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.
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.
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.
| Concern | On-prem PostgreSQL | Managed (RDS / Aurora / Cloud SQL) |
|---|---|---|
| Provisioning & patching | Your team: install, minor/major upgrades, OS patches | Provider: console/API provisioning; upgrades scheduled, major versions still planned by you |
| Backups & PITR | Base backups + WAL archiving you build and restore-test | Automated; PITR to any second within retention (≤ 35 days on RDS) |
| HA / failover | Your tooling (Patroni etc.), your rehearsed runbook | Multi-AZ promotion ~60-120 s; Aurora storage survives AZ loss by design |
| Files & logs access | Full: data directory, pg_wal, pg_waldump, OS tools | None at the file level; logs via console/API download only |
| Tuning surface | Every parameter, plus OS and filesystem choices | Parameter groups; a locked subset; no OS, no filesystem |
| Cost shape & exit | Hardware + people; data is files you can copy anywhere | Hourly rent scaling with instance, storage, I/O; exit is a logical dump/replication project |
The managed section above is one of four. Same engine, three other owners. Each block opens with the problem that option solves.
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.
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.
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.
Where it lives
| On-prem | Kubernetes | Managed cloud | |
|---|---|---|---|
| Problem it solves | Same control, no hardware | Database declared in YAML like everything else | Provisioning, patching, backups, failover handled |
| Who patches | You, OS and engine | The operator provisions; you own version upgrades | The provider |
| Who backs up | You, same as on-prem | Barman Cloud plugin, backups and point-in-time recovery | Automated backups with point-in-time recovery, up to 35 days on RDS |
| Who fails over | You, Patroni or a runbook | The operator, automated failover | The provider, Multi-AZ in 60 to 120 seconds, Aurora under 30 |
| What you still own | Every operational job, plus the VM and EBS bill | Cluster definition, storage class, backup destination, version upgrades, Postgres tuning | Schema, indexes, query plans, autovacuum health, connection pooling, restore tests, the bill |
| Cost shape | VM plus EBS bill | Cluster plus storage plus operator overhead | Per-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
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.
| Concern | EC2, all three engines |
|---|---|
| Problem it solves | Same control, no hardware |
| Who patches | You, OS and engine |
| Who backs up | You, same as on-prem |
| Who fails over | You, by runbook: Patroni for PostgreSQL, your orchestrator for MySQL, a runbook for MongoDB |
| What you still own | Every operational job, plus the VM and EBS bill |
| Cost shape | VM plus EBS bill |
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.
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.
| Concern | On-prem MySQL | Managed (RDS / Aurora / Cloud SQL) |
|---|---|---|
| Provisioning & patching | Your team, per server | Provider; replicas and Multi-AZ in minutes |
| Backups & PITR | XtraBackup/mysqldump + binlog archive you operate | Automated snapshots + binlog PITR within retention |
| HA / failover | Your orchestrator (or manual), GTID checks by hand | Managed promotion; Aurora replicas promote in ~tens of seconds |
| Files & logs access | Full datadir: .ibd, redo, binlog files, mysqlbinlog | No datadir; binlog via procedures/retention settings only |
| Tuning surface | Every variable, plus OS and storage layout | Parameter groups; no SUPER; some internals provider-managed |
| Cost shape & exit | Hardware + people; mysqldump or replication out at will | Hourly rent + I/O charges (notably Aurora); exit via dump/DMS-style replication |
The managed section above is one of four. Same engine, three other owners. Each block opens with the problem that option solves.
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.
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.
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.
Where it lives
| On-prem | Kubernetes | Managed cloud | |
|---|---|---|---|
| Problem it solves | Same control, no hardware | Clusters declared in YAML, failover and backups automated | Backups, replica provisioning, failover handled |
| Who patches | You, OS and engine | The operator runs the cluster lifecycle | The provider |
| Who backs up | You, same as on-prem | XtraBackup through the operator | Automated snapshots plus binlog-based point-in-time recovery |
| Who fails over | You, your orchestrator or your runbook | Orchestrator, or the operator's automation | The provider, Multi-AZ in 60 to 120 seconds, Aurora in tens of seconds |
| What you still own | Same jobs, plus the VM and EBS bill | Resource definition, storage, backup destination, version, InnoDB tuning; sharding stays yours | Queries, indexes, purge and history list, buffer pool sizing, primary key discipline, replica lag, durability settings |
| Cost shape | VM plus EBS bill | Cluster plus storage | Hourly 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
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.
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.
| Concern | On-prem MongoDB | MongoDB Atlas |
|---|---|---|
| Provisioning & patching | Your team: mongod installs, rolling upgrades by runbook | Console/API; rolling upgrades operated by the platform |
| Backups & PITR | mongodump/snapshots you schedule, store, and restore-test | Built-in snapshots + continuous backup with PITR |
| HA / failover | Your replica set design, election tuning, member replacement | Managed members across zones; elections on platform automation |
| Files & logs access | Full dbPath: .wt files, journal/, rollback/, mongod.log | No dbPath; logs and metrics via UI/API only |
| Tuning surface | Full setParameter + config file + OS/storage choices | Tier size and a curated parameter subset; shard key still fully yours |
| Cost shape & exit | Hardware + people; mongodump out at will | Per-tier hourly rent (RAM/CPU/storage bundled); exit via live migration or dump |
The managed section above is one of four. Same engine, three other owners. Each block opens with the problem that option solves.
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:
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.
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.
Where it lives
| On-prem | Kubernetes | Managed cloud | |
|---|---|---|---|
| Problem it solves | Same control, no hardware | Replica sets and sharded clusters declared in YAML | Replica set and sharded cluster operations handled |
| Who patches | You, OS and engine | The operator automates provisioning and member management | The provider |
| Who backs up | You, same as on-prem | The operator's backup jobs | Continuous cloud backups with point-in-time recovery, recovery point as low as 1 minute |
| Who fails over | You, by runbook | The operator | Automatic, three-node replica set by default |
| What you still own | Same jobs, plus the VM and EBS bill | Resource definition, storage, backup destination, version, shard key, WiredTiger tuning | Schema and indexing, the shard key, read and write concerns, oplog window math, tier sizing |
| Cost shape | VM plus EBS bill | Cluster plus storage | Per-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.