Amazon Aurora Serverless

Aurora Serverless is an on-demand, auto-scaling configuration for Amazon Aurora. Rather than choosing a DB instance class, you set a capacity range and Aurora adjusts within it as the workload moves. Billing is per second for the capacity actually consumed, which is what makes it attractive for workloads that are intermittent, unpredictable, or idle most of the time.

It runs the same Aurora engine on the same storage layer as a provisioned cluster: same six copies across three Availability Zones, same endpoints, same failover behaviour. Only the compute sizing differs.

Aurora Serverless v1 reached end of life on 31 March 2025

Aurora Serverless v1 is gone. New v1 clusters could not be created from 8 January 2025, and remaining clusters were upgraded automatically to v2 from 7 April 2025. Everything below describes v2, which AWS now documents simply as “Aurora serverless”. Material describing warm pools of pre-provisioned capacity, pauses that drop connections, or a cluster that scales as a single unit describes v1 and no longer applies.

Aurora capacity units

Capacity is measured in Aurora capacity units (ACUs). One ACU is approximately 2 GiB of memory with proportional CPU and networking.

• The range is 0 to 256 ACUs, in increments of 0.5 ACU. The allowed minimum depends on the engine version.
• Scaling is in-place and granular: Aurora adds or removes half an ACU at a time rather than doubling or halving, and does so while statements are running and transactions are open. Connections are not dropped.
• The rate at which a cluster can scale up depends on its current capacity, so a very low minimum makes the climb to a high maximum slower. If a database spends most of its time near its ceiling, raise the floor.
• Storage scales independently of ACUs, from 10 GiB upwards.

Scaling to zero

Setting the minimum capacity to 0 ACUs lets the cluster pause after a period with no connections and resume on the next one. This is the setting that makes an idle development or test database cost almost nothing, and it is the main practical difference from the old 0.5 ACU floor.

Two consequences are worth planning for: the first connection after a pause pays a resume delay, and on PostgreSQL-compatible clusters a minimum of 0 or 0.5 ACUs caps max_connections at 2,000. High-connection PostgreSQL workloads should use a minimum of 1 ACU or higher.

What works, and what does not

Aurora Serverless instances support reader instances, Multi-AZ clusters, global databases, IAM database authentication, Performance Insights and RDS Proxy. Reader instances can be configured to scale with the writer or independently, which is how a cluster absorbs a read-heavy spike without resizing the writer.

Database Activity Streams and Aurora PostgreSQL cluster cache management are not supported. Aurora Auto Scaling — adding whole reader instances based on CPU — is not supported either, and is unnecessary: pre-create readers and leave them scaled down.

A cluster can hold a mixture of provisioned and serverless instances, and an individual instance can be converted in either direction without recreating the cluster. That makes it practical to test serverless by adding one as a reader and failing over to it.

Where it fits

• Variable workloads — traffic that surges unpredictably, where provisioning for the peak means paying for it all the time.
• Multi-tenant fleets — a cluster per tenant, each with a wide capacity range, so quiet tenants cost little and busy ones scale.
• New applications — where the right instance size is genuinely unknown.
• Development and test — a low minimum, or zero, instead of burstable instance classes.
• Mixed-use applications — an OLTP workload with periodic reporting spikes, handled by readers scaling independently of the writer.
• Capacity discovery — run the real workload and observe how far it actually scales, instead of estimating an instance class.

The case against it is the mirror image: a steady, well-understood, always-on workload usually costs less on a provisioned instance, particularly with a reserved instance against it.