Every SAA-C03 guide, including our own AWS databases guide for the SAA-C03, describes Amazon Aurora in about six bullets: MySQL and PostgreSQL compatible, six copies of your data across three Availability Zones, up to 15 read replicas, a Global Database option, a serverless option, and Backtrack. Those bullets answer the one question that asks you to choose Aurora over RDS.
They do not answer the questions that assume you already chose Aurora and now ask what happens next. Which endpoint should the reporting team use so that their queries never land on the production-sized readers? Why did the application keep hitting the same replica when you “load balanced” through the reader endpoint? Which replica becomes the writer when the primary dies, and how do you control that? What is the cheapest way to give the development team a copy of a 4 TB production database by lunchtime? Why can’t you turn on Backtrack for the cluster you already have, and why is it not available for PostgreSQL at all? What is the difference between a Global Database switchover and a failover, and which one promises zero data loss? When is Aurora I/O-Optimized cheaper than Aurora Standard?
Each of those has a precise answer in the Aurora User Guide. This post collects them. Read it once for the model, then use the scenario drill near the end to check that the rules stuck. Everything below was checked against the AWS documentation in November 2026, and several facts have changed since most study material was written. Those changes are flagged.
The Mental Model: Compute Is Disposable, Storage Is the Cluster
An Aurora DB cluster is two things that scale independently:
- One cluster volume. A single virtual SSD-backed volume whose data is replicated as six copies across three Availability Zones in one Region. The volume holds everything persistent: tables, indexes, BLOBs, stored procedures, system tables and the binary log. The documentation is explicit that the amount of replication “is independent of the number of DB instances in your cluster”. A cluster with one instance still has six copies.
- Zero or more DB instances that attach to that volume. Exactly one is the writer (primary). Up to 15 are read-only Aurora Replicas (reader instances). Instances can be provisioned (a fixed instance class) or Aurora serverless (the
db.serverlessclass that scales in ACUs), and a single cluster can mix both.
Because the data lives in the volume and not on the instances, three things that are slow or impossible with ordinary RDS become cheap in Aurora:
| Operation | Why Aurora makes it cheap |
|---|---|
| Adding a reader | The new instance attaches to the existing volume. Nothing is copied. |
| Removing a reader | The instance goes away. The data stays. Only deleting the whole cluster removes data. |
| Replica lag | Replicas read the same pages the writer wrote, so lag is “usually much less than 100 milliseconds” and is not a function of how many replicas exist. |
| Failover | A replica is promoted to writer. No storage needs to be re-synchronized. |
| Cloning | A new cluster points at the same pages until either side changes one (copy-on-write). |
Hold on to this split. Nearly every Aurora exam question is really a question about one side of it: something about the volume (storage growth, cloning, Backtrack, replication to other Regions) or something about the instances (endpoints, failover, promotion tiers, serverless capacity).
What the writer does that readers cannot
The writer handles all DDL (CREATE TABLE, ALTER TABLE) and all DML (INSERT, UPDATE, DELETE). Readers process read-only statements such as SELECT. If a session connected through the reader endpoint tries to write, it gets an error, with one exception covered below: a cluster with no replicas at all, where the reader endpoint resolves to the writer.
Storage: How the Cluster Volume Grows, Shrinks and Is Billed
Automatic growth and the two ceilings
The cluster volume grows automatically as data arrives. There is no provisioned size and no “allocated storage” knob. The ceiling depends on the engine version, and this is a fact that has moved:
| Maximum cluster volume | Engine versions |
|---|---|
| 256 TiB | Aurora PostgreSQL 17.5+, 16.9+, 15.13+; Aurora MySQL 3.10 (MySQL 8.0.42) and higher |
| 128 TiB | All earlier Aurora PostgreSQL versions; Aurora MySQL 3 below 3.10; Aurora MySQL 2 (2.09 and higher) |
If a study guide says Aurora tops out at 64 TiB or 128 TiB, it is describing an older generation. The exam is unlikely to test the exact ceiling, but it does test the shape: storage is automatic and you never pre-provision it. Watch AuroraVolumeBytesLeftTotal to know how far from the ceiling you are, and VolumeBytesUsed to know what you are paying for.
Dynamic resizing: dropping tables now shrinks your bill
Older Aurora versions could reuse freed space but never shrank the volume, so the high-water mark was what you paid for. Current versions have dynamic resizing: when you drop or truncate, the billed space goes down by a comparable amount. The documentation lists which versions have it:
| Engine | Versions with dynamic resizing |
|---|---|
| Aurora MySQL version 3 | All supported versions |
| Aurora MySQL version 2 | 2.11 and higher |
| Aurora PostgreSQL | All supported versions |
| Aurora serverless | All supported versions |
Three details make good distractors:
- It applies to operations that physically remove or resize tablespaces:
DROP TABLE,DROP DATABASE,TRUNCATE TABLE,ALTER TABLE ... DROP PARTITION. It does not apply toDELETE. After a largeDELETE, runOPTIMIZE TABLE(Aurora MySQL) or usepg_repack(Aurora PostgreSQL) to reorganize the table and let the volume shrink. - Space is reclaimed gradually, “at a rate of approximately 10 TB per day”, and only while the cluster is in an available state.
- For Aurora MySQL, set
innodb_file_per_tableto 1. Tables in the system tablespace never shrink it, because the system tablespace is never removed.
Aurora Standard vs Aurora I/O-Optimized
Every Aurora cluster has one of two storage configurations, and the exam has started asking about them because they change the pricing shape:
| Aurora Standard | Aurora I/O-Optimized | |
|---|---|---|
| What you pay for | Instance hours + storage + a per-million-request charge for read and write I/O | Instance hours + storage, with no charge for I/O operations (the instance and storage rates are higher) |
| When AWS says it wins | I/O spend is less than 25% of total Aurora spend | I/O spend is 25% or more of total Aurora spend |
| Switching rules | Switch from I/O-Optimized to Standard at any time | Switch from Standard to I/O-Optimized once every 30 days |
| Downtime when switching | None for non-NVMe instances (all serverless instances are non-NVMe); NVMe-based instance classes need an engine restart | Same |
| Scope | The whole cluster. It is a cluster property, not an instance property | Same |
The decision cue is the word predictable. An I/O-heavy workload whose monthly bill swings with request counts, and where the I/O line item is already a quarter of the bill, is the I/O-Optimized answer. A moderate workload with a small I/O line item stays on Standard. If a question mentions “switched to I/O-Optimized last week and now wants to switch again”, the 30-day rule says it has to wait; the reverse direction has no such wait.
Endpoints: The Four Kinds and What Each One Resolves To
An endpoint is a DNS name plus a port. Aurora uses them so you never hard-code instance hostnames or write your own routing logic. There are four kinds for a Regional cluster, plus one more for a Global Database.
| Endpoint | DNS shape | Resolves to | Created by |
|---|---|---|---|
| Cluster (writer) | name.cluster-xyz.region.rds.amazonaws.com | Whichever instance is currently the writer. Follows failover automatically | Aurora, one per cluster |
| Reader | name.cluster-ro-xyz.region.rds.amazonaws.com | One of the Aurora Replicas, chosen per connection. If there are no replicas, the writer | Aurora, one per cluster |
| Instance | instancename.xyz.region.rds.amazonaws.com | Exactly that instance | Aurora, one per instance |
| Custom | name.cluster-custom-xyz.region.rds.amazonaws.com | One of the instances you put in a group | You, up to 5 per cluster |
| Global Database writer | A global endpoint | The cluster endpoint of whichever Regional cluster is currently primary | Aurora, when you add a Region |
The reader endpoint balances connections, not queries
This is the single most-missed Aurora endpoint fact. The documentation says: “The reader endpoint balances connections to available Aurora Replicas in an Aurora DB cluster. It doesn’t balance individual queries. If you want to balance each query to distribute the read workload for a DB cluster, open a new connection to the reader endpoint for each query.”
The mechanism is DNS. Each resolution of the reader endpoint returns the address of one replica, and every connection you open through that address stays on that replica for its lifetime. An application with a long-lived connection pool that was created when only one replica existed will keep hammering that replica even after you add four more, because its pooled connections never reconnect. The fixes a question wants: recycle connections periodically, honor the short DNS TTL rather than caching resolutions in the JVM or OS, or put RDS Proxy in front, whose read-only endpoints balance the same way but reconnect faster when readers disappear.
Two more reader endpoint rules:
- Single-instance clusters. If the cluster contains only a primary and no replicas, the reader endpoint connects to the primary and you can write through it. A question that says “writes through the reader endpoint succeeded” is describing a cluster with no readers, not a bug.
- During failover the reader endpoint “might direct connections to the new primary DB instance of a DB cluster for a short time after an Aurora Replica is promoted”. Read-only sessions can briefly land on the writer. Design for it.
Instance endpoints are for diagnosis, not for applications
Instance endpoints exist so you can connect to one specific instance to tune or troubleshoot it. The documentation’s recommendation for high availability is blunt: the writer and reader endpoints “manage DB instance failover better than instance endpoints do”, because they change what they point at when an instance becomes unavailable and an instance endpoint never does. If you roll your own routing against instance endpoints, you must rediscover the topology with describe-db-clusters after every failover.
Custom endpoints: groups you define
A custom endpoint represents a set of instances you choose, and Aurora balances connections across that set the same way the reader endpoint does (DNS returns one member’s address at random; if a member is unavailable, subsequent connections go to the others). The documented use case is a cluster whose readers are not identical: two large instances for production reads and one small instance for ad hoc reporting, say, where you want to “direct internal users to low-capacity instances for report generation or ad hoc (one-time) querying, and direct production traffic to high-capacity instances”. Before custom endpoints existed, people did this with their own CNAME records and had to edit DNS every time the cluster changed.
The rules, all of which are testable:
| Rule | Detail |
|---|---|
| Quota | 5 custom endpoints per cluster (adjustable). None exist until you create one |
| Name | Up to 63 characters; unique per account per Region; not included in snapshots, so you re-create them after a restore |
| Types | READER (only reader instances can be members) or ANY (readers and the writer, each chosen with equal probability). The console always creates ANY; only the CLI/API can set READER |
| Role changes | With READER, membership is adjusted automatically on failover: a replica that is promoted to writer drops out of the endpoint. With ANY, Aurora does not change membership when roles change |
| Static list | The endpoint contains exactly the instances you named. Newly added replicas (manual or Auto Scaling) are not added |
| Exclusion list | The endpoint contains every instance in the cluster except the ones you named, including instances added later, provided their role matches the type. In the console this is the “Attach future instances added to this cluster” check box |
| Unavailable members | A stopped, rebooting or unhealthy replica stays a member; you just can’t connect to it through the endpoint until it recovers |
| Existing connections | Adding or removing an instance does not drop connections already open to it |
| Multiple membership | One instance can belong to several custom endpoints |
The documentation also notes that when you use custom endpoints, “you typically don’t use the reader endpoint for that cluster”, because the point is to stop connections landing on arbitrary readers.
Exam pattern: “reporting queries slow down the production read fleet” is a custom endpoint answer, not a new cluster, not a read replica of a different engine, and not DynamoDB. “New Auto Scaling replicas are not receiving reporting traffic” means the custom endpoint was created with a static list; switch it to an exclusion list.
High Availability and Failover
Multi-AZ for Aurora means readers in other AZs
With RDS, “Multi-AZ” means a synchronous standby that serves no traffic. With Aurora there is no idle standby: the data is already in three AZs, and a Multi-AZ Aurora cluster simply means you have at least one Aurora Replica in a different Availability Zone from the writer so that a failover target exists. You can convert a single-AZ Aurora cluster to Multi-AZ at any time by adding a reader and choosing another AZ.
What happens when the writer fails
Aurora recovers in one of two ways, and the time difference is the exam’s favorite Aurora number:
| Cluster has | What Aurora does | Documented time |
|---|---|---|
| One or more Aurora Replicas | Promotes a replica to writer. Reads and writes fail with an exception briefly | ”typically restored in less than 60 seconds, and often less than 30 seconds” |
| No replicas | Recreates the primary instance in the same AZ | ”typically takes less than 10 minutes” |
The documentation adds that the fastest recovery “is often to restart or to fail over to the same DB instance”, so Aurora may simply restart the writer rather than promote. Also, in Aurora MySQL only the writer and the replica being promoted restart during failover; the other replicas keep serving reads through the reader endpoint.
If an entire AZ is lost and the cluster has readers in other AZs, failover promotes one of them. If the writer and every reader were in the same AZ, or there is only one instance, you must manually create instances in another AZ. A question that says “the cluster had three instances but all in us-east-1a and the AZ failed” is testing exactly this.
RDS Proxy is the documented accelerator here: it keeps application connections open across failover and “bypasses Domain Name System (DNS) caches to reduce failover times by up to 66% for Aurora Multi-AZ databases”.
Promotion tiers: who becomes the writer
Each replica has a failover priority, also called a promotion tier, from 0 (highest) to 15 (lowest). The rules:
- On failure, the replica with the highest priority (lowest number) is promoted.
- If several replicas share the same tier, the largest one is promoted.
- If they share tier and size, Aurora picks one arbitrarily within that tier.
- Changing a replica’s priority does not trigger a failover.
- Replicas created by Aurora Auto Scaling are placed in tier 15 so that a manually created replica is always preferred.
- “After five unsuccessful failover attempts, promotion tiers are no longer considered.”
The exam uses tiers in two ways. The direct question: “ensure the db.r6g.4xlarge replica, not the db.r6g.large reporting replica, takes over” means set the big one to tier 0 and the small one to a higher number. The indirect question comes through Aurora serverless, where tiers 0 and 1 also decide whether a serverless reader scales with the writer (covered below).
Cluster cache management (Aurora PostgreSQL)
After failover the new writer starts with an empty buffer cache, so performance dips while it rereads hot pages from storage. Cluster cache management (CCM) in Aurora PostgreSQL keeps one designated reader’s buffer cache warm with the writer’s hot pages so that promotion is fast and fast afterwards. The documented requirements are specific: set apg_ccm_enabled to 1 in a custom cluster parameter group, set the writer to tier 0, set exactly one reader to tier 0, and that reader must be the same instance class and size as the writer. More than one tier-0 reader, a size mismatch, or a writer not in tier 0 silently disables CCM. CCM is not supported on Global Database secondary clusters, and AWS recommends running no workload on the designated reader. Check progress with SELECT * FROM aurora_ccm_status(); on the writer.
Aurora MySQL has no CCM, but both engines have a survivable page cache: the buffer pool lives in a process separate from the database engine, so a crash or restart of the engine on the same instance does not empty it.
Aurora Auto Scaling for replicas
Aurora Auto Scaling uses Application Auto Scaling to add and remove Aurora Replicas with a target tracking policy on a predefined metric (average CPU utilization of readers, or average connections of readers) or a custom metric. The facts worth knowing:
- Minimum and maximum capacity are each 0 to 15, and apply to the whole cluster across all its policies. One policy per target metric per cluster.
- The cluster needs at least one reader for the policy to work; with zero readers the metric is not calculated and the alarms stay inactive.
- New replicas get the same instance class as the writer, an ID prefixed
application-autoscaling-, and promotion tier 15. Auto Scaling only removes replicas it created. - Default scale-in and scale-out cooldowns are 300 seconds each; scale-in can be disabled, scale-out cannot.
- The target metric averages all readers, manual and auto-scaled alike, including readers behind custom endpoints, and excludes the writer. The documentation’s example has two manual readers at 90% CPU and one auto-scaled reader at 10% producing a 63.33% average.
- Not supported for Global Database secondary clusters.
- Your application must be able to find the new readers, which is why AWS tells you to use the reader endpoint (or an exclusion-list custom endpoint).
Replication: Aurora Replicas vs the Other Kinds
Aurora has three replication stories, and the exam tests that you know which one is which:
| Mechanism | Scope | How it works | Lag | Limits |
|---|---|---|---|---|
| Aurora Replicas | Same Region, same cluster | Share the cluster volume; no data copy | Usually well under 100 ms | 15 per cluster; must match the cluster’s encryption state |
| Aurora MySQL cross-Region read replica | Another Region, separate cluster | MySQL binary log (binlog) replication | Seconds, workload-dependent | Up to 5 per cluster, each in a different Region; not available when Backtrack is on |
| Aurora Global Database | Up to 10 other Regions | Storage-level replication over dedicated infrastructure | Typically under 1 second | Covered below |
Aurora PostgreSQL has no cross-Region Aurora Replica feature; its cross-Region answers are Global Database or PostgreSQL logical replication. Aurora MySQL can also replicate to or from an external MySQL or an RDS for MySQL instance using binlog, which is a migration tool more than an HA design. The documentation also notes you cannot create an encrypted replica of an unencrypted cluster or vice versa.
Cloning: Copy-on-Write at the Storage Layer
How it works
Aurora cloning creates a new cluster whose volume initially points at the same data pages as the source. Nothing is copied at clone time, so a multi-terabyte clone is available in minutes. Only when either side changes a page does Aurora write a new copy of that page for the side that changed it. The documentation’s example: cluster A has pages 1 to 4 and clone B points at the same four pages; when A changes page 1, A gets a new page 1[A] while B still sees the original; when B changes page 4, B gets 4[B] while A keeps 4.
Billing follows ownership. A clone’s VolumeBytesUsed “starts out small and only grows as the data diverges”. Identical pages are charged once, to the original cluster. If you delete the source, its pages are redistributed to the clones (with two clones, each takes half) and the clones’ metrics go up accordingly. The 1,000-page example in the docs: after cloning and changing 100 pages, the parent pays for 1,000 and the clone for 100; delete the parent and the clone pays for 1,000.
The rules
| Rule | Detail |
|---|---|
| Speed vs snapshot restore | Cloning is “faster and more space-efficient than physically copying the data using other techniques, such as restoring a snapshot” |
| Copy-on-write limit | Up to 15 clones per source share pages. The 16th becomes a full copy, which “acts like a point-in-time recovery” |
| Clones of clones | Allowed; you can create multiple clones from a clone |
| Region | Same Region only. No cross-Region cloning |
| VPC | A different VPC is allowed if its subnets map to the same Availability Zones |
| Instances | Source must have at least one instance. The console clone gets one instance; the CLI clone (restore-db-cluster-to-point-in-time --restore-type copy-on-write --use-latest-restorable-time) creates a cluster with no instances, and you add them with create-db-instance |
| Different shape | The clone can use fewer or smaller instances, serverless instead of provisioned (pass --serverless-v2-scaling-configuration), or a different storage configuration; it is created on the latest minor version of the source’s engine |
| Parallel query | You cannot clone from a non-parallel-query cluster into one that uses parallel query |
| Backtrack | You cannot backtrack a clone to a time before the clone was created |
The exam cue words are “copy of production for testing”, “quickly”, “without impacting production” and “minimal additional storage cost”. All four point to a clone, not a snapshot restore, not a read replica, and not DMS.
Cross-account cloning with AWS RAM
You can share a cluster through AWS Resource Access Manager and let another account clone it, or clone it yourself and share the clone. The documented limits are precise and make good trick answers:
- An account can create only one clone from any resource shared with it, and cannot re-share a resource that was shared with it.
- Maximum 15 cross-account clones per source cluster, each owned by a different account; the original and its clones count together toward that 15.
- The source must be in
ACTIVEstate and cannot be renamed while shared. - You cannot share a cluster encrypted with the default RDS KMS key. Re-encrypt it with a customer managed key (snapshot, copy with the new key, restore) first, and grant the other account access to that key in the key policy. The clone can use the same key or the recipient’s own key, but an encrypted source cannot produce an unencrypted clone.
- Invitations for accounts outside your organization are accepted through the AWS RAM console, CLI or API, not the RDS console.
- The recipient sees only a few properties of the shared cluster (engine, version, encryption state), identified by ARN, and the
CrossAccountClonefield indescribe-db-clusters --include-sharedtells you which clusters are cross-account clones.
Backtrack: Rewinding the Cluster In Place
Backtrack rewinds an Aurora MySQL cluster to an earlier time without creating a new cluster. Point-in-time restore (PITR) launches a new cluster from backups and “can take hours”; Backtrack “rewinds the DB cluster in minutes” and you can move back and forth repeatedly to find exactly when a bad change happened (back three hours, then forward one).
The limitations are where the questions live:
| Limitation | Detail |
|---|---|
| Engine | Aurora MySQL only (versions 2, 3 and 8.4). “Backtrack is not available for Aurora PostgreSQL” |
| Enablement | Only on clusters created with Backtrack enabled, or restored from a snapshot with it enabled. “You can’t modify a DB cluster to enable the Backtrack feature” |
| Window | Target backtrack window up to 72 hours. The actual window can be shorter under heavy write load, because it depends on how many change records fit; AWS notifies you when actual falls below target |
| Scope | The entire cluster. You cannot backtrack one table or one update |
| Disruption | Aurora pauses the database, closes connections and drops uncommitted work. Stop your application first |
| Consistency | Aurora backtracks to the nearest consistent time, which may not be exactly the time you asked for; describe-db-cluster-backtracks shows the actual time |
| Replication | No cross-Region read replicas from a backtrack-enabled cluster; forcing a backtrack with binlog enabled breaks downstream replicas and blue/green deployments |
| Global Database | Not supported |
| Clones | Cannot backtrack a clone to before its creation |
| Upgrades | After an in-place major upgrade (2 to 3, or 3 to 8.4) you cannot backtrack to before the upgrade |
| Cost | An hourly rate for storing change records; heavy workloads store more |
| Regions | Not available everywhere (for example, not in Stockholm, Zurich, São Paulo, or the GovCloud Regions) |
The decision table the exam expects:
| Need | Answer |
|---|---|
Undo a DELETE without WHERE on Aurora MySQL, within the last day, as fast as possible | Backtrack (if it was enabled at creation) |
| Same, but Aurora PostgreSQL | Point-in-time restore to a new cluster, then repoint the application or copy the rows back |
| Same, but the cluster was created without Backtrack | PITR. You cannot enable Backtrack now |
| A copy of production for testing, right now | Clone |
| Recover from an accidental cluster deletion | Restore the final snapshot or a manual snapshot |
Aurora Serverless: ACUs, Scaling and Auto-Pause
A naming change you should know
The AWS documentation now calls this simply Aurora serverless, and reserves “Aurora Serverless v1” for the deprecated earlier product with a different architecture. The exam, course titles and most study material still say “Aurora Serverless v2”. They are the same feature. In this post “Aurora serverless” means what SAA-C03 calls Serverless v2.
Capacity: ACUs
The unit is the Aurora capacity unit (ACU): approximately 2 GiB of memory plus corresponding CPU and networking. You set a minimum and maximum capacity for the cluster, and every serverless writer and reader in the cluster scales independently within that range. Current ranges:
| Range (ACUs) | Aurora MySQL | Aurora PostgreSQL |
|---|---|---|
| 0.5 to 128 | 3.02.0+ | 13.6+, 14.3+, 15.2+, 16.1+ |
| 0.5 to 256 | 3.06.0+ | 13.13+, 14.10+, 15.5+, 16.1+ |
| 0 to 256 | 3.08.0+ | 13.15+, 14.12+, 15.7+, 16.3+, 17.4+, 18.3+ |
| 0 to 384 | not available | 14.23+, 15.18+, 16.14+, 17.10+, 18.4+ |
Study material that says “0.5 to 128 ACUs” is describing the 2022 launch. The current ceiling is 256 for MySQL and 384 for PostgreSQL, and the floor is 0. Charges are per ACU-hour for capacity actually used, measured every second. A cluster with n serverless instances idles at roughly n times the minimum and never exceeds n times the maximum.
Memory-related parameters are managed for you: the buffer cache grows and shrinks with capacity, and max_connections is fixed based on the maximum capacity so that connections are not dropped when the instance scales down.
Scaling behavior
Scaling is in-place and fine-grained, in increments as small as 0.5 ACU, larger when the current capacity is larger. It “can happen while database connections are open, while SQL transactions are in process, while tables are locked, and while temporary tables are in use”. There are no scaling events in the console; you watch ServerlessDatabaseCapacity and ACUUtilization in CloudWatch.
The promotion tier of a serverless reader decides how it scales, and this is the mechanism behind the “which tier should the standby be in” questions:
- Tiers 0 and 1: the reader’s minimum capacity is pinned to the writer’s current capacity, so it is always big enough to take over on failover. If the writer is provisioned, the reader’s minimum is the ACU equivalent of the writer’s memory.
- Tiers 2 to 15: the reader scales independently between the cluster minimum and maximum. It can idle at the minimum while the writer is busy, which is cheaper, but if promoted it may need to scale up before it can carry the write load.
So: “a serverless standby that can take over instantly” is tier 0 or 1; “a serverless reporting reader that should scale down when reports finish” is tier 2 to 15.
Mixed-configuration clusters
A cluster can have a provisioned writer with serverless readers (when you need more write capacity than the largest serverless instance provides) or a serverless writer with provisioned readers (variable writes, steady reads). Serverless storage is the same six-copy cluster volume as provisioned.
Auto-pause: scaling to 0 ACUs
Setting minimum capacity to 0 enables auto-pause. The facts:
| Fact | Detail |
|---|---|
| Idle timer | SecondsUntilAutoPause: minimum and default 300 seconds (5 minutes), maximum 86,400 seconds (1 day) |
| Resume time | ”approximately 15 seconds”; set client connection timeouts above that. An instance paused for more than 24 hours may take 30 seconds or longer to resume |
| What wakes it | Any connection attempt, even with bad credentials; a Data API request; a parameter group change; a Backtrack; cloning the cluster; upgrades and some maintenance. Taking or deleting a snapshot does not |
| Billing while paused | Instance charge is zero; storage and other cluster costs continue |
| Status | Still shows Available while paused; ACUUtilization and ServerlessDatabaseCapacity read 0 |
| Group behavior | The writer and all tier-0/1 readers pause and resume together; tier 2 to 15 readers pause independently. Resuming any reader resumes the writer |
| What prevents pausing | Any user connection; RDS Proxy (it keeps connections open to every instance); being the primary or a secondary cluster of a Global Database; binlog or logical replication enabled (for the writer and tier 0/1 readers); a zero-ETL integration; any provisioned instance in the cluster (the serverless writer and tier 0/1 readers then never pause); Babelfish T-SQL connections |
| Scheduled jobs | pg_cron and the MySQL event scheduler do not wake a paused instance; jobs due while paused are skipped |
| After maintenance | Aurora waits at least 20 minutes before pausing again |
Auto-pause is faster to resume than the cluster stop/start feature, which is the right choice when a dev cluster is unused for many hours and resume speed does not matter.
Serverless and the other features
Aurora serverless supports readers (up to 15 across 3 AZs), Multi-AZ failover, Global Database (AWS recommends a minimum of 8 ACUs for the primary cluster of a global database), cloning (pass the scaling configuration when you clone), and switching between Standard and I/O-Optimized with no downtime. For Global Database secondaries, serverless readers are explicitly recommended so they can “scale down when the database isn’t busy”.
Aurora Global Database: Up to 10 Secondary Regions
Shape and claims
An Aurora global database has one primary cluster where all writes happen and up to 10 read-only secondary clusters, each in a different Region. This is another number that has moved: older material says five. Replication is at the storage layer using dedicated infrastructure, so it has little impact on the primary and typical lag is under one second. Each secondary can have up to 16 readers rather than 15, because it has no writer. The documented objectives: “RTO can be in the order of minutes” and “RPO is typically measured in seconds”. Memory-optimized instance classes are required (db.r5 or higher recommended), and no two clusters of a global database can share a Region.
Writes should go through the Global Database writer endpoint, which always points at the current primary cluster’s writer, in whatever Region it happens to be, so you do not encode a Region into connection strings. During a failover AWS tells you to drop DNS TTL to about 5 seconds so clients notice the repoint quickly.
Switchover vs failover vs manual
This is the heart of the Global Database questions, and the terminology changed: switchover used to be called “managed planned failover”.
| Switchover | Managed failover | Manual failover (detach and promote) | |
|---|---|---|---|
| Use when | Planned: Regional rotation, follow-the-sun, failing back after a disaster | Unplanned outage of the primary Region | Managed failover is not possible, for example incompatible engine versions between Regions |
| Data loss | RPO = 0. Aurora waits for the chosen secondary to synchronize, makes the old primary read-only, then promotes | RPO is non-zero, measured in seconds; depends on replication lag at the moment of failure | Non-zero; depends on lag |
| Topology afterwards | Unchanged; the old primary becomes a secondary | Preserved: Aurora automatically re-adds the old primary Region as a secondary when it recovers, after snapshotting its volume as rds:unplanned-global-failover-... so you can recover unreplicated writes | You detach a secondary, it becomes a standalone cluster, and you rebuild the global database around it |
| Downtime | Short; on recent engine versions (Aurora MySQL 3.09+, Aurora PostgreSQL 16.8/15.12/14.17/13.20+) “typically under 30 seconds” | A few minutes for the new primary; other secondaries are rebuilt from it, which can take minutes to hours | Depends on you |
| CLI | switchover-global-cluster | failover-global-cluster --allow-data-loss | remove-from-global-cluster, then re-add Regions |
| Requirements | Same major and minor engine versions in both Regions | Same | None, which is why it exists |
| Split-brain protection | n/a | Best-effort write fencing on the old primary; not guaranteed under multi-AZ failure, hence the DNS TTL and take-apps-offline advice | Up to you |
The exam cue: “no data loss” plus “planned” equals switchover; “Region is down” plus “minutes” equals managed failover and accept some data loss; “versions differ” equals manual.
Two configuration gotchas the documentation calls out: the promoted cluster does not inherit the old primary’s parameter group, CloudWatch alarms or integrations, so keep them consistent across Regions in advance. And a headless secondary (a secondary cluster with no DB instances, kept for cheaper DR) must have an instance added before it can be the target of a switchover or failover.
Managing RPO on Aurora PostgreSQL
Aurora PostgreSQL global databases can enforce an RPO with the cluster parameter rds.global_db_rpo (20 seconds to 2,147,483,647 seconds). Aurora then blocks commits on the primary whenever every secondary’s RPO lag exceeds the value, and resumes them as soon as one secondary catches up. It guarantees the RPO at the cost of write availability. With only two Regions AWS recommends leaving it at the default in the secondary’s parameter group, because after a failover the rebuilt old primary would otherwise stall transactions. Monitor with AuroraGlobalDBRPOLag (all Aurora PostgreSQL versions, Aurora MySQL 3.04+/2.12+) or AuroraGlobalDBReplicationLag on older Aurora MySQL.
Write forwarding
With write forwarding enabled, a secondary cluster accepts write statements from local clients and forwards them to the primary, which applies them and replicates the result back. The primary remains the single source of truth, Aurora handles the cross-Region networking and session context, and your application in the secondary Region needs only one endpoint. It is available for Aurora MySQL and Aurora PostgreSQL global databases, with a per-session read-consistency setting (eventual, session or global) that controls whether a session waits to see its own forwarded writes. The exam framing is “simplify endpoints for a globally distributed app that mostly reads and occasionally writes from a secondary Region”; heavy write workloads should still connect to the primary’s writer endpoint.
What Global Database does not support
Backtrack; Aurora Auto Scaling on secondary clusters; cluster cache management on Aurora PostgreSQL secondaries; Secrets Manager integration (turn it off before adding a Region; our Secrets Manager vs Parameter Store post explains what that integration does); automatic minor version upgrades (the setting is ignored); stopping or starting member clusters individually; renaming a member cluster; and a primary that is itself a replica of an RDS PostgreSQL instance. Also, when the primary writer restarts or fails over, readers in the secondary Regions restart too and the secondary is unavailable until they resync.
Quotas That Become Distractors
| Quota | Default |
|---|---|
| DB clusters per Region | 40 (adjustable) |
| DB instances per Region (shared with RDS, Neptune, DocumentDB) | 40 (20 in ap-south-1), adjustable |
| Aurora Replicas per cluster | 15, not adjustable |
| Custom endpoints per cluster | 5 (adjustable) |
| Copy-on-write clones per source | 15, then full copies |
| Cross-account clones per source | 15, one per account |
| Global Database secondary Regions | 10 |
| Readers per Global Database secondary cluster | 16 |
| Cluster volume | 128 TiB or 256 TiB by version |
| Table size | 64 TiB (Aurora MySQL), 32 TiB (Aurora PostgreSQL) |
| Manual cluster snapshots | 100 (adjustable); AWS Backup snapshots do not count |
| Backtrack window | 72 hours |
| Serverless capacity | 0 to 256 ACUs (MySQL), 0 to 384 ACUs (PostgreSQL) |
| Auto-pause idle timer | 300 to 86,400 seconds |
A 15-Minute Lab
You can watch most of these behaviors on a small cluster. Costs are low if you delete everything afterwards. Replace the identifiers and subnet group with your own.
-
Create a cluster with Backtrack and I/O-Optimized settings you can inspect.
aws rds create-db-cluster \ --db-cluster-identifier lab-aurora \ --engine aurora-mysql --engine-version 8.0 \ --master-username admin --manage-master-user-password \ --backtrack-window 86400 \ --storage-type aurora-iopt1 \ --serverless-v2-scaling-configuration MinCapacity=0,MaxCapacity=4,SecondsUntilAutoPause=600 \ --db-subnet-group-name my-subnetsBacktrack can only be set here, at creation. The I/O-Optimized configuration is
aurora-iopt1; Standard isaurora. -
Add a serverless writer and a provisioned reader in another AZ.
aws rds create-db-instance --db-instance-identifier lab-aurora-w \ --db-cluster-identifier lab-aurora --db-instance-class db.serverless \ --engine aurora-mysql --promotion-tier 0 aws rds create-db-instance --db-instance-identifier lab-aurora-r1 \ --db-cluster-identifier lab-aurora --db-instance-class db.t4g.medium \ --engine aurora-mysql --promotion-tier 2 --availability-zone us-east-1bYou have just built a mixed-configuration, Multi-AZ cluster. Note the reader’s tier: 2, so it scales and pauses independently and is not the preferred failover target.
-
List the endpoints.
aws rds describe-db-clusters --db-cluster-identifier lab-aurora \ --query 'DBClusters[0].{W:Endpoint,R:ReaderEndpoint,Custom:CustomEndpoints}' -
Create a READER custom endpoint with an exclusion list.
aws rds create-db-cluster-endpoint --db-cluster-identifier lab-aurora \ --db-cluster-endpoint-identifier lab-reports \ --endpoint-type READER --excluded-members lab-aurora-wBecause this is an exclusion list, any reader you add later joins the endpoint automatically. Add a second reader and re-run
describe-db-cluster-endpointsto confirm. -
Prove the reader endpoint balances connections, not queries. Open two separate
mysqlsessions to the reader endpoint and runSELECT @@aurora_server_id;in each. Then run it ten times inside one session. Each session stays on one instance for its whole life. -
Clone the cluster.
aws rds restore-db-cluster-to-point-in-time \ --source-db-cluster-identifier lab-aurora --db-cluster-identifier lab-aurora-clone \ --restore-type copy-on-write --use-latest-restorable-time \ --serverless-v2-scaling-configuration MinCapacity=0.5,MaxCapacity=2The clone cluster appears in seconds and has no instances until you add one. Watch
VolumeBytesUsedon the clone stay near zero until you write to it. -
Force a failover and watch the tiers.
aws rds failover-db-cluster --db-cluster-identifier lab-aurora aws rds describe-db-clusters --db-cluster-identifier lab-aurora \ --query 'DBClusters[0].DBClusterMembers[*].[DBInstanceIdentifier,IsClusterWriter,PromotionTier]'The cluster endpoint now resolves to the old reader. Your READER custom endpoint dropped the promoted instance automatically because its type is READER, not ANY.
-
Clean up. Delete the clone’s instance and cluster, then the lab cluster’s instances and cluster with
--skip-final-snapshot. Remember the clone does not disappear when the source does; delete it explicitly.
Scenario Drill
Cover the right column, read the cue, answer, then check.
| Cue in the question | Answer |
|---|---|
| Relational, MySQL-compatible, needs more than 5 read replicas | Aurora (15 Aurora Replicas) |
| Reporting queries must not land on the large production readers | Custom endpoint grouping the small readers |
| Added readers but the app still hammers the first replica | Reader endpoint balances per connection; recycle connections or use RDS Proxy |
| Writes through the reader endpoint succeeded | The cluster has no replicas, so the reader endpoint points at the writer |
| Failover with replicas present, how long? | Typically under 30 seconds, less than 60 |
| Failover with no replicas, how long? | New primary in the same AZ, under 10 minutes |
| Ensure the large replica is promoted before the small one | Give it a lower promotion tier number (0 is highest priority) |
| Two replicas in the same tier, which is promoted? | The larger one |
| New Auto Scaling readers never get custom endpoint traffic | The custom endpoint uses a static list; switch to an exclusion list |
| Auto Scaling replica promoted before a hand-built one | Impossible by default; auto-scaled replicas get tier 15 |
| Dev team needs a copy of a 5 TB production database in minutes with minimal storage cost | Aurora clone (copy-on-write) |
| 16th clone is slow and uses full storage | The copy-on-write limit is 15; the next clone is a full copy |
| Share a clone with another AWS account | AWS RAM; the source cannot use the default RDS KMS key |
Undo a bad UPDATE on Aurora MySQL from two hours ago, fastest | Backtrack (if enabled at creation) |
| Same cluster, but Backtrack was never enabled | Point-in-time restore; Backtrack cannot be enabled on an existing cluster |
| Aurora PostgreSQL, rewind the database | Not possible with Backtrack; use PITR |
| Backtrack window request of 5 days | Rejected; maximum is 72 hours |
| Spiky, unpredictable load; pay only for capacity used | Aurora serverless with a min/max ACU range |
| Dev database idle most of the day, must cost nothing when idle | Min capacity 0 ACUs (auto-pause); expect about 15 s resume |
| Serverless cluster with RDS Proxy never pauses | Expected; the proxy holds connections open |
| Serverless standby must take over at full size immediately | Put the serverless reader in tier 0 or 1 |
| Cross-Region DR for Aurora with RPO in seconds and RTO in minutes | Aurora Global Database |
| Planned Region rotation with zero data loss | Global Database switchover |
| Primary Region is down; recover now and accept some data loss | Global Database managed failover (--allow-data-loss) |
| Primary and secondary run different engine minor versions and the Region is down | Manual failover: detach the secondary and promote it |
| I/O charges are 30% of the Aurora bill and unpredictable | Switch to Aurora I/O-Optimized |
Mistakes to Avoid
- Thinking the reader endpoint spreads individual queries. It spreads connections. Pooled, long-lived connections defeat it.
- Treating Aurora Multi-AZ like RDS Multi-AZ. There is no silent standby. Multi-AZ means a reader in another AZ, and that reader serves traffic.
- Trying to enable Backtrack on an existing cluster, or on PostgreSQL. Neither is possible.
- Confusing Backtrack with a restore. Backtrack rewinds the same cluster in minutes and interrupts connections; PITR creates a new cluster and can take hours.
- Assuming the clone is free forever. It is nearly free at creation; pages diverge over time and the clone pays for its own changes, and for everything if you delete the source.
- Reading “Multi-Region” and answering “cross-Region read replica” for Aurora PostgreSQL. It does not exist; the answer is Global Database.
- Mixing up switchover and failover. Switchover is planned and loses nothing. Failover is for outages and may lose seconds of writes.
- Creating custom endpoints in the console and expecting READER semantics. The console always makes
ANY, which includes the writer and does not adjust on failover. - Switching to I/O-Optimized and back and forth. Standard to I/O-Optimized is once per 30 days.
- Quoting the old limits. Global Database allows 10 secondaries, not 5; serverless reaches 256 or 384 ACUs and scales to 0, not 0.5 to 128; volumes reach 256 TiB on current versions.
Practise the Decision Patterns
Aurora questions on the real exam are rarely about one fact. They stack two or three: a serverless standby and its promotion tier, a clone and its KMS key, a Global Database and which recovery operation to run. The fastest way to make those combinations automatic is to work through timed scenarios where the distractors are the other Aurora features. Our SAA-C03 practice questions give you a free set to start on, and the AWS Certified Solutions Architect Associate mock exam bundle has eight full-length exams with explanations that spell out why each wrong Aurora option is wrong. Pair this post with the resilient architectures guide for the RTO/RPO framing and the cost-optimized architectures guide for the serverless and I/O-Optimized pricing logic.
Frequently Asked Questions
What is the difference between the Aurora cluster endpoint and the reader endpoint?
The cluster endpoint always resolves to the current writer and follows failover, so applications use it for writes and mixed workloads. The reader endpoint distributes each new connection across the Aurora Replicas and is for read-only sessions. If the cluster has no replicas, the reader endpoint points at the writer and accepts writes.
How many custom endpoints can an Aurora cluster have, and what are READER and ANY?
Five by default. A READER custom endpoint contains only reader instances and automatically drops a replica that is promoted to writer. An ANY endpoint can contain the writer and readers with equal probability and does not change membership on failover. The console can only create ANY; use the CLI or API for READER.
How does Aurora decide which replica becomes the new writer?
By promotion tier, 0 (highest priority) to 15 (lowest). Within a tier, the largest instance wins; if size also ties, Aurora picks arbitrarily. Replicas added by Aurora Auto Scaling are placed in tier 15.
How long does an Aurora failover take?
With at least one Aurora Replica, service is typically restored in under 60 seconds and often under 30. Without replicas, Aurora recreates the primary in the same AZ, which typically takes under 10 minutes. RDS Proxy can cut application-visible failover time by up to 66% by bypassing DNS caches.
How does Aurora cloning work and what does it cost?
Cloning uses a copy-on-write protocol: the clone shares the source’s data pages and new storage is allocated only for pages either side changes afterwards. You can create up to 15 copy-on-write clones per source; the next is a full copy. Clones must be in the same Region, and cross-account clones use AWS RAM and require a customer managed KMS key rather than the default RDS key.
What is the difference between Backtrack and point-in-time restore?
Backtrack rewinds an existing Aurora MySQL cluster to a time within its window (up to 72 hours) in minutes, pausing the database briefly. Point-in-time restore creates a new cluster from backups, works on both engines, and can take hours. Backtrack must be enabled when the cluster is created and is not available for Aurora PostgreSQL.
What is an ACU and can Aurora serverless scale to zero?
An Aurora capacity unit is roughly 2 GiB of memory with matching CPU and networking. Serverless instances scale between a minimum and maximum you set, up to 256 ACUs on Aurora MySQL and 384 on Aurora PostgreSQL. Setting the minimum to 0 enables auto-pause after an idle period of 300 to 86,400 seconds; resume takes about 15 seconds. RDS Proxy, Global Database membership, binlog or logical replication, and provisioned instances in the same cluster prevent pausing.
What is the difference between a Global Database switchover and a failover?
A switchover is a planned operation on a healthy global database: Aurora synchronizes the target secondary first, so RPO is zero, and the old primary becomes a secondary. A managed failover is for an unplanned primary-Region outage: it promotes a secondary immediately, so recent unreplicated writes can be lost, and Aurora re-adds the old primary Region as a secondary once it recovers. If engine versions differ between Regions, you perform a manual failover by detaching and promoting a secondary.
When should I choose Aurora I/O-Optimized over Aurora Standard?
When your I/O charges are 25% or more of your total Aurora spend, or when you need predictable pricing for an I/O-intensive workload. I/O-Optimized removes the per-request I/O charge in exchange for higher instance and storage rates. You can move to I/O-Optimized once every 30 days and back to Standard at any time.
Does Aurora storage shrink when I delete data?
On current versions, yes. Dropping or truncating tables, databases or partitions reduces the billed volume size, reclaimed at roughly 10 TB per day. Deleting rows does not; reorganize the table with OPTIMIZE TABLE or pg_repack afterwards.
Conclusion
The six bullets every guide gives Aurora are the start of the story, not the end. The exam’s Aurora questions assume you know that storage and compute are separate; that endpoints are DNS names with specific balancing and failover semantics, and that custom endpoints exist for heterogeneous readers; that promotion tiers decide both failover order and how serverless readers scale; that cloning is copy-on-write with a 15-clone limit; that Backtrack is MySQL-only, creation-time-only and 72 hours at most; that Aurora serverless now reaches 256 or 384 ACUs and pauses at zero; that Global Database supports 10 secondaries and distinguishes a zero-loss switchover from a lossy failover; and that I/O-Optimized is a pricing decision with a 25% rule and a 30-day switch limit.
Keep the handful of numbers (15 replicas, 5 custom endpoints, tiers 0 to 15, 15 clones, 72 hours, 300 seconds, 15 seconds, 10 Regions, 16 readers, 25%, 30 days) and the handful of rules behind them, and the rest of the Aurora questions turn into pattern matching.