On-prem vs cloud

The cloud side · same engines, different owner

On-prem vs cloud: the physics stays, the 3 AM work moves

I wrote this page because the cloud changes who does the work, not how the database works. A managed database does not repeal anything on this site. A commit on Aurora still waits for log writes. An Atlas oplog window is still size ÷ write rate. Autovacuum still runs on RDS, and it still falls behind. What changes is the ownership boundary. The provider absorbs the sysadmin and storage layers wholesale, part of the DBA layer, and none of the query layer. After this page you will price that boundary per engine, and you will know which checks stay yours.

6 copies, 3 AZsAurora ships redo records to a storage quorum: six copies across three availability zones, growing in 10 GB increments up to 256 TiB. The compute node holds no WAL files and no data pages of its own. Storage applies the redo and keeps the pages, so there is no classic checkpoint and no torn page to repair. Storage provisioning was a storage-team job on-prem. Here it simply stops existing as a task.
~60-120 sTypical RDS Multi-AZ failover time. The standby is promoted and the endpoint's DNS flips. On-prem, the same failover is your script, your monitoring, and your pager. It is measured in minutes if it is rehearsed, hours if it is not.
35 daysMaximum automated-backup retention on RDS. Point-in-time recovery to any second inside that window, with no archive scripting. The on-prem equivalent is a base backup plus a WAL/binlog archive you built, monitored, and restore-tested yourself.

PostgreSQL RDS for PostgreSQL · Aurora PostgreSQL · Cloud SQL · Azure Database

The problem cloud solves: provisioning, patching, backup plumbing, and failover mechanics for the most correctness-sensitive engine. That work is identical at every company and expert at none of them by default. Why it is easy to maintain: automated backups with PITR, one-click Multi-AZ, parameter groups instead of config files, and minor-version upgrades scheduled by the provider.

The cloud takes over

  • Provisioning, OS and engine patching, hardware failure
  • Automated backups + PITR (up to 35 days on RDS); storage scaling
  • Multi-AZ failover mechanics (~60-120 s, endpoint unchanged)
  • Aurora: the storage layer itself: 6 copies across 3 AZs, up to 256 TiB
  • Monitoring plumbing (Performance Insights, enhanced monitoring)

The DBA still owns

  • Schema, indexes, query plans: every incident in "When it hurts" still applies
  • Autovacuum health: it runs, it can still fall behind, and wraparound is still possible
  • Parameter group tuning: shared_buffers is set as a fraction of instance RAM; some parameters are locked outright
  • Connection pooling (RDS Proxy or your own PgBouncer) and lag monitoring
  • Restore tests: the button is theirs, the verification is yours

Tradeoffs: no superuser and no host. On RDS you cannot read pg_wal files or run pg_waldump. On Aurora there are no WAL files at all: the compute node ships redo to the storage layer, so there is nothing to read and no checkpoint to watch. You cannot install an unlisted extension, or set parameters the provider locks. Failover timing and maintenance windows are the provider's schedule. Cost is a per-hour instance plus per-GB plus per-I/O rent that beats on-prem at small scale and can exceed it at large, steady scale.

ConcernOn-prem PostgreSQLManaged (RDS / Aurora / Cloud SQL)
Provisioning & patchingYour team: install, minor/major upgrades, OS patchesProvider: console/API provisioning; upgrades scheduled, major versions still planned by you
Backups & PITRBase backups + WAL archiving you build and restore-testAutomated; PITR to any second within retention (≤ 35 days on RDS)
HA / failoverYour tooling (Patroni etc.), your rehearsed runbookMulti-AZ promotion ~60-120 s; Aurora storage survives AZ loss by design
Files & logs accessFull: data directory, pg_wal, pg_waldump, OS toolsNone at the file level; logs via console/API download only
Tuning surfaceEvery parameter, plus OS and filesystem choicesParameter groups; a locked subset; no OS, no filesystem
Cost shape & exitHardware + people; data is files you can copy anywhereHourly rent scaling with instance, storage, I/O; exit is a logical dump/replication project

Four ways to run PostgreSQL

The managed section above is one of four. Same engine, three other owners. Each block opens with the problem that option solves.

On-prem

The problem it solves: full control, and no per-hour rent. The database behaves exactly as configured. Every extension, every parameter, every file.

You install Postgres on your own servers. The files live where you put them: pg_wal, base, postgresql.conf.

What you still own: the whole stack. OS patching, backups, WAL archiving, failover, storage, and the pager. Backups and restore tests, replication and failover, autovacuum health, and parameter tuning. Every incident on the home page still applies, and you are the one who answers it.

EC2

The problem it solves: the same control, without buying hardware. You want a machine in minutes, and you want to resize it or throw it away.

You install the same Postgres binaries on the VM. Same files, same parameters, same ownership. What it solves: no procurement, fast provisioning, EBS snapshots for disk-level copies. What it costs: every operational job stays yours, plus the VM bill and the EBS bill. Backups still need pg_basebackup and a WAL archive you monitor. Failover still needs Patroni or a runbook.

pg_basebackup -D /backup/main -Ft -z -P

Kubernetes

The problem it solves: your apps already run in Kubernetes, and you want the database declared in YAML like everything else.

Two operators I verified, as of Nov 2026. CloudNativePG runs a Cluster resource, apiVersion postgresql.cnpg.io/v1, with instances 3, native streaming replication, and automated failover. The Barman Cloud plugin handles backups and point-in-time recovery. A Pooler resource runs PgBouncer in front. The Zalando Postgres Operator runs apiVersion acid.zalan.do/v1, with Patroni underneath and the Spilo image. It builds standby clusters from S3 or Google Cloud Storage WAL archives, or from a remote primary. Passwords are hashed with scram-sha-256.

What you still own: the cluster definition, the storage class, the backup destination, version upgrades, and the same Postgres tuning: shared_buffers, autovacuum, max_wal_size. The Zalando operator states plainly that monitoring and tuning are out of scope.

apiVersion: postgresql.cnpg.io/v1 kind: Cluster metadata: name: shop-db spec: instances: 3 storage: size: 20Gi

Side by side: who does what

Where it lives

on-prema server you own, Postgres installed on it
→
EC2a VM you rent, same Postgres on it
→
Kubernetesa pod, declared in YAML, run by an operator
→
managed cloudthe provider's control plane, no host at all
On-premKubernetesManaged cloud
Problem it solvesSame control, no hardwareDatabase declared in YAML like everything elseProvisioning, patching, backups, failover handled
Who patchesYou, OS and engineThe operator provisions; you own version upgradesThe provider
Who backs upYou, same as on-premBarman Cloud plugin, backups and point-in-time recoveryAutomated backups with point-in-time recovery, up to 35 days on RDS
Who fails overYou, Patroni or a runbookThe operator, automated failoverThe provider, Multi-AZ in 60 to 120 seconds, Aurora under 30
What you still ownEvery operational job, plus the VM and EBS billCluster definition, storage class, backup destination, version upgrades, Postgres tuningSchema, indexes, query plans, autovacuum health, connection pooling, restore tests, the bill
Cost shapeVM plus EBS billCluster plus storage plus operator overheadPer-hour instance plus per-GB plus per-I/O rent

Sources: CloudNativePG docs · Zalando Postgres Operator · Aurora overview, AWS docs · RDS Multi-AZ · Cloud SQL features

EC2, once, for all three engines

The EC2 column is identical for all three engines, so it lives here once instead of three times. The only row that differs is failover, where each engine names its own tooling.

ConcernEC2, all three engines
Problem it solvesSame control, no hardware
Who patchesYou, OS and engine
Who backs upYou, same as on-prem
Who fails overYou, by runbook: Patroni for PostgreSQL, your orchestrator for MySQL, a runbook for MongoDB
What you still ownEvery operational job, plus the VM and EBS bill
Cost shapeVM plus EBS bill

MySQL · InnoDB RDS for MySQL · Aurora MySQL · Cloud SQL for MySQL

The problem cloud solves: the operational machinery around InnoDB. Backups, replica provisioning, failover. That is for an engine whose typical deployment is many similar web workloads. Why it is easy to maintain: read replicas in minutes, automated snapshots plus binlog-based PITR, and on Aurora a shared storage layer that makes replica lag mostly a non-event because replicas read the same storage the writer writes.

The cloud takes over

  • Provisioning, patching, snapshot backups + PITR
  • Replica creation and Multi-AZ failover mechanics
  • Binlog retention management within the window you configure
  • Aurora: redo-driven storage layer: replicas share storage, failover is fast, storage auto-grows
  • Parameter delivery via parameter groups

The DBA still owns

  • Queries, indexes, and the purge/history-list problem: a long transaction pins purge on RDS exactly as on-prem
  • Buffer pool sizing, via parameter group, inside instance-class limits
  • Primary-key discipline: random UUID PKs fragment Aurora and RDS tables the same way
  • Replica lag on binlog-based replicas, and GTID consistency at failover
  • Durability settings: flush/sync choices still exist in the parameter group, and can still be set wrong

Tradeoffs: no SUPER privilege and no filesystem. On RDS, #innodb_redo/ and the binlog files are unreachable. On Aurora MySQL the redo files do not exist on the compute node at all: redo is shipped to the storage layer, which applies it. Binlog access is through stored procedures and retention settings, and some InnoDB internals (change buffer behavior, redo sizing on Aurora) are managed for you whether you like their values or not. Sharding remains your problem. Vitess runs on top, not inside.

ConcernOn-prem MySQLManaged (RDS / Aurora / Cloud SQL)
Provisioning & patchingYour team, per serverProvider; replicas and Multi-AZ in minutes
Backups & PITRXtraBackup/mysqldump + binlog archive you operateAutomated snapshots + binlog PITR within retention
HA / failoverYour orchestrator (or manual), GTID checks by handManaged promotion; Aurora replicas promote in ~tens of seconds
Files & logs accessFull datadir: .ibd, redo, binlog files, mysqlbinlogNo datadir; binlog via procedures/retention settings only
Tuning surfaceEvery variable, plus OS and storage layoutParameter groups; no SUPER; some internals provider-managed
Cost shape & exitHardware + people; mysqldump or replication out at willHourly rent + I/O charges (notably Aurora); exit via dump/DMS-style replication

Four ways to run MySQL

The managed section above is one of four. Same engine, three other owners. Each block opens with the problem that option solves.

On-prem

The problem it solves: full control over InnoDB and the two logs. You set innodb_buffer_pool_size yourself, you size the redo log, and you keep the binlog as long as your slowest replica needs it.

The files are shop/users.ibd, #innodb_redo/#ib_redo0, mysql-bin.000001, and undo_001.

What you still own: the OS, the backups, the binlog archive, replication, and failover. XtraBackup or mysqldump runs on a schedule you test. A replica that comes back after the binlog rolled off needs a full rebuild, so retention is a number you choose on purpose.

EC2

The problem it solves: the same control, no hardware. The engine is the same, the files are the same, the ownership is the same.

What it solves: machines in minutes, EBS snapshots, no procurement. What it costs: the VM bill, the EBS bill, and every job from the on-prem list. Binlog retention must still exceed your longest replica outage. Failover is still your orchestrator or your runbook. Nothing about the physics changes. Only the owner of the hardware does.

Kubernetes

The problem it solves: MySQL clusters declared in YAML, with failover and backups automated.

Two operators I verified, as of Nov 2026. The Percona Operator for MySQL runs a PerconaServerMySQL resource, with Orchestrator for async replication, HAProxy or MySQL Router in front, and XtraBackup for backups. Group Replication is generally available. Async replication is still a tech preview. Version 1.2.0 added cross-site ClusterSet replication. Version 1.3.0 added encrypted binlogs for point-in-time recovery. The Oracle MySQL Operator runs an InnoDBCluster resource, apiVersion mysql.oracle.com/v2, with three instances plus a Router. It manages the full lifecycle, including upgrades and backups, and a MySQLBackup resource runs backup jobs.

What you still own: the resource definition, the storage, the backup destination, the version, and the same InnoDB tuning: innodb_buffer_pool_size, innodb_redo_log_capacity, innodb_flush_log_at_trx_commit. Sharding stays your problem. Vitess runs on top, not inside.

apiVersion: mysql.oracle.com/v2 kind: InnoDBCluster metadata: name: shop-db spec: secretName: shop-db-secret instances: 3 router: instances: 1

Side by side: who does what

Where it lives

on-prema server you own, MySQL installed on it
→
EC2a VM you rent, same MySQL on it
→
Kubernetesa pod, declared in YAML, run by an operator
→
managed cloudthe provider's control plane, no host at all
On-premKubernetesManaged cloud
Problem it solvesSame control, no hardwareClusters declared in YAML, failover and backups automatedBackups, replica provisioning, failover handled
Who patchesYou, OS and engineThe operator runs the cluster lifecycleThe provider
Who backs upYou, same as on-premXtraBackup through the operatorAutomated snapshots plus binlog-based point-in-time recovery
Who fails overYou, your orchestrator or your runbookOrchestrator, or the operator's automationThe provider, Multi-AZ in 60 to 120 seconds, Aurora in tens of seconds
What you still ownSame jobs, plus the VM and EBS billResource definition, storage, backup destination, version, InnoDB tuning; sharding stays yoursQueries, indexes, purge and history list, buffer pool sizing, primary key discipline, replica lag, durability settings
Cost shapeVM plus EBS billCluster plus storageHourly rent plus I/O charges, notably Aurora

Sources: Percona Operator for MySQL architecture · Oracle MySQL Operator manual · Aurora overview, AWS docs · RDS Multi-AZ · Cloud SQL features

MongoDB · WiredTiger MongoDB Atlas (and compatible managed offerings)

The problem cloud solves: replica-set and sharded-cluster operations. Elections, member replacement, balancer supervision, backup consistency across shards. Those are the easiest parts of MongoDB to run badly by hand. Why it is easy to maintain: a replica set or a sharded cluster is a configuration choice in a console, snapshots and continuous backup are built in, and members are replaced by the platform instead of by a runbook.

The cloud takes over

  • Provisioning replica sets and sharded clusters; member replacement after failure
  • Elections happen on managed infrastructure with tested automation
  • Snapshots + continuous backup with PITR; cross-region cluster options
  • Patching and version upgrades as rolling operations
  • Monitoring and alerting plumbing (including oplog window visibility)

The DBA still owns

  • Schema design and indexing: the ESR rule and COLLSCAN economics are unchanged
  • The shard key: still chosen by you, still near-permanent, jumbo chunks still possible
  • Read/write concerns per application: Atlas cannot choose your durability
  • The oplog window math: Atlas shows the window; sizing the tier so the window fits your maintenance is your decision
  • Tier sizing and cost: an oversized cluster is the most common Atlas incident, and it is a billing incident

Tradeoffs: no host and no dbPath. journal/ files, WiredTiger.wt, and the rollback directory are not yours to inspect. Logs come through the UI/API, and only a subset of setParameter knobs are exposed. Network design (peering, private endpoints) becomes part of the database's latency profile. In exchange, the entire on-prem ownership table from Start here, sysadmin, storage, most of operations, collapses into the provider's column.

ConcernOn-prem MongoDBMongoDB Atlas
Provisioning & patchingYour team: mongod installs, rolling upgrades by runbookConsole/API; rolling upgrades operated by the platform
Backups & PITRmongodump/snapshots you schedule, store, and restore-testBuilt-in snapshots + continuous backup with PITR
HA / failoverYour replica set design, election tuning, member replacementManaged members across zones; elections on platform automation
Files & logs accessFull dbPath: .wt files, journal/, rollback/, mongod.logNo dbPath; logs and metrics via UI/API only
Tuning surfaceFull setParameter + config file + OS/storage choicesTier size and a curated parameter subset; shard key still fully yours
Cost shape & exitHardware + people; mongodump out at willPer-tier hourly rent (RAM/CPU/storage bundled); exit via live migration or dump

Four ways to run MongoDB

The managed section above is one of four. Same engine, three other owners. Each block opens with the problem that option solves.

On-prem

The problem it solves: full control over replica sets and sharding, no cloud bill.

You install mongod yourself, design the replica set, tune elections, replace members by runbook, and schedule backups with mongodump or filesystem snapshots. The files are collection-*.wt, index-*.wt, journal/WiredTigerLog.*, and local.oplog.rs.

What you still own: rolling upgrades, member replacement, backup storage, restore tests, and the oplog window math. The window is oplog size divided by write rate. A secondary down longer than the window needs a full initial sync. Check the window before any planned downtime:

rs.printReplicationInfo()

EC2

The problem it solves: the same control, no hardware. The engine is the same, the files are the same, the ownership is the same.

What it solves: machines in minutes, EBS snapshots, no procurement. What it costs: the VM bill, the EBS bill, and every job from the on-prem list. The oplog window math does not change. A secondary that falls behind the window still needs a full sync, wherever the machine lives.

Kubernetes

The problem it solves: replica sets and sharded clusters declared in YAML.

The MongoDB Controllers for Kubernetes Operator, version 1.9 as of Nov 2026, defines a MongoDB resource with three types: Standalone, ReplicaSet, and ShardedCluster. You set members and shardCount in the spec. The operator creates the StatefulSets: one pod per member, plus mongos and config server pods for sharded clusters. The Community edition covers replica sets. Sharded clusters need Enterprise Advanced.

What you still own: the resource definition, the storage, the backup destination, the version, the shard key, and the same WiredTiger tuning: cacheSizeGB and oplog size. The shard key stays near-permanent.

apiVersion: mongodb.com/v1 kind: MongoDB metadata: name: shop-db spec: type: ReplicaSet members: 3 version: 8.0.0

Side by side: who does what

Where it lives

on-prema server you own, mongod installed on it
→
EC2a VM you rent, same mongod on it
→
Kubernetespods, declared in YAML, run by an operator
→
managed cloudAtlas, no host at all
On-premKubernetesManaged cloud
Problem it solvesSame control, no hardwareReplica sets and sharded clusters declared in YAMLReplica set and sharded cluster operations handled
Who patchesYou, OS and engineThe operator automates provisioning and member managementThe provider
Who backs upYou, same as on-premThe operator's backup jobsContinuous cloud backups with point-in-time recovery, recovery point as low as 1 minute
Who fails overYou, by runbookThe operatorAutomatic, three-node replica set by default
What you still ownSame jobs, plus the VM and EBS billResource definition, storage, backup destination, version, shard key, WiredTiger tuningSchema and indexing, the shard key, read and write concerns, oplog window math, tier sizing
Cost shapeVM plus EBS billCluster plus storagePer-tier hourly rent, RAM, CPU, storage bundled

Sources: MongoDB Kubernetes Operator reference · Atlas backup guidance

The decision rule that survives every vendor: cloud removes operational work whose difficulty is the same everywhere. Patching, failover mechanics, backup plumbing. It removes none of the work whose difficulty is specific to your data. Schema, indexes, shard keys, cleanup health, the window math. If your incidents are mostly the first kind, managed wins. If they are mostly the second kind, and the eight cards in "When it hurts" say they usually are, the cloud changes who holds the pager, not whether it rings.

Before you leave, check this: run SELECT replay_lag FROM pg_stat_replication; If lag is over 5 seconds, your replicas are not where you think they are.