How do Aurora Serverless v2 and provisioned instances bill differently?

Backend and platform teams usually reach this question after watching a provisioned Aurora writer sit at low CPU for most of the day, then saturate during a nightly batch, a marketing push, or a burst of webhook retries. A provisioned instance must be sized for the peak, so you pay for peak capacity around the clock. Serverless v2 is attractive because it lets you pay for the capacity the database actually uses.

Who should use Aurora Serverless v2?

Serverless v2 fits teams whose database load has long quiet periods and short or irregular peaks. Common cases include:

  • Spiky production workloads. Nightly batches, campaign-driven traffic, or webhook bursts where the peak is several times the baseline and lasts only a few hours a day.
  • Workloads with unknown load. New services where you cannot yet size an instance with confidence. Serverless v2 lets you run first and size later from real metrics.
  • Read-heavy spikes on an existing cluster. Teams that want to keep a provisioned writer and add Serverless v2 readers to absorb read bursts.
  • Development, test and staging environments. These sit idle outside working hours but still need production-like behavior when in use.
  • Platform teams running many small clusters. For example, per-tenant or per-team databases, where sizing each one by hand is impractical.

It is a poor fit for steady, consistently busy load and for teams with fixed budgets or commitment discounts on provisioned capacity. The section on when to avoid Serverless v2 covers these cases.

How does Aurora Serverless v2 work?

Serverless v2 is an instance class (db.serverless) inside a normal Aurora cluster, not a separate service. It uses the same distributed storage layer, the same cluster and reader endpoints, and the same replication as provisioned instances. A cluster can contain only Serverless v2 instances, only provisioned instances, or a mix of the two.

The database engine runs continuously. Aurora changes the CPU and memory allocated to each Serverless v2 instance in place while it runs. The change happens in fine-grained increments and does not require a failover or a restart, so connections stay open while capacity changes. Aurora bases scaling decisions on CPU, memory and network demand. As capacity grows or shrinks, the memory available to the engine, including the buffer cache, changes with it.

You set a minimum and maximum ACU range for the cluster. Each Serverless v2 instance scales independently within that range, so a reader can scale up for a read spike while the writer stays small. Readers in the highest failover promotion tiers are an exception: they track the writer's capacity so that they are ready to take over after a failover. Check current documentation for the exact tier behavior on your engine version.

Aurora meters the capacity allocated to each instance over time, and that is what you are billed for. The rest of this article follows from this point. You pay for allocated capacity, which is not the same as the capacity your queries need.

The two billing units

A provisioned instance bills per instance-hour for a fixed class such as db.r6g.xlarge. The price depends only on the class and how long the instance runs, so it is the same at 3% CPU or 95% CPU.

Serverless v2 bills per ACU-hour. An Aurora Capacity Unit is roughly 2 GiB of memory with proportional CPU and networking. Capacity moves in fine-grained increments between a minimum and maximum ACU that you configure. Billing tracks the capacity that is allocated at each moment, which is not always the capacity the workload needs. Section 3 explains why that difference matters.

Aspect Provisioned Serverless v2
Billing unit Instance-hour ACU-hour
Capacity Fixed by instance class Varies between min and max ACU
Cost at idle Full instance rate Minimum ACU rate
Cost at peak Same as idle Up to max ACU rate
Resize Manual class change Automatic

What this comparison leaves out

Storage, I/O, backups and data transfer are billed separately from compute. They are largely the same under either compute model, so this analysis excludes them. The exception is a comparison where the clusters use different storage configurations. In that case, compare the storage line separately.

How do you calculate the break-even point for Serverless v2?

Pull two numbers from the current AWS pricing page for your region and engine: the on-demand hourly price of the instance class you would provision for peak, and the Serverless v2 price per ACU-hour. Then convert the instance to ACUs by memory. One ACU corresponds to roughly 2 GiB of RAM, so a 32 GiB instance is about 16 ACUs.

The break-even ratio is:

ratio = provisioned hourly price / (memory-equivalent ACUs × ACU-hour price)

Serverless v2 is cheaper only when average consumed ACUs / peak ACUs is below that ratio. The ratio is usually well under 1 because an ACU-hour costs more than the same capacity bought as an instance. You are paying a premium for elasticity, and that premium only pays off if you spend enough hours scaled down.

Illustrative estimate (placeholder prices, not real AWS rates)

Assume a 16-ACU-equivalent instance at $1.00/h and an ACU-hour at $0.12.

  • Ratio = 1.00 / (16 × 0.12) ≈ 0.52.
  • The workload runs at 2 ACUs for 20 h and at 16 ACUs for 4 h. That is 104 ACU-hours per day, compared with 384 for an instance sized to peak.
  • Utilization = 104 / 384 ≈ 0.27. This is below 0.52, so Serverless v2 wins.

The table shows how the result changes as the daily burst gets longer:

Burst hours at 16 ACUs ACU-hours/day Utilization Serverless $/day Provisioned $/day
4 104 0.27 12.48 24.00
8 160 0.42 19.20 24.00
11 202 0.53 24.24 24.00
16 272 0.71 32.64 24.00

With these placeholder prices, the result flips at about 11 burst hours per day.

Spreadsheet version

To rerun this with your own inputs, set up the following cells:

  • B1: instance price per hour
  • B2: memory-equivalent ACUs
  • B3: ACU-hour price
  • B4: baseline ACUs
  • B5: burst hours per day

Then add three formulas:

  • Ratio: =B1/(B2*B3)
  • Utilization: =(B4*(24-B5)+B2*B5)/(24*B2)
  • Serverless v2 is cheaper when utilization is less than the ratio.
INSTANCE_PRICE_PER_HOUR = 1.00   # provisioned instance sized for peak ($/h)
MEMORY_EQUIV_ACUS = 16           # instance RAM in GiB / 2 (about 2 GiB per ACU)
ACU_HOUR_PRICE = 0.12            # Serverless v2 price per ACU-hour ($)
BASELINE_ACUS = 2                # ACUs consumed outside the burst
PEAK_ACUS = 16                   # ACUs consumed during the burst

ratio = INSTANCE_PRICE_PER_HOUR / (MEMORY_EQUIV_ACUS * ACU_HOUR_PRICE)
provisioned_per_day = INSTANCE_PRICE_PER_HOUR * 24
print(f"break-even ratio: {ratio:.2f}")

print("burst_h  acu_h/day  util   serverless$  provisioned$  winner")
for burst_h in (4, 8, 11, 16):
    acu_hours = BASELINE_ACUS * (24 - burst_h) + PEAK_ACUS * burst_h
    util = acu_hours / (MEMORY_EQUIV_ACUS * 24)
    serverless_per_day = acu_hours * ACU_HOUR_PRICE
    winner = "serverless" if serverless_per_day < provisioned_per_day else "provisioned"
    print(f"{burst_h:>7}  {acu_hours:>9}  {util:.2f}  {serverless_per_day:>11.2f}"
          f"  {provisioned_per_day:>12.2f}  {winner}")

break_even_h = (provisioned_per_day / ACU_HOUR_PRICE - BASELINE_ACUS * 24) / (
    PEAK_ACUS - BASELINE_ACUS)
print(f"costs are equal at about {break_even_h:.1f} burst hours/day")

A rerunnable Python script that computes the break-even ratio, reproduces the illustrative table with placeholder prices, and solves for the burst length where Serverless v2 stops being cheaper (about 10.9 hours/day with these inputs).

Why does the scaling curve, not the request curve, drive your bill?

The formula assumes capacity tracks load exactly. It doesn't. Serverless v2 adjusts in fine-grained ACU increments and usually scales up faster than it scales down. It releases capacity cautiously so it doesn't thrash or evict a warm buffer cache. Each spike therefore leaves a decay tail, and you pay for that tail even though no requests are arriving.

load / ACUs
  ^
  |      ┌──┐            ── request curve
  |      │  │░░          ░░ ACUs billed after load drops
  |      │  │  ░░░
  |      │  │     ░░░░
  |  ────┘  └─────────░░░░░─────
  +------------------------------> time
         spike   decay tail

On a workload with frequent short spikes, the tails can overlap. Capacity then never returns to baseline, and the effective "baseline ACUs" in your spreadsheet ends up much higher than your quiet-period load suggests.

CPU is not the only scaling signal. Memory pressure and connection count also drive capacity. The ceiling on max_connections is derived from your capacity settings, so the database has to hold enough capacity to support the connections it accepts. A connection storm from autoscaled app pods, or a few queries running large sorts and hash joins, can push ACUs up while query volume stays modest. A connection pooler or proxy in front of the cluster can flatten that signal and noticeably change the cost picture.

Step-function load works against you in a different way. A cron job that fans out hundreds of workers at the top of the hour can arrive before capacity catches up. You get latency during the ramp, and then you pay for the tail afterward.

+------------------+   +------------------+
| App pods         |   | Cron fan-out     |
| (autoscaled)     |   | (top of hour)    |
+--------+---------+   +--------+---------+
         |  many conns          | step spike
         v                      v
+-----------------------------------------+
| Connection pooler / proxy (optional)    |
| many client conns -> few server conns   |
+--------------------+--------------------+
                     | pooled conns
                     v
+-----------------------------------------+
| Aurora Serverless v2 instance           |
| scaling signals: CPU, memory, conns     |
| memory: buffer cache, sorts, hash joins |
| max_connections derived from capacity   |
+--------------------+--------------------+
                     | fine-grained ACU increments
         +-----------+----------+
         v                      v
+------------------+   +------------------+
| Scale up: faster |   | Scale down: slow |
| lags step spikes |   | leaves decay tail|
+--------+---------+   +--------+---------+
         +-----------+----------+
                     v
+-----------------------------------------+
| Billed ACU-hours: spikes plus tails     |
+-----------------------------------------+

Connection storms and cron fan-outs reach Aurora Serverless v2 through an optional pooler, where CPU, memory and connection signals drive capacity up quickly and down slowly, so billed ACU-hours include each spike's decay tail.

How do you measure your workload before choosing a billing model?

Run the measurement on a cluster that carries real traffic. The best option is a Serverless v2 reader added to an existing cluster, or a clone that receives replayed production traffic. Two metrics in the AWS/RDS namespace, keyed by DBInstanceIdentifier, tell you most of what you need. ServerlessDatabaseCapacity shows how many ACUs you are paying for at each moment. ACUUtilization shows how close that capacity is to your configured maximum. If utilization sits near 100% during peaks, the maximum is capping you, and the cost estimate will be too low.

On provisioned instances that have never run Serverless v2, use CPUUtilization and FreeableMemory history as a proxy. One ACU corresponds to roughly 2 GiB of memory, so you can estimate the equivalent ACU count from memory in use. This is a loose estimate. Aurora reserves most instance memory for the buffer cache, so FreeableMemory changes very little with load. Treat CPU as the more honest signal of demand, and validate the estimate with a short trial before you commit.

Pull get-metric-statistics with --period 3600 and both Average and Maximum statistics. Cover at least 30 days so that weekly cycles and a month-end close are included. Hourly data is retained long enough for this. Minute-level data expires after about two weeks.

Each hourly average equals ACU-hours for that hour, so the sum of the averages is your billed capacity. Illustrative estimate: 720 hourly averages sum to 4,320 ACU-hours, which is a mean of 6 ACU, while the hourly maximum peaks at 32 ACU. Compare 4,320 × your ACU price with 720 hours of an instance sized for 32 ACU, which is about 64 GiB. The comparison usually settles the decision, and it does so before anyone spends time on a migration.

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

INSTANCE_ID="my-cluster-sv2-reader-1"   # placeholder DBInstanceIdentifier
REGION="us-east-1"
START=$(date -u -d '30 days ago' +%Y-%m-%dT%H:%M:%SZ)   # GNU date
END=$(date -u +%Y-%m-%dT%H:%M:%SZ)

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 Maximum \
  --output json > capacity.json

jq -r '
  .Datapoints as $d
  | ($d | map(.Average) | add) as $acu_hours
  | {
      hours:        ($d | length),
      acu_hours:    $acu_hours,
      mean_acu:     ($acu_hours / ($d | length)),
      peak_acu:     ($d | map(.Maximum) | max),
      peak_mem_gib: (($d | map(.Maximum) | max) * 2)
    }
' capacity.json

Fetches 30 days of hourly ServerlessDatabaseCapacity with get-metric-statistics and uses jq to compute total ACU-hours, mean ACU, and peak ACU for comparison against a provisioned instance sized for the peak.

How should you set minimum and maximum ACUs?

The minimum ACU drives your idle cost more than any other setting, and it also carries the most risk. Each ACU comes with roughly 2 GiB of memory, and Aurora sizes the buffer pool from the capacity currently allocated. A floor of 0.5 or 1 ACU looks cheap overnight, but it leaves only a small cache. When traffic returns, the first wave of queries reads from storage instead of memory. Latency rises at exactly the moment you need headroom.

A low floor also slows the start of a spike. Scaling increments are proportional to current capacity, so a database idling at 1 ACU takes longer to reach 16 ACU than one idling at 4. Set the floor high enough to hold your hot working set, which you can estimate from cache hit ratio and buffer pool usage at quiet times. The allowed minimum has changed over time, and so has support for auto-pause or scale-to-zero. Check current documentation for your engine and version rather than assuming either one.

The maximum is your blast-radius control. If you set it too high, a runaway query, a client retry storm or a bad deploy with an N+1 pattern will scale capacity up, and you will pay for it. If you set it too low, the database pins at the ceiling, and you see queueing and timeouts that look like throttling.

Alarm on both limits:

  • Capacity sitting at the floor while latency rises.
  • Capacity reaching the ceiling at all.

Raising the floor before known events, such as launches or batch windows, is reasonable. Each hour spent at the higher floor gives back part of the savings that justified Serverless v2, so include those hours in the break-even calculation.

How can Aurora Serverless v2 save engineering time?

The compute bill is only part of the cost. With provisioned capacity, engineers also spend time keeping instance sizes aligned with load. Serverless v2 removes some of that work:

  • No resize operations. Changing a provisioned instance class means planning a change, usually failing over or restarting, and checking the result afterward. Serverless v2 changes capacity in place within the configured range, so routine growth and seasonal peaks do not need a change ticket or a maintenance window.
  • Less capacity forecasting. Teams do not need to predict next quarter's peak precisely. They choose a min/max range, alarm on the limits, and review the range when an alarm fires.
  • No custom scaling automation. Scheduled scaling scripts, replica add/remove jobs and the runbooks behind them are no longer needed for the instances that run Serverless v2.
  • Simpler non-production environments. Dev, test and staging clusters can stay small while idle and scale up when someone uses them, without a person or a scheduler resizing them.
  • Fewer capacity incidents. Load that exceeds a fixed instance size causes pages and urgent resizes. Load within the max ACU range is absorbed automatically.

Illustrative estimate: assume a team resizes its provisioned clusters 4 times per quarter, and assume each resize takes 3 engineer-hours for planning, the change window and verification. That is 12 engineer-hours per quarter that Serverless v2 could remove. Replace the assumed inputs with your own change history.

Serverless v2 also adds work. Someone has to choose and revisit the min/max range, maintain the floor and ceiling alarms, and run the measurement from the earlier sections. Include that time in the comparison. Serverless v2 saves the most engineering time when a team manages many clusters with irregular load, because resizing work grows with the number of clusters while the work of setting a range and alarms is largely a one-time setup.

When should you avoid Aurora Serverless v2?

Serverless v2 is cheaper only when capacity would otherwise sit idle for long stretches. If your cluster runs near its peak most hours, you pay a higher per-unit rate for capacity you would have used anyway. A provisioned instance sized for that load costs less, because its flat hourly price buys the same memory and CPU at a lower effective rate.

Situation Why provisioned tends to win
Steady or mostly busy load Utilization is high, so the per-ACU premium applies to nearly every hour
Fixed monthly budget Instance cost is flat; serverless cost follows scaling and changes month to month
Commitment discounts available A discount lowers the instance price and raises the idle share serverless needs to break even
Well-tuned existing fleet Migration and retesting cost can exceed the expected savings

Commitment discounts can change the result by a large margin. A reserved commitment lowers the provisioned side of the break-even ratio, so Serverless v2 has to spend a much larger share of hours scaled down to come out ahead. Discount eligibility changes over time and may differ between Serverless v2 and provisioned capacity. Check which programs currently apply to each before you compare on-demand prices, because a comparison of two on-demand prices can point you to the wrong choice.

Predictability also has value. A traffic surge or a runaway query raises a serverless bill without warning. A maximum ACU cap limits the cost, but it does so by limiting performance.

Switching has its own costs: engineering time, load tests, failover drills and parameter reviews. Scaling behavior and feature support vary by engine and version, so test on the exact configuration you plan to run.

What are the alternatives to switching fully to Serverless v2?

Mixed clusters are often a better middle ground than a full switch. Aurora lets a provisioned writer and Serverless v2 readers share one cluster. The writer handles the steady baseline and can be covered by commitment pricing such as reserved instances, because its usage is predictable. Serverless readers absorb read spikes, and you pay for ACUs only while they scale up. The catch is failover. If a serverless reader at low capacity is promoted, it starts as an undersized writer and must scale up under full write load. Give failover-tier readers a minimum ACU close to the writer's normal footprint, and keep low minimums for readers that only serve spikes. Check how promotion tiers affect reader scaling on your engine version.

You can also right-size provisioned capacity without serverless:

  • Scheduled scaling: Add or remove read replicas on a schedule for predictable peaks. Changing the instance class of an existing instance involves a restart or failover, so adding and removing replicas is usually less disruptive.
  • Smaller writer plus read replicas: If reads drive the peaks, a smaller writer with replicas behind the reader endpoint is often cheaper than one oversized writer.
  • Burstable classes for dev/test: These suit idle-heavy environments. CPU credit exhaustion makes them a poor choice for production.
Option Cost predictability Savings potential Engineering effort
Mixed cluster Medium Medium–high Medium (failover tuning)
Scheduled replicas High Medium Low–medium
Smaller writer + replicas High Medium Medium (read routing)
Burstable dev/test High High for idle environments Low
Full Serverless v2 Low Highest for very spiky load High

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