Home / Guides
Comparison

Aurora vs RDS: Which One to Migrate To

By · October 20, 2026 · 12 min read

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:

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.

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