The short version
Aurora vs RDS comes down to storage. RDS runs the stock engine on an EBS-style volume you size and pay for by the GB allocated, with a synchronous standby that cannot take reads. Aurora (MySQL or PostgreSQL only) puts every instance on one shared cluster volume kept in three Availability Zones, so replicas are cheap to add, fail over faster, and you pay for storage actually used, plus either a per-I/O charge (Standard) or a higher flat rate (I/O-Optimized). If you run Oracle, SQL Server, Db2 or MariaDB, or a small steady database, RDS is the answer. If you need many readers, fast failover, cross-Region replicas or spiky load, look at Aurora, and measure your I/O before you pick the billing mode.
Aurora vs RDS at a glance
RDS here means RDS for MySQL or PostgreSQL, the engines Aurora competes with.
| RDS for MySQL / PostgreSQL | Aurora MySQL / PostgreSQL | |
|---|---|---|
| Engines | Db2, MariaDB, SQL Server, MySQL, Oracle, PostgreSQL | MySQL- and PostgreSQL-compatible only |
| Storage | gp2/gp3 or io1/io2 volume per instance | One cluster volume shared by all instances, copies in three AZs |
| Growth | You allocate size | Grows on its own, up to 256 TiB on specific versions |
| High availability | Multi-AZ standby, synchronous, no reads | Any reader can be promoted |
| Failover | Typically 60 to 120 seconds | Usually under 60 seconds, often under 30 |
| Read scaling | Up to 15 read replicas (MySQL), async, each with its own copy of the data | Up to 15 Aurora Replicas on the same volume, lag usually well under 100 ms |
| Cross-Region | Cross-Region read replicas | Global Database, up to 10 secondary Regions |
| Undo a bad DELETE | Restore from a backup | Backtrack in place (Aurora MySQL only, 72 hours max) |
| Variable load | Pick an instance class | Aurora serverless, 0 to 256 ACUs (MySQL), to 384 (PostgreSQL) |
| I/O billing | Part of the storage type you buy | Standard: per million I/Os. I/O-Optimized: none |
Sources for the rows: RDS engines, RDS storage types, Aurora storage, Multi-AZ DB instance, Multi-AZ failover time, Aurora high availability, RDS for MySQL read replicas, Aurora replication, Global Database, Backtrack, Aurora serverless.
What is the difference between RDS and Aurora?
The storage layer. On RDS, each instance has its own volume, and a read replica is a separate copy kept up to date by the engine's own replication: asynchronous, using the engine's built-in replication. A replica of a 2 TB database is another 2 TB volume.
On Aurora, the cluster volume holds the data and the instances only attach to it. AWS writes that adding an instance is quick "because Aurora doesn't make a new copy of the table data". Writes go synchronously to six storage nodes across Availability Zones, no matter how many instances you run. A one-instance Aurora cluster still has its data in three AZs; what it lacks is a warm instance to fail over to.
RDS has a middle option worth knowing: the Multi-AZ DB cluster, one writer and two readable standbys in three AZs with semisynchronous replication.
Failover and read replicas
A classic Multi-AZ DB instance keeps a synchronous standby you cannot query; AWS says "You can't use a standby replica to serve read traffic". Its failover typically takes 60 to 120 seconds. Read capacity comes from read replicas you create and delete by hand, since RDS does not autoscale them.
Aurora promotes a reader. With at least one replica, service is typically back in under 60 seconds and often under 30. Without a replica, Aurora recreates the writer, which typically takes under 10 minutes. You set promotion tiers 0 to 15 to choose which reader wins.
Engine versions and features that only exist on one side
RDS covers six engines. Aurora covers two, and its MySQL flavour has its own version line: Aurora MySQL 3.x is wire-compatible with MySQL 8.0.23 or higher, and from 8.4 the Aurora version number matches the MySQL version.
Aurora-only features that change the decision:
- Backtrack rewinds the whole cluster to a time in the last 72 hours, in minutes, without a restore. It is Aurora MySQL only, must be switched on when the cluster is created or restored from a snapshot, and you cannot create cross-Region read replicas from a backtrack-enabled cluster.
- Global Database replicates at the storage layer to up to 10 other Regions with latency "typically under a second". It does not support Backtrack, so you choose one.
- Aurora serverless scales each instance in steps as small as 0.5 ACU, an ACU being about 2 GiB of memory with matching CPU, and recent versions scale to zero when idle. Provisioned and serverless instances can sit in the same cluster.
Is Aurora cheaper than RDS?
Sometimes, and the pricing pages will not tell you which case you are in without your own numbers. Prices below are from the Aurora pricing page, US East (N. Virginia), as of October 2026, taken from the worked examples on that page: Aurora Standard storage is $0.10 per GB-month plus $0.20 per million I/Os; Aurora I/O-Optimized storage is $0.225 per GB-month with no I/O charge; the db.r6i.large instance in its example costs $0.29 an hour on Standard and $0.377 on I/O-Optimized. I could not read RDS instance or gp3 rates from the RDS for MySQL pricing page (the rate tables did not render), so I am not quoting them; open it for your Region and instance class.
Two structural points hold regardless of rates. Aurora bills the storage you use, and space freed by dropping tables shrinks the bill, where on RDS you choose the volume size. And Aurora replicas add instance cost but no extra copy of the data, while every RDS read replica brings its own volume.
Aurora Standard vs I/O-Optimized: the 25% rule
AWS's own guidance: I/O-Optimized "is the best choice when your I/O spending is 25% or more of your total Aurora database spending", Standard below that. You can move from Standard to I/O-Optimized once every 30 days and back at any time.
The number that counts is what Aurora bills: VolumeReadIOPs, reads of "database pages that aren't in the buffer cache and must be loaded from storage", and VolumeWriteIOPs. The pricing page's examples count reads as 16 KB pages and writes as 4 KB units. Before you have an Aurora cluster, the closest thing is your current server's cache misses and log volume. Here is how I measured those, and what the numbers looked like.
Measuring your own I/O profile on MySQL
I loaded 2,000,000 rows (332 MB of table and index) into MySQL 8.4.11 with the default 128 MB InnoDB buffer pool, so most of the table could not stay in memory. Then I ran 20,000 primary-key lookups and 2,000 single-row updates at random ids, from a stored procedure, and read the counters before and 90 seconds after. Per-file numbers come from performance_schema.file_summary_by_instance, which isolates my table from the other databases on the server; the global ones are InnoDB status variables.
SELECT SUBSTRING_INDEX(FILE_NAME,'/',-2) AS file, COUNT_READ, COUNT_WRITE,
SUM_NUMBER_OF_BYTES_READ AS bytes_read, SUM_NUMBER_OF_BYTES_WRITE AS bytes_written
FROM performance_schema.file_summary_by_instance
WHERE FILE_NAME LIKE '%aurora_vs_rds%';
SHOW GLOBAL STATUS WHERE Variable_name IN
('Innodb_buffer_pool_read_requests','Innodb_buffer_pool_reads',
'Innodb_data_reads','Innodb_data_writes','Innodb_pages_written','Innodb_os_log_written');
Before:
| aurora_vs_rds/orders.ibd | 198784 | 55184 | 3256877056 | 1432092672 |
| Innodb_buffer_pool_read_requests | 15952907 |
| Innodb_buffer_pool_reads | 12361 |
| Innodb_os_log_written | 610494464 |
90 seconds after the workload (it ran from 16:47:20 to 16:47:21):
| aurora_vs_rds/orders.ibd | 217196 | 57075 | 3558539264 | 1463074816 |
| Innodb_buffer_pool_read_requests | 16098316 |
| Innodb_buffer_pool_reads | 30935 |
| Innodb_os_log_written | 614700544 |
The table file took 18,412 reads totalling 301,662,208 bytes, exactly 16,384 bytes each, so one read per 16 KB page. Innodb_buffer_pool_reads rose by 18,574 against 145,409 logical requests: an 87% hit rate, and about 0.84 storage reads per statement. The 1,891 page writes to the table file landed during the 90 seconds after the procedure finished, flushed in the background. The redo log grew by 4,206,080 bytes.
A warning from my first attempt: I wrote WHERE id = 1 + FLOOR(RAND()*2000000), and MySQL evaluated RAND() per row, turning every lookup into a full scan: 144,491 reads and 2.3 GB off disk before the procedure failed with ERROR 1172 (42000): Result consisted of more than one row. On Standard billing, one query shape like that in production is a line item.
The same check on PostgreSQL
On PostgreSQL 16.14, same data (503 MB with the index), same workload as a DO block. pg_stat_database is per database, so it ignores everything else on the server; WAL position from pg_current_wal_lsn() is server-wide.
SELECT blks_read, blks_hit, tup_returned, tup_fetched, tup_updated, xact_commit,
pg_current_wal_lsn() AS wal_lsn
FROM pg_stat_database WHERE datname = current_database();
== before
blks_read | blks_hit | tup_returned | tup_fetched | tup_updated | xact_commit | wal_lsn
110354 | 6490748 | 4003377 | 1981 | 2 | 23 | 0/2FFA9AB0
workload seconds 0.82
== after
blks_read | blks_hit | tup_returned | tup_fetched | tup_updated | xact_commit | wal_lsn
135027 | 6577050 | 4025809 | 24410 | 2002 | 27 | 0/3245E7B0
wal bytes 38489344
blks_read 24673
blks_hit 86302
tup_fetched 22429
tup_updated 2000
24,673 blocks missed PostgreSQL's cache against 86,302 hits, a 78% hit rate. The docs note that blks_hit counts only PostgreSQL's own buffer cache, so some of those "reads" came from the OS page cache. The WAL grew 38 MB for 2,000 one-row updates, nine times what MySQL's redo log grew. Part of that is full_page_writes: the first change to a page after a checkpoint puts the whole page into WAL, and random updates touch a new page almost every time. The rest is other activity on a shared server.
Turning counters into a Standard vs I/O-Optimized answer
Take the two snapshots an hour apart at your busiest time, on the real server.
- Reads per second: the change in
Innodb_buffer_pool_reads(MySQL) orblks_read(PostgreSQL), divided by 3,600. - Writes per second: the change in
Innodb_os_log_writtenor the WAL byte difference, divided by 4,096 and by 3,600. This is my own rough proxy, built on the pricing page counting writes in 4 KB units, and Aurora does not write data pages the way stock InnoDB or PostgreSQL does; treat it as an order of magnitude.
Then do the arithmetic with the published rates. One db.r6i.large writer with 200 GB for 720 hours costs $208.80 + $20.00 = $228.80 on Standard before I/O, and $271.44 + $45.00 = $316.44 on I/O-Optimized. The gap is $87.64, which buys 438 million I/Os at $0.20 per million, or about 169 I/Os per second averaged over the month. At that point I/O is 27.7% of the Standard bill, close to AWS's 25% line. Above about 169 a second on that shape, I/O-Optimized wins; below, Standard does. More storage per instance moves the break-even up, because I/O-Optimized storage costs more per GB. Backups and data transfer are left out of both sides.
The real test is cheap: run on Standard for a week, read VolumeReadIOPs and VolumeWriteIOPs, and switch if the I/O share is over 25%.
When to use Aurora vs RDS
Stay on RDS when the engine is Oracle, SQL Server, Db2 or MariaDB; when the database is small and steady and one Multi-AZ instance is enough; or when you need the exact community MySQL or PostgreSQL version on day one.
Move to Aurora when you need several read replicas without paying for several copies of the data, when a 60 to 120 second failover is too long, when you want Global Database or Backtrack, or when load swings hard enough that serverless capacity beats a fixed instance.
If you are on RDS for MySQL today, the low-risk path is an Aurora read replica of the RDS instance, promoted when lag reaches zero; AWS warns it takes roughly several hours per TiB. The full procedure, and the route from your own server, is in MySQL to Aurora: Moving from RDS or Your Own Server. For PostgreSQL on RDS, see On-Prem PostgreSQL to Amazon RDS, and for Oracle, Oracle to Aurora PostgreSQL on AWS.
Sources
- Amazon Aurora storage
- Replication with Amazon Aurora
- High availability for Amazon Aurora
- How Aurora serverless works
- Backtracking an Aurora DB cluster
- Using Amazon Aurora Global Database
- Amazon CloudWatch metrics for Amazon Aurora
- Aurora MySQL version numbers
- What is Amazon Aurora?
- Migrating RDS for MySQL to Aurora with an Aurora read replica
- What is Amazon RDS?
- Amazon RDS DB instance storage
- Multi-AZ DB instance deployments
- Failing over a Multi-AZ DB instance
- Multi-AZ DB cluster deployments
- Working with DB instance read replicas
- Working with MySQL read replicas
- Amazon Aurora pricing
- Amazon RDS for MySQL pricing
- MySQL 8.4 server status variables
- MySQL 8.4 file I/O summary tables
- PostgreSQL 16: the cumulative statistics system
- PostgreSQL 16: system administration functions
- PostgreSQL 16: write ahead log settings