What is an ACU and how does Aurora Serverless v2 billing work?

An Aurora Capacity Unit (ACU) is Aurora Serverless v2's unit of database capacity. It bundles compute and memory: one ACU is roughly 2 GiB of memory plus a proportional share of CPU and networking. These resources scale together. You can't request more CPU without also paying for more memory, so a CPU-bound workload with a small working set still pays for memory it may not use.

Billing is per ACU-hour, metered in fine-grained increments rather than whole hours. If an instance runs at 4 ACUs for 15 minutes and then drops to 1 ACU, you pay for 4 ACUs for those 15 minutes and 1 ACU afterward. Storage, I/O (depending on the cluster's storage configuration), and backups are billed separately, just as they are for provisioned Aurora. ACU charges cover only the instance layer.

For each Serverless v2 instance you configure a minimum and maximum ACU. Aurora adjusts capacity continuously within that range in small steps, typically fractions of an ACU, based on CPU, memory pressure, and connection load. It does not swap instances, so scaling doesn't drop connections. The minimum sets your idle cost floor. The maximum caps both your peak spend and your peak performance.

Several details depend on the engine and version: the lowest allowed minimum, how quickly capacity rises and falls, and whether an instance can scale to zero and pause when idle. Check the current Aurora documentation for your exact engine version before you model costs. An assumption that holds on one version may not hold on another.

Why does the per-ACU rate matter more than the scaling?

Scaling behaviour gets most of the attention, but the per-unit rate decides most of the bill. Each ACU provides roughly 2 GiB of memory with proportional CPU, so the fair comparison is between a provisioned instance and the ACU count that matches its memory. For example, an instance with 32 GiB lines up with 16 ACUs. Take the current on-demand ACU-hour price for your region, multiply it by that ACU count, and compare the result with the instance's hourly price in the same region and engine.

In most regions this comparison shows a premium for Serverless v2: 16 ACUs held for an hour cost more than the equivalent instance-hour. That premium is the cost of elasticity. You recover it only when your average consumed ACUs sit well below the provisioned size you would otherwise run. Peak usage does not settle the question. Average usage does. Reserved or other committed pricing applies to provisioned instances, so it lowers the provisioned side and widens the gap.

Line item Differs between options?
Compute (ACU-hours vs instance-hours) Yes, and this is the main variable
Storage Same within Aurora
I/O Same under the chosen Aurora storage configuration
Backups Same, count on both sides
Data transfer Same, count on both sides

The table holds only when both options are Aurora. If you are moving from non-Aurora RDS, Aurora uses its own storage and I/O pricing model. Price that change on its own before you attribute any savings or losses to Serverless v2.

How do you calculate break-even utilization for Aurora Serverless v2 vs RDS cost?

The comparison reduces to one ratio. A provisioned instance bills for its full capacity every hour. Serverless v2 bills only for the ACUs it actually holds, but at a higher per-unit rate.

Define:

  • P: peak ACUs you must be able to serve, which is what the provisioned instance is sized for
  • A: average ACUs consumed across the month
  • R_p: provisioned cost per ACU-hour of capacity (instance hourly price ÷ its ACU-equivalent)
  • R_s: serverless price per ACU-hour
  • H: hours in the month

Provisioned cost is P × R_p × H, and serverless cost is A × R_s × H. Serverless is cheaper when A / P < R_p / R_s. Because R_s is higher than R_p, the ratio on the right is below 1. Serverless v2 only wins when your average utilization falls below that ratio.

Illustrative estimate (assumed numbers, not a benchmark). All of these inputs are assumed:

  • R_s = $0.12 and R_p = $0.06, so break-even is 0.5.
  • Peak is 32 ACUs.
  • Baseline is 8 ACUs (25% of peak) for 22 hours a day.
  • The spike is 4× baseline (32 ACUs) for 2 hours a day.
  • H = 730.

That gives A = (8×22 + 32×2) / 24 = 240 / 24 = 10 ACUs. Utilization against a 32-ACU instance is 10/32 = 0.31, which is under 0.5.

Option (assumed) Formula Monthly compute
Provisioned with 2× headroom (64 ACU-eq) 64 × $0.06 × 730 $2,803.20
Provisioned right-sized to peak (32 ACU-eq) 32 × $0.06 × 730 $1,401.60
Serverless v2 (avg 10 ACU) 10 × $0.12 × 730 $876.00

The serverless figure assumes scaling tracks load closely. If scale-down lags, or your minimum ACU sits above the baseline, A rises toward the break-even point.

# Break-even calculator for Aurora Serverless v2 vs provisioned compute.
# Every rate and load figure is an ASSUMED input (illustrative estimate, not measured).

R_S = 0.12   # assumed serverless price per ACU-hour
R_P = 0.06   # assumed provisioned cost per ACU-hour of capacity
H = 730      # hours in the month

PEAK = 32            # ACUs needed at the daily spike
BASELINE = 8         # 25% of peak
SPIKE_HOURS = 2      # hours per day at peak

def avg_acus(min_acu=0):
    # Serverless cannot drop below its configured minimum, so the floor raises A.
    base = max(BASELINE, min_acu)
    return (base * (24 - SPIKE_HOURS) + PEAK * SPIKE_HOURS) / 24

break_even = R_P / R_S
print(f"break-even A/P: {break_even:.2f}")

for min_acu in (0, 12, 16):
    a = avg_acus(min_acu)
    util = a / PEAK
    winner = "serverless" if util < break_even else "provisioned"
    print(f"min_acu={min_acu:>2}  A={a:5.2f}  A/P={util:.2f}  cheaper: {winner}")

# Monthly compute for the three options in the table (default floor of 0).
options = {
    "provisioned, 2x headroom (64 ACU-eq)": 64 * R_P * H,
    "provisioned, right-sized (32 ACU-eq)": PEAK * R_P * H,
    "serverless v2 (avg ACUs)": avg_acus() * R_S * H,
}
for name, cost in options.items():
    print(f"{name:<38} ${cost:,.2f}")

A short Python script that applies the A/P < R_p/R_s break-even test to the assumed rates and spike profile, shows how a higher minimum ACU raises average utilization toward break-even, and reproduces the illustrative monthly totals of $2,803.20, $1,401.60 and $876.00.

How do you measure your real spike profile before deciding?

Pull at least two weeks of data, and make sure the window covers a month-end, a batch run, or whatever usually drives your peaks. A quiet week will understate both the peak and how often it happens.

On a provisioned instance

Use the AWS/RDS namespace with the DBInstanceIdentifier dimension. Query three metrics:

  • CPUUtilization shows compute pressure.
  • FreeableMemory shows whether the working set would push Serverless v2 to scale. Serverless v2 scales on memory as well as CPU.
  • DatabaseConnections shows whether a spike is real query load or a connection storm from an application tier that is scaling out.

aws cloudwatch get-metric-statistics can return Average and Maximum together. Two limits shape how you query:

  • Points per call. A call returns at most 1,440 data points. Use --period 3600 for a 30-day overview, then rerun at --period 60 on individual spike windows.
  • Retention. CloudWatch keeps 1-minute data for only 15 days, so the fine-grained pass has to cover recent spikes.

On an existing Serverless v2 cluster

Query two metrics:

  • ServerlessDatabaseCapacity gives the ACUs actually billed per period.
  • ACUUtilization shows how much of your configured maximum you are using.

The average of ServerlessDatabaseCapacity over the month is your A. Use the measured value rather than an estimate.

Turning results into formula inputs

  1. Peak-to-average ratio. Divide mean CPU by the hourly maximum CPU.
  2. Translate to ACUs. At 1 ACU ≈ 2 GiB of memory, map the instance's capacity to an ACU equivalent. Multiply that by the ratio to approximate A.
  3. Spike duration. Count consecutive 1-minute periods above roughly 70% CPU. Short, sharp spikes favor serverless. Long plateaus behave like baseline load and favor provisioned.

Keep the FreeableMemory result in mind. If it stays low even when CPU is idle, a large buffer pool is holding capacity up, and A will sit above what CPU alone suggests.

#!/usr/bin/env bash
set -euo pipefail
INSTANCE="orders-db-prod"; CLUSTER="orders-aurora-sv2"
END=$(date -u +%Y-%m-%dT%H:%M:%SZ)
START=$(date -u -d '30 days ago' +%Y-%m-%dT%H:%M:%SZ)

# Pass 1: hourly Average and Maximum over 30 days (720 points, under the 1,440 cap).
# Rerun with FreeableMemory and DatabaseConnections by changing --metric-name.
aws cloudwatch get-metric-statistics --namespace AWS/RDS \
  --metric-name CPUUtilization \
  --dimensions Name=DBInstanceIdentifier,Value="$INSTANCE" \
  --start-time "$START" --end-time "$END" --period 3600 \
  --statistics Average Maximum \
  --query 'Datapoints[].[Average,Maximum]' --output text > cpu_hourly.tsv

# Peak-to-average ratio = highest hourly maximum / mean of hourly averages.
awk '{s+=$1; n++; if ($2>m) m=$2} END {printf "mean=%.1f%% peak=%.1f%% ratio=%.2f\n", s/n, m, m/(s/n)}' cpu_hourly.tsv

# Pass 2: 1-minute data for one spike window. Must fall within the last 15 days,
# and 24h at --period 60 is exactly 1,440 points.
SPIKE_START="2026-10-31T00:00:00Z"; SPIKE_END="2026-11-01T00:00:00Z"
aws cloudwatch get-metric-statistics --namespace AWS/RDS \
  --metric-name CPUUtilization \
  --dimensions Name=DBInstanceIdentifier,Value="$INSTANCE" \
  --start-time "$SPIKE_START" --end-time "$SPIKE_END" --period 60 \
  --statistics Maximum \
  --query 'sort_by(Datapoints,&Timestamp)[].Maximum' --output text | tr '\t' '\n' > cpu_1m.txt

# Spike duration: longest run of consecutive minutes above 70% CPU.
awk '$1>70 {r++; if (r>b) b=r; next} {r=0} END {print "longest run >70%: " b+0 " min"}' cpu_1m.txt

# Existing Serverless v2 cluster: the mean of hourly ServerlessDatabaseCapacity is measured A (ACUs).
aws cloudwatch get-metric-statistics --namespace AWS/RDS \
  --metric-name ServerlessDatabaseCapacity \
  --dimensions Name=DBClusterIdentifier,Value="$CLUSTER" \
  --start-time "$START" --end-time "$END" --period 3600 \
  --statistics Average --query 'Datapoints[].Average' --output text \
  | tr '\t' '\n' | awk '{s+=$1; n++} END {printf "A=%.2f ACU\n", s/n}'

Pulls 30 days of hourly CPU statistics to compute the peak-to-average ratio (highest hourly maximum divided by mean), runs a 1-minute pass over one recent spike to measure how long CPU stays above 70%, and averages ServerlessDatabaseCapacity on an existing Serverless v2 cluster to get a measured A.

How should you set minimum and maximum ACU without overpaying?

The minimum ACU is the one setting you pay for every hour of the month, whether or not traffic arrives. That makes it the largest cost lever. A floor of 8 ACU costs the same overnight as it does at noon, so each ACU you add to the floor multiplies across roughly 730 hours a month.

Size the floor from memory, not idle CPU

Size the floor from the working set, not from idle CPU. Each ACU comes with a fixed amount of memory, and the buffer pool shrinks when capacity drops. If the floor is too low, a quiet period evicts hot pages. When the next spike arrives, queries read from storage while the cluster scales up, so latency rises at the moment it matters most. Choose a floor that keeps your frequently accessed indexes and tables cached. Then accept that this cost behaves like a provisioned baseline.

Treat the maximum as two ceilings

The maximum ACU limits both cost and performance. If it is set too low, an incident or a legitimate surge gets throttled. If it is set too high, a missing index, a runaway report query, or a client retry storm can scale the cluster to its limit and keep it there for hours. Set the maximum from the peak you have actually observed, plus deliberate headroom.

Control connection count

Connection-heavy workloads hold capacity up. Each connection consumes memory, so thousands of mostly idle connections from autoscaled application pods can prevent scale-down. A connection pooler in front of the cluster caps the number of backend connections and lets capacity fall back to the floor.

Alert on capacity and spend

The database bill is no longer a fixed line item, so set up two kinds of alerts:

  • CloudWatch alarms on ServerlessDatabaseCapacity and ACUUtilization, for example when capacity stays near the maximum for an extended period.
  • Cost anomaly alerts on daily spend.
#!/usr/bin/env bash
set -euo pipefail

CLUSTER_ID="orders-aurora-cluster"   # placeholder cluster name
SNS_TOPIC_ARN="arn:aws:sns:us-east-1:123456789012:db-capacity-alerts"  # placeholder
MAX_ACU=32

# Floor sized from working set (keeps hot indexes cached), not idle CPU.
# Ceiling = observed peak plus deliberate headroom; it caps cost AND performance.
aws rds modify-db-cluster \
  --db-cluster-identifier "$CLUSTER_ID" \
  --serverless-v2-scaling-configuration MinCapacity=4,MaxCapacity=$MAX_ACU \
  --apply-immediately

# Alert when capacity sits near the ceiling for 30 minutes:
# either you are being throttled, or a runaway query/retry storm is running up the bill.
aws cloudwatch put-metric-alarm \
  --alarm-name "${CLUSTER_ID}-capacity-near-max" \
  --namespace AWS/RDS \
  --metric-name ServerlessDatabaseCapacity \
  --dimensions Name=DBClusterIdentifier,Value="$CLUSTER_ID" \
  --statistic Average \
  --period 300 \
  --evaluation-periods 6 \
  --threshold $((MAX_ACU * 90 / 100)) \
  --comparison-operator GreaterThanOrEqualToThreshold \
  --alarm-actions "$SNS_TOPIC_ARN"

# ACUUtilization is a percentage of MaxCapacity; sustained high values mean the ceiling is binding.
aws cloudwatch put-metric-alarm \
  --alarm-name "${CLUSTER_ID}-acu-utilization-high" \
  --namespace AWS/RDS \
  --metric-name ACUUtilization \
  --dimensions Name=DBClusterIdentifier,Value="$CLUSTER_ID" \
  --statistic Average \
  --period 300 \
  --evaluation-periods 6 \
  --threshold 90 \
  --comparison-operator GreaterThanOrEqualToThreshold \
  --alarm-actions "$SNS_TOPIC_ARN"

Sets an explicit Aurora Serverless v2 floor and ceiling with the AWS CLI, then adds CloudWatch alarms that fire when capacity stays near the maximum for 30 minutes.

How do readers, Multi-AZ and mixed clusters change the bill?

Every Serverless v2 instance in a cluster is billed for its own ACU-hours. A writer and two readers are three separate meters, not one shared pool. In Aurora, Multi-AZ means you run a reader in another Availability Zone, because cluster storage is already replicated across zones and is not billed per replica. High availability therefore costs at least one extra compute meter.

What that reader costs depends on its failover tier. Readers in tiers 0 and 1 track the writer's capacity, so they are sized to take over without a cold scale-up. Readers in tiers 2–15 scale on their own load.

                 Aurora cluster (shared storage)
 ┌────────────────────────────────────────────────────────┐
 │  Writer  ──── capacity mirrored ────▶  Reader (tier 0)  │
 │  0.5–32 ACU                            follows writer   │
 │                                                         │
 │  Reader (tier 2)          Reader (tier 15)              │
 │  scales on own load       scales on own load            │
 └────────────────────────────────────────────────────────┘

Illustrative estimate: if the writer averages 16 ACUs during a spike, a tier-0 reader that serves almost no queries still bills about 16 ACUs. That nearly doubles compute for the spike. The cost is reasonable if you need a fast failover. If you don't, move the reader to tier 2 or lower.

Aurora also lets you mix instance types in one cluster. If writes are steady and only reads spike, for example during catalog browsing or report generation, a provisioned writer bought at the lower per-hour rate can sit alongside Serverless v2 readers that absorb read bursts. You pay the ACU premium only on the part of the workload that actually varies.

┌────────────────────────── Aurora cluster ──────────────────────────┐
│                                                                    │
│  ┌──────────────────┐    capacity    ┌──────────────────────┐      │
│  │ Writer           │    mirrored    │ Reader, tier 0 or 1  │      │
│  │ Serverless v2    │───────────────▶│ follows writer ACUs  │      │
│  │ AZ-a             │                │ AZ-b, failover pair  │      │
│  │ ACU meter #1     │                │ ACU meter #2         │      │
│  └────────┬─────────┘                └──────────┬───────────┘      │
│           │                                     │                  │
│  ┌────────┴─────────────────────────────────────┴───────────┐      │
│  │ Shared cluster storage (replicated across AZs)           │      │
│  │ Billed once per cluster, not per replica                 │      │
│  └────────┬─────────────────────────────────────┬───────────┘      │
│           │                                     │                  │
│  ┌────────┴─────────┐                ┌──────────┴───────────┐      │
│  │ Reader, tier 2   │                │ Reader, tier 15      │      │
│  │ scales on own    │                │ scales on own        │      │
│  │ read load        │                │ read load            │      │
│  │ ACU meter #3     │                │ ACU meter #4         │      │
│  └──────────────────┘                └──────────────────────┘      │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘
 Tier 0/1: sized for fast failover, bills about what the writer bills.
 Tier 2-15: bills only for its own read load.
 Mixed option: provisioned writer + Serverless v2 readers for spiky reads.

Each Serverless v2 instance in an Aurora cluster has its own ACU meter: a tier 0 or 1 reader mirrors the writer's capacity, so it bills about what the writer bills, while readers in tiers 2–15 scale and bill on their own load.

When should you avoid Aurora Serverless v2, and what are the alternatives?

Serverless v2 pays off when the peak-to-baseline ratio is high and spikes are short and unpredictable. A provisioned instance would sit mostly idle in that case. Dev and test databases, and low-traffic multi-tenant clusters that are quiet most of the day, fit this profile. Paying the ACU premium for a few busy hours costs less than paying for a peak-sized instance around the clock.

Avoid it when the load is steady or the spikes are predictable, such as daily batch jobs or business-hours traffic. In those cases you know the capacity in advance, so you can buy it at the provisioned rate. Very sharp spikes are also a poor fit. If load arrives faster than capacity can scale, you either suffer latency or raise the minimum ACU, and a high minimum erases the savings. Teams that need a fixed monthly budget will find variable ACU billing harder to forecast and cap.

Alternative Best for Why it's cheaper
Reserved instances on a right-sized provisioned instance Steady baseline You get a discount for committing to capacity you would use anyway
Scheduled scaling or instance resizing Predictable daily or weekly peaks You pay for peak size only during the known window
Query tuning and caching Any spike driven by repeated or inefficient reads It lowers the peak itself, so every pricing model gets cheaper

Decision checklist

  • Flat load: use provisioned with reserved pricing.
  • Predictable peaks: use provisioned with scheduled resizing.
  • Unpredictable, short, high-ratio spikes: use Serverless v2.
  • Near-instant spikes: use provisioned sized for the peak, or a high Serverless v2 minimum. Compare the cost of both.
  • Any spike profile: profile the top queries before choosing a pricing model.

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.
  • Changing a shared variable is one edit and one review instead of editing every service's .env by hand.

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.
  • A wrong or stale value is caught at review time by the services it affects, not by a failed deploy.
  • 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.