How does Aurora Serverless v2 billing work?

Aurora Serverless v2 is an Aurora instance class whose capacity changes while the database runs. You don't pick an instance size such as db.r6g.xlarge. You set a capacity range, and Aurora adjusts the allocation inside it. Teams adopt it when load varies too much for any single instance size to fit well: a size chosen for the peak sits idle most of the day, and a size chosen for the average falls behind during bursts.

Capacity is measured in Aurora Capacity Units (ACUs). Each ACU is about 2 GiB of memory, with CPU and network bandwidth that scale with it. You configure a minimum and a maximum ACU. Aurora scales in fine-grained steps between the two, and you pay per second for the capacity allocated at each moment. Allocated capacity is not the same as the capacity your queries actually use, and that difference drives cost later in this article.

Only the compute line item differs from provisioned Aurora. The other charges are the same for both:

Cost component Serverless v2 Provisioned Aurora
Compute ACU-hours, billed per second Instance-hours for a fixed class
Storage Billed on data stored in the cluster volume Same
I/O Per-request on Aurora Standard; included on I/O-Optimized Same
Backups and snapshots Billed beyond the free allowance Same
Data transfer Standard Aurora rates Same

Standard RDS for PostgreSQL works differently. It uses provisioned volumes, so you pay for the storage size and performance you allocate, not for the data you store. Comparing Serverless v2 with plain RDS changes both the compute and storage lines. Treat it as a separate calculation from comparing Serverless v2 with provisioned Aurora.

When is Aurora Serverless v2 cheaper than a provisioned instance?

The comparison comes down to one number: your effective average ACU. Serverless v2 bills for capacity per second, so add up ACU-hours over a representative day or month and divide by the hours in that period. One ACU is roughly 2 GiB of memory with proportional CPU, so you can translate a provisioned instance into an ACU equivalent. A 32 GiB instance is about 16 ACU.

An ACU-hour costs more than the same memory on a provisioned instance. Serverless therefore wins only when the database spends most of its time far below peak. Divide the provisioned instance's hourly price by the ACU-hour price to get the break-even average ACU. If your effective average stays under that figure, serverless is cheaper. The provisioned instance must be the smallest one that can handle peak, because you pay for that peak capacity around the clock.

Illustrative estimate. The prices are assumed placeholders, not quotes: $0.12 per ACU-hour and $0.52 per hour for a 32 GiB (≈16 ACU) instance. Break-even is 0.52 / 0.12 ≈ 4.3 ACU.

Profile Daily load shape ACU-hours/day Avg ACU Serverless/day Provisioned/day
Spiky 2 ACU for 22 h, 16 ACU for 2 h 76 3.2 $9.12 $12.48
Flatter 6 ACU for 16 h, 14 ACU for 8 h 208 8.7 $24.96 $12.48

Both profiles peak at roughly the same capacity, but the flatter one costs about twice as much on serverless. A high baseline erases the savings.

This covers compute only. Before deciding, substitute current prices for your region from the AWS pricing page.

# Illustrative estimate: placeholder prices, not quotes.
# Substitute current prices for your region from the AWS pricing page.
ACU_HOUR_PRICE = 0.12        # assumed $ per ACU-hour (Serverless v2)
PROVISIONED_HOURLY = 0.52    # assumed $ per hour, 32 GiB (~16 ACU) instance

# Above this average ACU, serverless costs more than the provisioned instance.
break_even_acu = PROVISIONED_HOURLY / ACU_HOUR_PRICE

# Each profile is a list of (acu, hours) segments covering 24 hours.
profiles = {
    "spiky":   [(2, 22), (16, 2)],
    "flatter": [(6, 16), (14, 8)],
}

print(f"break-even average ACU: {break_even_acu:.1f}")
for name, segments in profiles.items():
    hours = sum(h for _, h in segments)
    assert hours == 24, f"{name} must cover a full day"
    acu_hours = sum(acu * h for acu, h in segments)
    avg_acu = acu_hours / hours                  # effective average ACU
    serverless = acu_hours * ACU_HOUR_PRICE      # billed for capacity actually used
    provisioned = PROVISIONED_HOURLY * hours     # peak-sized instance, paid around the clock
    winner = "serverless" if serverless < provisioned else "provisioned"
    print(f"{name:8} acu_hours={acu_hours:4} avg={avg_acu:4.1f} "
          f"serverless=${serverless:6.2f} provisioned=${provisioned:6.2f} -> {winner}")

# Expected output with these placeholders:
# break-even average ACU: 4.3
# spiky    acu_hours=  76 avg= 3.2 serverless=$  9.12 provisioned=$ 12.48 -> serverless
# flatter  acu_hours= 208 avg= 8.7 serverless=$ 24.96 provisioned=$ 12.48 -> provisioned

A short Python script that reproduces the illustrative estimate. It computes the break-even average ACU from placeholder prices, then compares daily compute cost for the spiky and flatter load profiles.

How should you set minimum and maximum ACU?

The floor is the number you pay for every hour, including the quiet ones, so for a spiky workload it sets most of the bill. Raising the minimum keeps the buffer cache warm and gives scale-up a larger starting point, but every extra ACU of floor is billed around the clock. Set it high enough and you have rebuilt a provisioned instance at a higher unit price.

A floor that is too low fails in a different way. Each ACU carries roughly 2 GiB of memory. When the cluster shrinks during a lull, Postgres has less room for shared_buffers and per-connection memory. Hot pages get evicted, and the first requests after traffic returns read from storage while capacity climbs back up.

To choose the floor, use measurements from your own baseline:

  • Working set: take the memory your steady-state working set needs.
  • Connection overhead: add the memory consumed by your typical connection count.
  • Convert: divide the total by memory per ACU and round up.

Compare the result against the ServerlessDatabaseCapacity metric during your quietest periods.

The maximum is a safety valve, and it is also a cost risk. A missing index, a runaway query or a client retry storm does not show up as an outage. Aurora scales up to absorb it and bills you for the added capacity. Set the max to cover your real peak with some headroom, not the largest value allowed.

Two alarms catch this early:

  • Capacity alarm: a CloudWatch alarm on sustained high capacity.
  • Spend alarm: a budget alert on database spend.

The range itself is a single pair of values: MinCapacity and MaxCapacity in the --serverless-v2-scaling-configuration option of aws rds modify-db-cluster.

#!/usr/bin/env bash
set -euo pipefail

CLUSTER_ID="orders-pg"
SNS_TOPIC_ARN="arn:aws:sns:us-east-1:123456789012:db-capacity-alerts"

# Floor sizing (illustrative estimate, assumed inputs):
#   steady-state working set   ~6 GiB
#   ~200 connections x ~10 MiB ~2 GiB
#   total 8 GiB / ~2 GiB per ACU = 4 ACU minimum
# Max: assumed observed peak ~12 ACU plus headroom = 16 ACU.
# Do not set the max to the largest value allowed.
MIN_ACU=4
MAX_ACU=16

# Set the capacity range on the cluster.
aws rds modify-db-cluster \
  --db-cluster-identifier "$CLUSTER_ID" \
  --serverless-v2-scaling-configuration MinCapacity=${MIN_ACU},MaxCapacity=${MAX_ACU} \
  --apply-immediately

# Alarm when capacity stays near the max for 30 minutes.
# Sustained high ACU usually means a runaway query, a missing index or a
# retry storm, and it is being billed rather than failing visibly.
aws cloudwatch put-metric-alarm \
  --alarm-name "${CLUSTER_ID}-sustained-high-acu" \
  --namespace AWS/RDS \
  --metric-name ServerlessDatabaseCapacity \
  --dimensions Name=DBClusterIdentifier,Value="$CLUSTER_ID" \
  --statistic Average \
  --period 300 \
  --evaluation-periods 6 \
  --threshold 12 \
  --comparison-operator GreaterThanOrEqualToThreshold \
  --alarm-actions "$SNS_TOPIC_ARN"

# Pair this with a budget alert on database spend. The capacity alarm
# catches the cause, and the budget alert catches the bill.

Sets an Aurora Serverless v2 capacity range from a floor based on baseline memory and adds a CloudWatch alarm that fires on sustained capacity near the maximum.

How does scaling behavior affect cost and latency?

Scaling is incremental and usually quick, but it is reactive. Aurora adds ACUs after it sees CPU, memory, or connection pressure, not before. Scale-up is fast. Scale-down is deliberately slower, so after a short spike you keep paying for capacity the workload no longer uses.

Load vs. allocated ACU over time. Illustrative estimate (assumed numbers, not a benchmark).

Minute 0 2 4 6 10 14 18
ACU needed by load 2 16 16 2 2 2 2
ACU allocated 2 12 16 14 9 5 2

In this example the spike lasts about 4 minutes, but capacity stays elevated for about 12 more. The gap is the shaded area under the "allocated" curve:

Extra cost ≈ Σ (allocated ACU − needed ACU) × interval in hours × price per ACU-hour

Repeat that for each spike per day and multiply by the number of spikes to see what the lag costs you.

Cache shrinkage. As ACUs drop, so does memory for Postgres shared buffers. The first queries of the next spike can miss cache and read from storage. That raises latency and I/O exactly when load is climbing. A higher minimum ACU keeps more of the working set warm, at the cost of more baseline spend.

Connections hold capacity up. Each Postgres backend uses memory. Hundreds of idle application connections can keep the instance from scaling down even when queries are idle. A connection pooler in transaction mode reduces backend count, which lets capacity fall faster. The trade-off is another component to deploy, monitor, and fail over, and it can break session-level features such as prepared statements and advisory locks.

 ACU   # = ACU needed by load   o = ACU allocated   @ = both

  16 |       #  #  @  #
  14 |          o     o  o
  12 |       o              o
  10 |                         o  o
   8 |    #                          o  o
   6 |    o                                o  o
   4 |                                           o  o
   2 | @                 #  #  #  #  #  #  #  #  #  #  @  @  @
     +----------------------------------------------------------
       0     2     4     6           10          14          18  min
             |<- spike ->|<----- lag: billed, unused ---->|

 +-----------+  many idle   +-----------+  few busy   +----------------+
 | App pods  |------------->|  Pooler   |------------>|  Aurora Sv2    |
 | (N conns) |  connections | (txn mode)|  backends   | less memory,   |
 +-----------+              +-----------+             | ACU can fall   |
                                                      +----------------+

Illustrative estimate, not a benchmark: allocated ACUs rise quickly to meet a four-minute spike but take about twelve more minutes to step down, and that unused capacity is billed. A transaction-mode pooler reduces the number of Postgres backends, which can let capacity fall sooner.

How do you measure your Postgres load curve before switching?

Start with at least two weeks of data from the existing instance, so the window covers weekday peaks, weekend troughs and any batch jobs. Pull CPUUtilization, FreeableMemory and DatabaseConnections from the AWS/RDS namespace with aws cloudwatch get-metric-statistics, using the DBInstanceIdentifier dimension, --period 3600, and both Average and Maximum statistics. You need both statistics because an hourly average hides the short bursts that decide where your maximum ACU should sit.

Next, replay a representative workload against a small test Serverless v2 cluster and pull two metrics. ServerlessDatabaseCapacity shows the ACUs actually allocated. ACUUtilization shows how close the cluster ran to its configured maximum. Together they show how your real queries translate into capacity, and that ratio is usually different from what CPU percentages on the provisioned instance suggest.

From these results, build a 24-row profile of expected ACUs for each hour of a typical day. Multiply each hour's ACUs by the per-ACU-hour rate for your region and sum the 24 values. Then compare that total against 24 × the hourly price of the instance you would otherwise provision.

Illustrative estimate: assume 18 hours at 2 ACU and 6 hours at 12 ACU. That gives 108 ACU-hours per day. If the right-sized instance costs the same as roughly 8 ACU-hours per hour, the instance totals 192, so serverless comes out ahead.

This measurement takes a few days. Reversing a migration that was justified by guesswork involves a second cutover, re-tuning and weeks of cost surprises.

#!/usr/bin/env bash
# Pull hourly CloudWatch data and turn it into a 24-hour ACU cost profile.
set -euo pipefail
START=$(date -u -d '14 days ago' +%Y-%m-%dT%H:%M:%SZ)   # GNU date
END=$(date -u +%Y-%m-%dT%H:%M:%SZ)

# 1. Existing provisioned instance. Average shows the baseline and Maximum shows bursts.
for m in CPUUtilization FreeableMemory DatabaseConnections; do
  aws cloudwatch get-metric-statistics \
    --namespace AWS/RDS --metric-name "$m" \
    --dimensions Name=DBInstanceIdentifier,Value=orders-db-prod \
    --start-time "$START" --end-time "$END" --period 3600 \
    --statistics Average Maximum \
    --query 'sort_by(Datapoints,&Timestamp)[*].[Timestamp,Average,Maximum]' \
    --output text > "instance-$m.tsv"
done

# 2. Test Serverless v2 cluster, after replaying a representative workload.
for m in ServerlessDatabaseCapacity ACUUtilization; do
  aws cloudwatch get-metric-statistics \
    --namespace AWS/RDS --metric-name "$m" \
    --dimensions Name=DBClusterIdentifier,Value=orders-sv2-test \
    --start-time "$START" --end-time "$END" --period 3600 \
    --statistics Average Maximum \
    --query 'sort_by(Datapoints,&Timestamp)[*].[Timestamp,Average,Maximum]' \
    --output text > "serverless-$m.tsv"
done

# 3. Break-even. The rates below are PLACEHOLDERS, so use your region's prices.
ACU_RATE=0.12        # USD per ACU-hour (assumed)
INSTANCE_RATE=0.96   # USD per hour for the right-sized instance (assumed)
# Average ACU per hour approximates billed ACU-hours. Max ACU guides the capacity ceiling.
# Hours with no data drop out of the sum, so check that all 24 rows are present.
awk -v acu="$ACU_RATE" -v inst="$INSTANCE_RATE" '
  { h = substr($1, 12, 2); sum[h] += $2; n[h]++; if ($3 > peak) peak = $3 }
  END {
    for (h in sum) { total += sum[h] / n[h]; hours++ }
    printf "hours profiled: %d  ACU-hours/day: %.1f  peak ACU: %.1f\n", hours, total, peak
    printf "serverless/day: $%.2f  provisioned/day: $%.2f\n", total * acu, 24 * inst
  }' serverless-ServerlessDatabaseCapacity.tsv

The script pulls hourly Average and Maximum CloudWatch statistics from the existing RDS instance and from a test Serverless v2 cluster. It then folds the ACU data into a 24-hour profile and compares estimated daily serverless cost against the provisioned instance using placeholder prices.

When should you avoid Aurora Serverless v2?

The clearest case against serverless is a database that is rarely idle. An ACU costs more than the equivalent slice of a provisioned instance, which only pays off when the cluster spends long stretches near its minimum. If your load curve shows sustained high usage for most of the day with brief dips, you pay the premium on nearly every hour and gain little from scaling down.

Commitment pricing widens that gap. A provisioned instance with steady usage can be covered by reserved pricing, which lowers its effective hourly rate further. Check current AWS terms for how commitment discounts apply to serverless capacity rather than assuming they work the same way. A comparison that applies reserved rates to one side and on-demand rates to the other will be wrong.

Forecasting is a separate concern. Per-second billing on variable capacity means the monthly bill depends on traffic you don't control. A marketing push or a runaway batch job can raise costs before anyone notices. Teams with fixed budgets or strict approval processes often prefer a known instance price, even if it costs somewhat more on average.

If you run standard RDS for PostgreSQL today, adopting serverless also means moving to Aurora. That adds migration work, regression testing, and a different storage and I/O billing model that needs its own cost analysis. Finally, supported features and configurations can differ between serverless and provisioned Aurora. Confirm that your engine version, extensions and replication setup are supported before you commit.

What are the alternatives and hybrid setups worth pricing?

Even after you have done that check, Serverless v2 is only one option. The alternatives below are often cheaper, and they can be combined with it.

  • Provisioned plus commitments. If production holds a steady baseline most of the day, reserved or commitment pricing on a right-sized instance usually beats paying ACU rates for the same capacity. The discount is applied to load you were going to run anyway.
  • Mixed Aurora clusters. An Aurora cluster can contain both provisioned and Serverless v2 instances. A common pattern is a provisioned writer for the predictable write path with serverless readers that absorb read bursts. The reverse also works: a serverless writer for spiky writes, with provisioned readers sized for steady reporting traffic.
  • Scheduled resizing. If your peaks follow a known schedule, such as business hours or nightly batches, resizing a provisioned instance on a schedule captures much of the savings without per-second scaling. You trade some agility for a predictable bill.
  • Stopping non-production databases. A stopped cluster stops compute charges but still bills for storage. It also restarts automatically after a limited period, so the stop has to be automated and repeated.
  • Connection pooling. A pooler reduces connection overhead. That can lower the ACU floor you need and smooth scaling triggered by connection storms.

Non-production environments are the clearest serverless win. Dev, staging and preview databases sit idle most of the day, and a low ACU floor costs less than an always-on instance.

Decision table

Workload / environment Recommended option Development and operational cost
Dev, preview, staging Serverless v2, low minimum ACU Lowest idle cost, little management
Steady-baseline production Provisioned + commitment Cheapest per unit, requires capacity planning
Steady writes, bursty reads Provisioned writer + serverless readers Moderate complexity, pays for bursts only
Predictable daily peaks Scheduled resizing Requires automation, brief resize windows
Spiky, unpredictable production Serverless v2 + pooling Higher per-unit rate, less on-call tuning

How OneEnv can help

Disclosure: OneEnv is the product behind this blog.

OneEnv (oneenv.io) is a workspace-based governance platform for the things services share — environment variables, database structure, API routes and validation rules. A change to a shared value is staged on a branch, reviewed once, and then every affected service explicitly approves or rejects it before it goes live, so you can see who a change touches before it ships instead of finding out in production.

Applied to aurora serverless v2 vs rds cost, this is where it helps:

Saves time

  • Every service that inherits a shared value is listed in one place, so nobody searches repos and chats to find out who is affected.
  • One review per branch replaces coordinating each team separately; each service still keeps its own approve/reject.
  • Reviewers see the exact diff and the list of affected services up front, so approval is a decision rather than an investigation.

Saves cost

  • Fewer production incidents and rollbacks caused by a shared value, route or column changing under a consumer unannounced.
  • Less duplicated configuration to maintain: one shared definition inherited by many services.
  • Per-service approve/reject means a bad shared value can be refused where it would break something, before it is live.
  • OneEnv has a free plan (1 workspace, unlimited services and members, full governance), so trying it costs nothing.

These are qualitative benefits, not measured results — how much you save depends on how many services share the value.

Want to try it? Start at oneenv.io.