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

Aurora Serverless v2 is a capacity mode for Aurora MySQL and Aurora PostgreSQL in which a DB instance resizes itself while it runs. You don't pick an instance class. You set a minimum and maximum capacity, measured in Aurora Capacity Units (ACUs). Each ACU is roughly 2 GiB of memory with a proportional share of CPU and networking, so these resources scale together and you can't add CPU without also adding memory.

Aurora scaling adjusts capacity in fine-grained steps (half an ACU) anywhere between your min and max settings. It responds to CPU, memory, and connection pressure, and it does this without a failover or a manual resize. That is the main reason teams adopt it. A cluster can absorb a spike, then shrink back, and no one has to schedule a modify-instance window or overprovision for the peak hour.

Billing is per ACU-hour and metered in small increments. You pay for the capacity the instance is scaled to at each moment. You don't pay for the queries it serves. An idle instance that is sitting at 4 ACUs because of your minimum costs the same as a busy one at 4 ACUs. Rates vary by region and change over time, so check the current per-ACU and per-instance-hour prices on the AWS pricing page. Don't rely on any figures in this article.

Compute is only part of the bill

The following costs stay the same whether you run serverless v2 or provisioned instances:

  • storage
  • I/O charges, which depend on your storage configuration
  • backups
  • data transfer

The comparisons that follow cover compute only. When you estimate savings, add these fixed costs back into the total. For example, a 40% compute reduction may be much smaller as a share of your full bill.

How do you calculate the break-even between serverless v2 and provisioned?

The core comparison takes one division. Take the hourly price of the provisioned instance class you would actually run, and divide it by the per-ACU-hour price in the same region:

break-even ACU = provisioned hourly cost ÷ price per ACU-hour

The result is the average ACU level at which both options cost the same for compute. If your cluster's time-weighted average ACU stays below that line, serverless v2 is cheaper. If it sits above the line, provisioned is cheaper. The provisioned instance should be the one sized for your real peak plus headroom, not the largest instance in the family.

Peak capacity is the wrong comparison. A cluster that reaches 32 ACU for one hour a day and holds 4 ACU for the other 23 has a daily average close to 5 ACU. Matching serverless at its peak against a provisioned instance at its peak hides the reason serverless exists: you stop paying for idle headroom. Average across a full billing cycle, including nights and weekends, because short bursts barely move the mean.

Use the provisioned price you would really pay. Reserved instances or other savings commitments lower the provisioned hourly cost, which lowers the break-even ACU. Serverless then has to run leaner to win. For example, assume a 35% commitment discount. The break-even drops by the same 35%, so a workload that wins on serverless at on-demand rates can lose once the discount applies. If your organization already holds commitments, put the effective blended rate into the numerator, not the list price.

# Break-even model: Aurora Serverless v2 vs provisioned (compute only).
# All prices are PLACEHOLDERS. Replace them with your region's rates or your billing data.

def break_even_acu(provisioned_hourly, acu_hour_price, commitment_discount=0.0):
    """Average ACU at which serverless v2 and provisioned cost the same."""
    # Use the rate you would actually pay. A commitment discount lowers the numerator.
    effective_hourly = provisioned_hourly * (1 - commitment_discount)
    return effective_hourly / acu_hour_price

def time_weighted_avg_acu(samples):
    """samples: list of (acu_level, hours_at_that_level) over a full billing cycle."""
    total_hours = sum(hours for _, hours in samples)
    return sum(acu * hours for acu, hours in samples) / total_hours

# Placeholder inputs (illustrative only, not real prices).
PROVISIONED_HOURLY = 0.80  # on-demand $/hour for the right-sized instance class
ACU_HOUR_PRICE = 0.12      # $/ACU-hour in the same region

# One representative day: 32 ACU for 1 hour, 4 ACU for the other 23 hours.
# The peak is 32 ACU, but the average is about 5.17 ACU. The average is what you pay for.
day = [(32, 1), (4, 23)]
avg = time_weighted_avg_acu(day)

for label, discount in [("on-demand", 0.0), ("35% commitment", 0.35)]:
    be = break_even_acu(PROVISIONED_HOURLY, ACU_HOUR_PRICE, discount)
    winner = "serverless v2" if avg < be else "provisioned"
    print(f"{label:>15}: break-even {be:.2f} ACU, avg {avg:.2f} ACU -> {winner}")

# Illustrative output with these placeholder inputs:
#       on-demand: break-even 6.67 ACU, avg 5.17 ACU -> serverless v2
#  35% commitment: break-even 4.33 ACU, avg 5.17 ACU -> provisioned

A small Python function that computes the break-even average ACU from placeholder prices, compares it to a time-weighted average rather than the peak, and shows how a 35% commitment discount reverses the result for the same workload.

Database cost comparison: three workload profiles (illustrative estimate)

Illustrative estimate (assumed numbers, not a benchmark). None of these prices are AWS quotes. Replace them with your region's current rates before you draw conclusions.

Assumed inputs:

  • Serverless v2: $0.12 per ACU-hour.
  • Provisioned instance sized for a 16 ACU peak: $1.00/hour on-demand, or $0.65/hour with a 35% commitment discount.
  • Month length: 730 hours.
  • Storage and I/O: $300/month in every scenario. These charges do not change between the two options.

Formulas:

  • Serverless compute = Σ(ACU level × hours at that level) × ACU price
  • Average ACU = total ACU-hours ÷ 730
  • Provisioned compute = hourly rate × 730

Workload profiles:

  • Business hours: 16 ACU for 8 h × 22 weekdays (176 h), and 1 ACU for the other 554 h.
  • Steady 24/7: a flat 12 ACU around the clock.
  • Bursty batch: 16 ACU for 2 h/day × 30 days (60 h), and 0.5 ACU for the other 670 h.
Profile ACU-hours Avg ACU Serverless compute Total bill (serverless) vs on-demand total ($1,030) vs discounted total ($774.50)
Business hours 3,370 4.62 $404.40 $704.40 −32% −9%
Steady 24/7 8,760 12.00 $1,051.20 $1,351.20 +31% +74%
Bursty batch 1,295 1.77 $155.40 $455.40 −56% −41%

The provisioned instance bills for its full 16 ACU of capacity every hour. Serverless bills only for the capacity in use. When the average sits far below peak, as in the business-hours and batch profiles, serverless wins. The steady workload averages 75% of peak, and its per-ACU premium makes it more expensive than provisioned even at on-demand rates.

Storage and I/O shrink every percentage gap. In this example, the batch workload's compute saving is 79% against on-demand, but only 56% on the total bill. If storage is a large share of your bill, the compute choice matters less than it first appears.

How can you estimate your real average ACU usage before migrating?

You can get a usable number in two ways. The first is cheap but approximate. The second costs a few days of trial spend and gives you a measured figure.

Option 1: Map your provisioned cluster's metrics

Each ACU is roughly 2 GiB of memory plus matching CPU and networking. Divide your instance's memory by two to get the ACU ceiling it represents. Then scale that ceiling by the hourly CPUUtilization average, and check FreeableMemory as you go.

Watch memory closely. Serverless v2 tends to keep capacity high enough to hold the buffer cache. A cluster with low CPU but a large hot working set will therefore bill closer to its memory footprint than its CPU suggests. Treat the CPU-scaled figure as a floor, not an estimate.

Option 2: Run a trial serverless v2 cluster

Restore a snapshot to a serverless v2 instance and replay production-like traffic. Then read two metrics:

  • ServerlessDatabaseCapacity: the ACUs actually allocated, which is what you pay for.
  • ACUUtilization: capacity as a percentage of your configured maximum, which shows whether the max is capping you.

Pull a week of hourly averages with aws cloudwatch get-metric-statistics. Use these parameters:

  • --namespace AWS/RDS
  • --metric-name ServerlessDatabaseCapacity
  • --dimensions set to your DBInstanceIdentifier
  • --period 3600
  • --statistics Average
  • start and end times seven days apart

The mean of those 168 hourly values is your time-weighted average ACU.

Weight by a representative week

A single day misses weekly batch jobs, Monday peaks and month-end reporting. A trial that runs only during business hours misses overnight maintenance. Short samples usually catch the quiet periods and miss the spikes. That understates average ACUs and makes serverless look cheaper than your invoice will be. Measure at least a full week, and include any known periodic heavy jobs.

#!/usr/bin/env bash
# Pull 7 days of hourly ServerlessDatabaseCapacity averages for one
# serverless v2 instance and compute the time-weighted mean ACU.
# Requires: AWS CLI v2, GNU date, jq.
set -euo pipefail

INSTANCE_ID="trial-sv2-instance-1"   # placeholder: your DBInstanceIdentifier
REGION="us-east-1"                   # placeholder region

# A full week, so weekly batch jobs and Monday peaks are included.
END=$(date -u +%Y-%m-%dT%H:00:00Z)
START=$(date -u -d "$END - 7 days" +%Y-%m-%dT%H:00:00Z)

aws cloudwatch get-metric-statistics \
  --region "$REGION" \
  --namespace AWS/RDS \
  --metric-name ServerlessDatabaseCapacity \
  --dimensions Name=DBInstanceIdentifier,Value="$INSTANCE_ID" \
  --start-time "$START" \
  --end-time "$END" \
  --period 3600 \
  --statistics Average \
  --output json > acu_week.json

# Each datapoint is one hour, so a plain mean is already time-weighted.
COUNT=$(jq '.Datapoints | length' acu_week.json)
MEAN=$(jq '[.Datapoints[].Average] | if length > 0 then add / length else 0 end' acu_week.json)
PEAK=$(jq '[.Datapoints[].Average] | max // 0' acu_week.json)

echo "Hourly datapoints: $COUNT (expect 168)"
echo "Time-weighted average ACU: $MEAN"
echo "Highest hourly average ACU: $PEAK"

# Missing hours (trial not running, gaps in replay) bias the mean.
if [ "$COUNT" -lt 168 ]; then
  echo "WARNING: incomplete week; average likely understates real ACU usage" >&2
fi

Fetches a week of hourly ServerlessDatabaseCapacity averages with aws cloudwatch get-metric-statistics, then computes the time-weighted mean ACU and warns when hours are missing.

Why does the minimum ACU setting dominate cost for low-traffic and dev/test clusters?

…batch jobs or month-end reporting that only run occasionally. Once you have a realistic average, look at the floor. For quiet clusters, the floor is usually most of the bill.

The minimum ACU is billed every hour the cluster is running, whether or not any queries arrive. A dev/test cluster that is busy eight hours a day pays for its floor around the clock.

Illustrative estimate (assumed numbers, not a benchmark). Assume a price of $0.12 per ACU-hour, 730 hours per month, a 2 ACU floor, and a peak of 4 ACU for 173 hours per month.

  • Floor cost = min ACU × hours × price = 2 × 730 × 0.12 = $175.20
  • Burst cost = (peak − min) × busy hours × price = 2 × 173 × 0.12 = $41.52

The floor is about 81% of the total. Lowering it to 0.5 ACU cuts the floor cost to $43.80.

A lower floor also means less memory. Because memory scales with ACUs, the buffer pool shrinks and hot pages are evicted. When traffic returns, queries read from storage instead of cache. Latency rises, I/O increases, and the cache takes time to warm up again.

MaxCapacity is both a cost limit and a hard performance ceiling. If you set it too low, production gets throttled at peak. If you set it too high, a runaway query or a retry storm can scale the cluster up and produce a large bill.

Scaling up is fast but not instantaneous, so a sharp spike from a low baseline can still add latency. Scaling down is gradual, so you keep paying elevated rates for a while after the spike ends. Set both values with MinCapacity and MaxCapacity in the cluster's serverless v2 scaling configuration.

#!/usr/bin/env bash
# Set the Aurora Serverless v2 capacity range for an existing cluster.
# The cluster's instances must use the db.serverless instance class.
set -euo pipefail

CLUSTER_ID="orders-dev-cluster"   # placeholder cluster identifier

# MinCapacity: billed every hour the cluster runs, even when idle.
#   A low floor suits dev/test. Expect a cold buffer pool when traffic returns.
# MaxCapacity: the cost guardrail and the hard performance ceiling.
#   Set it high enough for real peaks and low enough to cap a runaway query.
aws rds modify-db-cluster \
  --db-cluster-identifier "$CLUSTER_ID" \
  --serverless-v2-scaling-configuration MinCapacity=0.5,MaxCapacity=8 \
  --apply-immediately

# Confirm the range the cluster is now using.
aws rds describe-db-clusters \
  --db-cluster-identifier "$CLUSTER_ID" \
  --query 'DBClusters[0].ServerlessV2ScalingConfiguration'

# For a production cluster, raise the floor to keep the cache warm and
# absorb sudden spikes, for example MinCapacity=4,MaxCapacity=32.

This AWS CLI example sets and verifies the Aurora Serverless v2 MinCapacity floor and MaxCapacity ceiling on a cluster, with comments on the cost and performance trade-off of each value.

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

Avoid serverless v2 when load is steady and high. If a cluster sits near the same capacity around the clock, you pay a premium for elasticity you never use. Per unit of capacity, ACUs cost more than a right-sized provisioned instance, and reserved pricing applies only to provisioned instances, which widens the gap.

Serverless v2 also adds cost multipliers that are easy to miss:

  • Readers are billed separately. Each serverless reader accrues its own ACU-hours.
  • Failover-ready readers track the writer. Readers in the highest-priority promotion tiers scale with the writer so they can take over at full capacity. Three such readers can roughly quadruple the ACU bill.
  • Spend varies month to month. Budgets become harder to forecast. Set anomaly alerts on ACU usage so a runaway query or a retry storm shows up before the invoice does.

Feature support, tuning options and regional availability can differ from provisioned instances. Verify compatibility for your engine and region before you commit.

Alternatives

A mixed cluster is a middle path. Baseline load runs on a provisioned instance at steady-state rates, and spikes run on serverless v2 capacity at elastic rates. The usual layout is a provisioned writer with serverless readers:

        ┌──────────────────────┐
writes →│ Writer (provisioned) │
        └──────────┬───────────┘
          shared cluster storage
        ┌──────────┴───────────┐
reads  →│ Readers (serverless) │ ← scale with read spikes
        └──────────────────────┘

You can also reverse it: a serverless writer with provisioned readers suits bursty writes alongside steady reporting reads.

Option Cost profile Predictability Best-fit workload
Provisioned on-demand Fixed hourly, no commitment High Steady load, uncertain lifespan
Provisioned reserved Lowest steady-state rate, upfront commitment Highest Long-lived, high-utilization production
Mixed cluster Steady baseline plus elastic spikes Medium Stable writes, spiky reads (or the reverse)
Serverless v2 only Pay per ACU-hour, premium per unit Low Variable, idle-heavy or unpredictable load
┌─────────────────────────────────────────────────────────────────────────┐
│                               Application                               │
└──────────┬─────────────────────────┬─────────────────────────┬──────────┘
    writes │                         │ reads                   │ reads
           ▼                         ▼                         ▼
┌─────────────────────┐   ┌─────────────────────┐   ┌─────────────────────┐
│ Writer              │   │ Reader, tier 0-1    │   │ Reader, tier 2+     │
│ provisioned         │   │ serverless v2       │   │ serverless v2       │
│ baseline load       │   │ tracks writer size  │   │ scales with reads   │
│ steady-state rates  │   │ failover-ready      │   │ absorbs read spikes │
│ on-demand/reserved  │   │ own ACU-hours       │   │ own ACU-hours       │
└──────────┬──────────┘   └──────────┬──────────┘   └──────────┬──────────┘
           │                         │                         │
           ▼                         ▼                         ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                      Shared cluster storage volume                      │
└─────────────────────────────────────────────────────────────────────────┘

 Reverse layout: serverless v2 writer + provisioned readers
 (bursty writes alongside steady reporting reads).

A mixed Aurora cluster runs baseline writes on a provisioned instance at steady-state rates, while serverless v2 readers are each billed for their own ACU-hours: a tier 0-1 reader scales with the writer to stay failover-ready, and a tier 2+ reader scales only with read spikes.

How does serverless v2 affect engineering time and total development cost?

The compute bill shows only part of the cost. Provisioned clusters create recurring work that never appears on the invoice. Someone watches CPU and memory trends, plans an instance class change, schedules it, and accepts a failover or brief disruption while it runs. Teams also size instances for the busiest hour of the quarter, because resizing under pressure is risky. Serverless v2 scales capacity in place, so most of that work goes away. Dev/test clusters become simpler too: you set a low minimum and stop debating instance sizes for each environment.

Serverless v2 creates its own work. You need to tune the minimum ACU so the buffer pool and connection headroom hold up under real load. You need to set the maximum ACU as a cost ceiling that doesn't throttle legitimate peaks. Elastic capacity also needs guardrails, such as alerts on sustained high ACU usage and budget tracking per cluster, so a runaway query shows up before the invoice does. The break-even also moves as traffic grows, so re-check it on a schedule.

To price the trade, compare the two sides directly:

Illustrative estimate (assumed numbers, not a benchmark): net value = (hours saved per month − new tuning and monitoring hours per month) × loaded hourly cost. Add that result to the compute delta from earlier sections.

Decision checklist

  • Use serverless v2 when average ACU usage sits well below the break-even line, when load is idle-heavy or unpredictable, or when the team values less capacity planning.
  • Stay provisioned when average usage sits near or above the break-even line, load is steady, and the team already has reliable capacity management.
  • Go mixed when the writer is steady but readers spike, or the reverse. Put the steady role on provisioned instances and the variable role on serverless v2.

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 cost vs provisioned, 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.