Back to Blog

Amazon Aurora Internals for the SAA-C03 Exam: The Shared Cluster Volume, the Four Endpoint Types & Custom Endpoints, Failover Promotion Tiers, Copy-on-Write Cloning, Backtrack vs Point-in-Time Restore, Aurora Serverless ACUs & Auto-Pause, Global Database Switchover vs Failover, Aurora Standard vs I/O-Optimized, and Dynamic Storage Resizing

A practitioner's guide to how Amazon Aurora really works for the SAA-C03 exam, one level below 'MySQL and PostgreSQL compatible with six copies in three AZs': what the cluster volume contains and how it grows and shrinks (10 TB per day reclaim, 128 vs 256 TiB), the cluster, reader, instance and custom endpoints and why the reader endpoint balances connections not queries, READER vs ANY custom endpoints with static vs exclusion lists, the 0-15 promotion tier rules and the under-30-second failover claim, copy-on-write cloning with the 15-clone limit and cross-account RAM sharing, Backtrack's 72-hour window and why it is MySQL-only, Aurora serverless ACUs from 0 to 384 with auto-pause after 300 seconds, Global Database with up to 10 secondary Regions, switchover (RPO 0) vs failover (data loss) vs manual detach, write forwarding, rds.global_db_rpo, Aurora Standard vs I/O-Optimized and the 25% rule, Aurora Auto Scaling for replicas, cluster cache management, plus a 26-row scenario drill and an FAQ.

By Sailor Team , November 16, 2026

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.serverless class 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:

OperationWhy Aurora makes it cheap
Adding a readerThe new instance attaches to the existing volume. Nothing is copied.
Removing a readerThe instance goes away. The data stays. Only deleting the whole cluster removes data.
Replica lagReplicas 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.
FailoverA replica is promoted to writer. No storage needs to be re-synchronized.
CloningA 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 volumeEngine versions
256 TiBAurora PostgreSQL 17.5+, 16.9+, 15.13+; Aurora MySQL 3.10 (MySQL 8.0.42) and higher
128 TiBAll 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:

EngineVersions with dynamic resizing
Aurora MySQL version 3All supported versions
Aurora MySQL version 22.11 and higher
Aurora PostgreSQLAll supported versions
Aurora serverlessAll 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 to DELETE. After a large DELETE, run OPTIMIZE TABLE (Aurora MySQL) or use pg_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_table to 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 StandardAurora I/O-Optimized
What you pay forInstance hours + storage + a per-million-request charge for read and write I/OInstance hours + storage, with no charge for I/O operations (the instance and storage rates are higher)
When AWS says it winsI/O spend is less than 25% of total Aurora spendI/O spend is 25% or more of total Aurora spend
Switching rulesSwitch from I/O-Optimized to Standard at any timeSwitch from Standard to I/O-Optimized once every 30 days
Downtime when switchingNone for non-NVMe instances (all serverless instances are non-NVMe); NVMe-based instance classes need an engine restartSame
ScopeThe whole cluster. It is a cluster property, not an instance propertySame

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.

EndpointDNS shapeResolves toCreated by
Cluster (writer)name.cluster-xyz.region.rds.amazonaws.comWhichever instance is currently the writer. Follows failover automaticallyAurora, one per cluster
Readername.cluster-ro-xyz.region.rds.amazonaws.comOne of the Aurora Replicas, chosen per connection. If there are no replicas, the writerAurora, one per cluster
Instanceinstancename.xyz.region.rds.amazonaws.comExactly that instanceAurora, one per instance
Customname.cluster-custom-xyz.region.rds.amazonaws.comOne of the instances you put in a groupYou, up to 5 per cluster
Global Database writerA global endpointThe cluster endpoint of whichever Regional cluster is currently primaryAurora, 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:

RuleDetail
Quota5 custom endpoints per cluster (adjustable). None exist until you create one
NameUp to 63 characters; unique per account per Region; not included in snapshots, so you re-create them after a restore
TypesREADER (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 changesWith 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 listThe endpoint contains exactly the instances you named. Newly added replicas (manual or Auto Scaling) are not added
Exclusion listThe 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 membersA stopped, rebooting or unhealthy replica stays a member; you just can’t connect to it through the endpoint until it recovers
Existing connectionsAdding or removing an instance does not drop connections already open to it
Multiple membershipOne 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 hasWhat Aurora doesDocumented time
One or more Aurora ReplicasPromotes 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 replicasRecreates 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:

  1. On failure, the replica with the highest priority (lowest number) is promoted.
  2. If several replicas share the same tier, the largest one is promoted.
  3. If they share tier and size, Aurora picks one arbitrarily within that tier.
  4. Changing a replica’s priority does not trigger a failover.
  5. Replicas created by Aurora Auto Scaling are placed in tier 15 so that a manually created replica is always preferred.
  6. “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:

MechanismScopeHow it worksLagLimits
Aurora ReplicasSame Region, same clusterShare the cluster volume; no data copyUsually well under 100 ms15 per cluster; must match the cluster’s encryption state
Aurora MySQL cross-Region read replicaAnother Region, separate clusterMySQL binary log (binlog) replicationSeconds, workload-dependentUp to 5 per cluster, each in a different Region; not available when Backtrack is on
Aurora Global DatabaseUp to 10 other RegionsStorage-level replication over dedicated infrastructureTypically under 1 secondCovered 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

RuleDetail
Speed vs snapshot restoreCloning is “faster and more space-efficient than physically copying the data using other techniques, such as restoring a snapshot”
Copy-on-write limitUp to 15 clones per source share pages. The 16th becomes a full copy, which “acts like a point-in-time recovery”
Clones of clonesAllowed; you can create multiple clones from a clone
RegionSame Region only. No cross-Region cloning
VPCA different VPC is allowed if its subnets map to the same Availability Zones
InstancesSource 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 shapeThe 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 queryYou cannot clone from a non-parallel-query cluster into one that uses parallel query
BacktrackYou 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 ACTIVE state 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 CrossAccountClone field in describe-db-clusters --include-shared tells 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:

LimitationDetail
EngineAurora MySQL only (versions 2, 3 and 8.4). “Backtrack is not available for Aurora PostgreSQL”
EnablementOnly 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”
WindowTarget 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
ScopeThe entire cluster. You cannot backtrack one table or one update
DisruptionAurora pauses the database, closes connections and drops uncommitted work. Stop your application first
ConsistencyAurora backtracks to the nearest consistent time, which may not be exactly the time you asked for; describe-db-cluster-backtracks shows the actual time
ReplicationNo cross-Region read replicas from a backtrack-enabled cluster; forcing a backtrack with binlog enabled breaks downstream replicas and blue/green deployments
Global DatabaseNot supported
ClonesCannot backtrack a clone to before its creation
UpgradesAfter an in-place major upgrade (2 to 3, or 3 to 8.4) you cannot backtrack to before the upgrade
CostAn hourly rate for storing change records; heavy workloads store more
RegionsNot available everywhere (for example, not in Stockholm, Zurich, São Paulo, or the GovCloud Regions)

The decision table the exam expects:

NeedAnswer
Undo a DELETE without WHERE on Aurora MySQL, within the last day, as fast as possibleBacktrack (if it was enabled at creation)
Same, but Aurora PostgreSQLPoint-in-time restore to a new cluster, then repoint the application or copy the rows back
Same, but the cluster was created without BacktrackPITR. You cannot enable Backtrack now
A copy of production for testing, right nowClone
Recover from an accidental cluster deletionRestore 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 MySQLAurora PostgreSQL
0.5 to 1283.02.0+13.6+, 14.3+, 15.2+, 16.1+
0.5 to 2563.06.0+13.13+, 14.10+, 15.5+, 16.1+
0 to 2563.08.0+13.15+, 14.12+, 15.7+, 16.3+, 17.4+, 18.3+
0 to 384not available14.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:

FactDetail
Idle timerSecondsUntilAutoPause: 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 itAny 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 pausedInstance charge is zero; storage and other cluster costs continue
StatusStill shows Available while paused; ACUUtilization and ServerlessDatabaseCapacity read 0
Group behaviorThe 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 pausingAny 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 jobspg_cron and the MySQL event scheduler do not wake a paused instance; jobs due while paused are skipped
After maintenanceAurora 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”.

SwitchoverManaged failoverManual failover (detach and promote)
Use whenPlanned: Regional rotation, follow-the-sun, failing back after a disasterUnplanned outage of the primary RegionManaged failover is not possible, for example incompatible engine versions between Regions
Data lossRPO = 0. Aurora waits for the chosen secondary to synchronize, makes the old primary read-only, then promotesRPO is non-zero, measured in seconds; depends on replication lag at the moment of failureNon-zero; depends on lag
Topology afterwardsUnchanged; the old primary becomes a secondaryPreserved: 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 writesYou detach a secondary, it becomes a standalone cluster, and you rebuild the global database around it
DowntimeShort; 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 hoursDepends on you
CLIswitchover-global-clusterfailover-global-cluster --allow-data-lossremove-from-global-cluster, then re-add Regions
RequirementsSame major and minor engine versions in both RegionsSameNone, which is why it exists
Split-brain protectionn/aBest-effort write fencing on the old primary; not guaranteed under multi-AZ failure, hence the DNS TTL and take-apps-offline adviceUp 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

QuotaDefault
DB clusters per Region40 (adjustable)
DB instances per Region (shared with RDS, Neptune, DocumentDB)40 (20 in ap-south-1), adjustable
Aurora Replicas per cluster15, not adjustable
Custom endpoints per cluster5 (adjustable)
Copy-on-write clones per source15, then full copies
Cross-account clones per source15, one per account
Global Database secondary Regions10
Readers per Global Database secondary cluster16
Cluster volume128 TiB or 256 TiB by version
Table size64 TiB (Aurora MySQL), 32 TiB (Aurora PostgreSQL)
Manual cluster snapshots100 (adjustable); AWS Backup snapshots do not count
Backtrack window72 hours
Serverless capacity0 to 256 ACUs (MySQL), 0 to 384 ACUs (PostgreSQL)
Auto-pause idle timer300 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.

  1. 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-subnets

    Backtrack can only be set here, at creation. The I/O-Optimized configuration is aurora-iopt1; Standard is aurora.

  2. 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-1b

    You 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.

  3. List the endpoints.

    aws rds describe-db-clusters --db-cluster-identifier lab-aurora \
      --query 'DBClusters[0].{W:Endpoint,R:ReaderEndpoint,Custom:CustomEndpoints}'
  4. 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-w

    Because this is an exclusion list, any reader you add later joins the endpoint automatically. Add a second reader and re-run describe-db-cluster-endpoints to confirm.

  5. Prove the reader endpoint balances connections, not queries. Open two separate mysql sessions to the reader endpoint and run SELECT @@aurora_server_id; in each. Then run it ten times inside one session. Each session stays on one instance for its whole life.

  6. 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=2

    The clone cluster appears in seconds and has no instances until you add one. Watch VolumeBytesUsed on the clone stay near zero until you write to it.

  7. 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.

  8. 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 questionAnswer
Relational, MySQL-compatible, needs more than 5 read replicasAurora (15 Aurora Replicas)
Reporting queries must not land on the large production readersCustom endpoint grouping the small readers
Added readers but the app still hammers the first replicaReader endpoint balances per connection; recycle connections or use RDS Proxy
Writes through the reader endpoint succeededThe 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 oneGive 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 trafficThe custom endpoint uses a static list; switch to an exclusion list
Auto Scaling replica promoted before a hand-built oneImpossible by default; auto-scaled replicas get tier 15
Dev team needs a copy of a 5 TB production database in minutes with minimal storage costAurora clone (copy-on-write)
16th clone is slow and uses full storageThe copy-on-write limit is 15; the next clone is a full copy
Share a clone with another AWS accountAWS RAM; the source cannot use the default RDS KMS key
Undo a bad UPDATE on Aurora MySQL from two hours ago, fastestBacktrack (if enabled at creation)
Same cluster, but Backtrack was never enabledPoint-in-time restore; Backtrack cannot be enabled on an existing cluster
Aurora PostgreSQL, rewind the databaseNot possible with Backtrack; use PITR
Backtrack window request of 5 daysRejected; maximum is 72 hours
Spiky, unpredictable load; pay only for capacity usedAurora serverless with a min/max ACU range
Dev database idle most of the day, must cost nothing when idleMin capacity 0 ACUs (auto-pause); expect about 15 s resume
Serverless cluster with RDS Proxy never pausesExpected; the proxy holds connections open
Serverless standby must take over at full size immediatelyPut the serverless reader in tier 0 or 1
Cross-Region DR for Aurora with RPO in seconds and RTO in minutesAurora Global Database
Planned Region rotation with zero data lossGlobal Database switchover
Primary Region is down; recover now and accept some data lossGlobal Database managed failover (--allow-data-loss)
Primary and secondary run different engine minor versions and the Region is downManual failover: detach the secondary and promote it
I/O charges are 30% of the Aurora bill and unpredictableSwitch 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.

Limited Time Offer: Get 80% off all Mock Exam Bundles | Sale ends in 7 days. Start learning today.

Claim Now