---
title: Amazon Aurora Pricing: The I/O-Optimized Crossover and the Serverless v2 ACU Trap
description: Aurora bills instance hours plus storage plus I/O — or storage at a 125% premium with I/O bundled (I/O-Optimized). Serverless v2 at $0.12 per ACU-hour wins on variable workloads, loses on steady traffic above 4 ACU. Global Database doubles the price per secondary region plus replicated-write fees. Backtrack adds per-change-record cost most teams never factor in.
url: https://www.factualminds.com/blog/amazon-aurora-pricing-io-optimized-serverless-v2-global/
datePublished: 2026-06-13T00:00:00.000Z
dateModified: 2026-06-13T00:00:00.000Z
author: palaniappan-p
category: Cost Optimization & FinOps
tags: amazon-aurora, aurora-pricing, aws-pricing, cost-optimization, finops, database
---

# Amazon Aurora Pricing: The I/O-Optimized Crossover and the Serverless v2 ACU Trap

> Aurora bills instance hours plus storage plus I/O — or storage at a 125% premium with I/O bundled (I/O-Optimized). Serverless v2 at $0.12 per ACU-hour wins on variable workloads, loses on steady traffic above 4 ACU. Global Database doubles the price per secondary region plus replicated-write fees. Backtrack adds per-change-record cost most teams never factor in.

import PricingHeroStats from '~/components/blog/PricingHeroStats.astro';
import PricingDimensionTable from '~/components/blog/PricingDimensionTable.astro';
import BillSurpriseCallout from '~/components/blog/BillSurpriseCallout.astro';
import PricingDecisionCard from '~/components/blog/PricingDecisionCard.astro';

Amazon Aurora is AWS's flagship cloud-native relational database, available in MySQL and PostgreSQL flavors with several deployment shapes (provisioned, Serverless v2, Global Database, Limitless, DSQL). The pricing reflects that breadth — instance hours, two storage models, optional features each with their own line items, and replication multipliers for multi-region. The right shape for a workload depends on traffic pattern, I/O intensity, and consistency requirements; the wrong shape can land the bill 2–5× higher than necessary.

<PricingHeroStats
  stats={[
    { value: '$0.29', label: 'db.r6g.large / hour', note: 'Provisioned baseline; RDS premium' },
    { value: '$0.12', label: 'Serverless v2 / ACU-hour', note: 'Crossover with provisioned at ~4 ACU sustained' },
    { value: '125%', label: 'I/O-Optimized storage premium', note: 'In exchange for no per-I/O charge' },
    { value: '2–3×', label: 'Global Database / region', note: 'Each replica region is a full cluster' },
  ]}
  caption="us-east-1 list prices, June 2026. Verify against the AWS Aurora pricing page for your region."
/>

This post is the bill story. For the broader Aurora-vs-RDS architectural decision, the [Aurora Serverless v2 vs provisioned comparison](/compare/aws-aurora-serverless-vs-aurora-provisioned/) covers the choice within Aurora; the [RDS vs Aurora comparison](/compare/aws-rds-vs-aurora-when-to-use-which-database/) covers when Aurora is the right primitive vs standard RDS.

## The Eight Aurora Billing Dimensions

<PricingDimensionTable
  title="Aurora pricing breakdown — us-east-1, June 2026"
  intro="Instance + storage + I/O is the standard model. Serverless v2 collapses these into per-ACU billing; Global Database compounds per region."
  region="us-east-1"
  dimensions={[
    {
      name: 'db.r6g.large (provisioned)',
      unitPrice: '$0.29 / hour',
      example: '1 instance × 730 hours',
      monthly: '$212',
      note: '20% premium over standard RDS rate',
      highlight: true,
    },
    {
      name: 'db.r6g.xlarge (provisioned)',
      unitPrice: '$0.58 / hour',
      example: '1 instance × 730 hours',
      monthly: '$423',
      note: 'Doubles per tier',
    },
    {
      name: 'Serverless v2',
      unitPrice: '$0.12 / ACU-hour',
      example: '2 ACU sustained',
      monthly: '$175',
      note: 'Scales by 0.5 ACU increments',
      highlight: true,
    },
    {
      name: 'Standard storage',
      unitPrice: '$0.10 / GB-month + $0.20 / M I/O',
      example: '500 GB + 50M I/O / mo',
      monthly: '$50 + $10 = $60',
      note: 'Cheaper for low-I/O workloads',
    },
    {
      name: 'I/O-Optimized storage',
      unitPrice: '$0.225 / GB-month, no I/O charge',
      example: '500 GB',
      monthly: '$112.50',
      note: 'Break-even at ~25% I/O share of bill',
      highlight: true,
    },
    {
      name: 'Backup storage (above db size)',
      unitPrice: '$0.021 / GB-month',
      example: '500 GB backup beyond db size',
      monthly: '$10.50',
      note: 'Free up to size of source database',
    },
    {
      name: 'Backtrack (Aurora MySQL)',
      unitPrice: '$0.012 / M change records',
      example: '100M change records / month',
      monthly: '$1.20',
      note: 'Per change-record stored',
    },
    {
      name: 'Aurora Global Database',
      unitPrice: 'Each region: full cluster + $0.20/M replicated writes',
      example: '2-region setup',
      monthly: '2× cluster cost + transfer',
      note: 'Cross-region transfer $0.02/GB',
      highlight: true,
    },
    {
      name: 'Data API',
      unitPrice: 'Free',
      example: 'HTTP query interface',
      monthly: '$0',
      note: 'Useful for Lambda integration',
    },
    {
      name: 'Aurora Limitless (routing + shards)',
      unitPrice: 'ACU-based',
      example: 'Sharded Aurora PostgreSQL',
      monthly: 'Varies with shard count',
      note: 'For workloads beyond single-cluster scale',
    },
  ]}
  footnote="Reserved Instance discounts apply to provisioned Aurora instances (40–75% off the on-demand rate depending on term). Serverless v2 has no RI mechanism."
/>

## I/O-Optimized vs Standard: The 25% Crossover

Standard Aurora storage bills $0.10/GB-month plus $0.20 per million I/O operations. I/O-Optimized bills $0.225/GB-month with no per-I/O charge — a 125% premium on storage in exchange for unlimited I/O.

The crossover: when I/O costs exceed roughly 25% of your Aurora bill, I/O-Optimized is cheaper.

<PricingDimensionTable
  title="Standard vs I/O-Optimized — 500 GB database, three I/O profiles"
  intro="Same data volume, different I/O rates. The decision is per-cluster, not per-application."
  region="us-east-1"
  dimensions={[
    {
      name: 'Standard, 10M I/O / mo',
      unitPrice: '$50 storage + $2 I/O',
      example: 'Read-mostly low-volume',
      monthly: '$52',
      note: 'Standard wins for low-I/O',
    },
    {
      name: 'I/O-Optimized, same workload',
      unitPrice: '$112.50 flat',
      example: 'Low-I/O workload',
      monthly: '$112.50',
      note: '2× more expensive at low I/O',
      highlight: false,
    },
    {
      name: 'Standard, 500M I/O / mo',
      unitPrice: '$50 storage + $100 I/O',
      example: 'Moderate OLTP',
      monthly: '$150',
      note: 'I/O catching up to storage',
    },
    {
      name: 'I/O-Optimized, same workload',
      unitPrice: '$112.50 flat',
      example: 'Moderate OLTP',
      monthly: '$112.50',
      note: 'I/O-Optimized wins',
      highlight: true,
    },
    {
      name: 'Standard, 2B I/O / mo',
      unitPrice: '$50 storage + $400 I/O',
      example: 'High-throughput OLTP',
      monthly: '$450',
      note: 'I/O dominates',
    },
    {
      name: 'I/O-Optimized, same workload',
      unitPrice: '$112.50 flat',
      example: 'High-throughput OLTP',
      monthly: '$112.50',
      note: '75% cheaper',
      highlight: true,
    },
  ]}
  footnote="The crossover is at roughly 300M I/O / month for a 500 GB database. Beyond that, I/O-Optimized is unconditionally cheaper."
/>

The audit pattern: check CloudWatch `VolumeReadIOPs` and `VolumeWriteIOPs` for your Aurora clusters over the last month, sum to get monthly I/O, multiply by $0.20/M to get the Standard-tier I/O bill, compare against the premium of I/O-Optimized. The decision is per-cluster.

<BillSurpriseCallout
  variant="optimization"
  title="Migrate high-I/O Aurora clusters to I/O-Optimized"
  amount="30–60% saving on the storage + I/O line"
>
  For OLTP workloads with substantial I/O, the I/O-Optimized migration is non-controversial — the cluster operates
  identically, the bill drops. The migration is a one-time storage configuration change (requires brief downtime for the
  storage class swap). For databases approaching the crossover threshold, the change pays for itself in a few months and
  the saving compounds indefinitely.
</BillSurpriseCallout>

## Serverless v2 vs Provisioned: The 4-ACU Break-Even

Serverless v2 bills $0.12 per ACU-hour where 1 ACU represents approximately 2 GB of memory and corresponding CPU/network. The pricing scales linearly: 2 ACU = $0.24/hour, 4 ACU = $0.48/hour, 16 ACU = $1.92/hour.

The break-even with provisioned db.r6g.large at $0.29/hour: roughly 2.4 ACU. Above that, Serverless v2 costs more per hour than provisioned for equivalent capacity.

<PricingDimensionTable
  title="Serverless v2 vs provisioned — usage scenarios"
  intro="Serverless v2 wins on variable workloads; provisioned wins on steady traffic above the break-even capacity."
  region="us-east-1"
  dimensions={[
    {
      name: 'Dev / test, scales to 0 nights/weekends',
      unitPrice: 'Serverless v2 avg 0.5 ACU',
      example: '40% of hours active',
      monthly: '~$26',
      note: 'Scaling to zero is the killer feature',
      highlight: true,
    },
    {
      name: 'Variable production, avg 2 ACU peak 8 ACU',
      unitPrice: 'Serverless v2 avg ~3 ACU',
      example: 'Variable web app load',
      monthly: '~$263',
      note: 'Cheaper than always-on db.r6g.xlarge',
    },
    {
      name: 'Steady production, sustained 4 ACU',
      unitPrice: 'Serverless v2',
      example: '4 ACU × 730h',
      monthly: '$350',
      note: 'Approaching break-even',
    },
    {
      name: 'Same workload on provisioned',
      unitPrice: 'db.r6g.large',
      example: 'Always-on',
      monthly: '$212',
      note: '40% cheaper for steady traffic',
      highlight: true,
    },
    {
      name: 'Steady production, sustained 8 ACU',
      unitPrice: 'Serverless v2',
      example: '8 ACU × 730h',
      monthly: '$700',
      note: 'Significantly more than provisioned',
    },
    {
      name: 'Same workload on provisioned',
      unitPrice: 'db.r6g.xlarge',
      example: 'Always-on',
      monthly: '$423',
      note: '40% cheaper for sustained 8 ACU',
    },
  ]}
  footnote="Scaling to zero on Serverless v2 (supported for dev environments) eliminates the cost when idle — the killer feature for non-production workloads."
/>

## Global Database: Each Region Is Full Cost

Aurora Global Database replicates a primary cluster to secondary regions with sub-second replication lag. Each secondary region runs its own Aurora cluster — full instance cost, full storage cost. The primary also pays for replicated writes ($0.20 per million writes replicated) and the inter-region data transfer ($0.02/GB).

A 2-region Global Database with db.r6g.xlarge instances effectively doubles the database tier cost — from $423/month to $850+/month for the instances alone. A 3-region setup roughly triples it.

The right use cases:

- **Active-active multi-region writes**: applications where users in different regions write locally and replicate globally. (For pure active-active write workloads, evaluate Aurora DSQL which is the newer primitive.)
- **Sub-second cross-region read locality**: serving users in multiple regions with local-latency reads.
- **Low-RPO disaster recovery**: cross-region failover with under-1-minute RPO.

The wrong use case: standard DR with relaxed RPO. A single-region cluster with cross-region automated snapshots achieves multi-hour RPO at dramatically lower cost.

## Backtrack: The Quiet Per-Change-Record Line

Aurora Backtrack (MySQL only) lets you rewind the cluster to a point within the configured retention window (1–72 hours) without restoring from a backup. The cost: $0.012 per million change records stored.

For low-write databases, this is essentially free. For high-write OLTP databases generating hundreds of millions of change records per day, the line item becomes material — a database with 500M change records/day at 72-hour retention bills ~$13/day, ~$390/month for Backtrack alone.

The mitigations:

- **Match retention to operational need.** 24-hour retention covers "rewind that bad deploy from this morning"; 72-hour retention is rarely operationally useful.
- **Evaluate vs PITR.** Point-in-Time Recovery from automated backups is free but slower (full restore from snapshot + log replay). For low-frequency rewind use cases, PITR may suffice.

## When to Use Each Aurora Shape

<PricingDecisionCard
  headline="Provisioned for steady production; Serverless v2 for variable / dev; Global Database for multi-region requirements; Limitless for beyond-single-cluster scale."
  useWhen={[
    'Provisioned Aurora: steady production traffic above ~4 ACU equivalent; predictable load',
    'Provisioned + Reserved Instances: predictable production for 1+ year of usage — substantial discount',
    'Serverless v2: variable production traffic with high peak-to-average ratio; dev/test with scale-to-zero',
    'I/O-Optimized storage: workloads with sustained I/O above ~25% of the bill',
    'Global Database: multi-region active-active writes, sub-second cross-region read locality, low-RPO DR',
    'Aurora Limitless: workloads that exceed single-cluster scale and need automatic sharding',
    'Aurora DSQL: serverless distributed SQL with multi-region active-active for greenfield workloads',
  ]}
  avoidWhen={[
    'Serverless v2 for steady high-utilization workloads — provisioned is cheaper',
    'Standard storage on high-I/O workloads — I/O-Optimized saves money',
    'Global Database for pure read replication — DAX, app-side cache, or read replica is cheaper',
    'Backtrack on high-write databases without retention discipline — silent line item',
    'Aurora when standard RDS would suffice — Aurora carries a ~20% instance premium',
  ]}
  footnote="Aurora is rarely the wrong primitive at the architecture level. The bill problems come from storage class selection, deployment shape, and multi-region overcommit."
/>

## A 30-Day Aurora Bill Cleanup Plan

**Week 1 — I/O-Optimized evaluation.** For each Aurora cluster, calculate the actual I/O volume (CloudWatch `VolumeReadIOPs` + `VolumeWriteIOPs` × 30 days). Compare the Standard vs I/O-Optimized cost. Migrate clusters where I/O-Optimized saves money.

**Week 2 — Serverless v2 fit audit.** Identify clusters on Serverless v2 with sustained ACU consumption above the break-even. Migrate to provisioned. Identify clusters on provisioned with low average utilization — evaluate migration to Serverless v2.

**Week 3 — Global Database scope.** Review Global Database setups against actual cross-region usage. Where the secondary region is purely DR with relaxed RPO, evaluate replacement with cross-region snapshots.

**Week 4 — Backtrack and dev-environment scale-to-zero.** Audit Backtrack retention on high-write databases. Configure scale-to-zero on Serverless v2 dev environments to eliminate idle-time cost.

## What This Post Doesn't Cover

- **Aurora DSQL** pricing in depth — newer serverless distributed SQL primitive with its own pricing model; covered in our database modernization content.
- **Aurora performance tuning** — relevant to bill (reducing I/O reduces Standard tier cost) but covered in our database operations content.
- **Migration from RDS to Aurora** — operational migration patterns covered in database migration content.
- **Aurora compatibility-mode specifics** (MySQL vs PostgreSQL feature differences affecting cost) — covered separately.

## If You Only Do One Thing This Week

Calculate I/O volume for your largest Aurora cluster and decide whether I/O-Optimized would be cheaper. Run a CloudWatch query: sum `VolumeReadIOPs` + `VolumeWriteIOPs` over 30 days, multiply by $0.20/M. If the result exceeds 25% of your current Aurora bill for that cluster, migrate to I/O-Optimized. The migration is a one-time storage configuration change; the bill drops on day one and the saving compounds indefinitely.

For the broader RDS-vs-Aurora architectural decision, the [RDS vs Aurora comparison](/compare/aws-rds-vs-aurora-when-to-use-which-database/) covers when Aurora's premium is worth it.

## FAQ

### When does I/O-Optimized Aurora pay off vs Standard?
The crossover is when I/O costs exceed roughly 25% of your Aurora bill. Standard at $0.10/GB-month storage plus $0.20 per million I/O operations is cheaper for low-I/O workloads. I/O-Optimized at $0.225/GB-month storage with no per-I/O charge is cheaper once I/O becomes a substantial line item. For OLTP workloads with heavy read/write patterns (typical SaaS application databases), I/O-Optimized usually wins. For low-volume databases, Standard remains cheaper. Run the calculation against actual VolumeBytesUsed and VolumeReadIOPs / VolumeWriteIOPs CloudWatch metrics before committing.

### When does Aurora Serverless v2 beat provisioned?
Serverless v2 at $0.12 per ACU-hour wins on variable workloads where average utilization is well below peak. The break-even with a provisioned db.r6g.large (roughly 4 ACU-equivalent at $0.29/hour) is about 2.4 ACU-hours of average usage; below that, Serverless v2 is cheaper. Above ~4 ACU sustained, provisioned db.r6g.large is cheaper because the ACU rate compounds linearly while provisioned bills the same hourly rate regardless of utilization. The right pattern: Serverless v2 for dev/test, intermittent workloads, and applications with high peak-to-average ratios; provisioned for steady production above db.r6g.large equivalent capacity.

### How much does Aurora Global Database actually cost?
Each Global Database region runs its own Aurora cluster with full instance and storage costs. A primary region with one db.r6g.xlarge replica region adds roughly the full instance cost ($420/month per db.r6g.xlarge) plus the replica storage cost plus $0.20 per million replicated writes plus inter-region data transfer. A 2-region Global Database approximately doubles the database tier cost; a 3-region setup roughly triples it. Use Global Database when you need cross-region read locality (sub-second secondary reads) or active-active writes (Aurora DSQL is the newer primitive for active-active). For pure DR with relaxed RPO, a single-region cluster with cross-region snapshots is dramatically cheaper.

### What is the cost of enabling Backtrack on Aurora MySQL?
Backtrack bills $0.012 per million change records stored, with a 24-hour to 72-hour retention configurable per cluster. The actual bill depends on the database's write rate — a high-write OLTP database can generate hundreds of millions of change records per day, translating to a real monthly line item. Backtrack is genuinely useful for 'rewind the database 5 minutes to before that bad deploy' scenarios, but it is not free. For low-write-rate databases, Backtrack is essentially free; for high-write databases, evaluate whether traditional point-in-time recovery (free, but slower restore) would meet the operational need.

### Is Aurora Serverless v2 with min ACU 0 actually serverless?
Aurora Serverless v2 supports auto-pause to zero ACUs with the introduction of "scaling to zero" capability — useful for dev / test environments that should not bill when idle. The trade-off: scaling from zero to actively serving a request introduces cold-start latency (seconds to tens of seconds depending on configuration). For production workloads, configure a minimum ACU greater than zero (typically 0.5 or 1) to keep the cluster warm. For dev environments, min ACU 0 is the right setting and can dramatically reduce non-production database spend.

### How do Aurora Reserved Instances compare to standard RDS RIs?
Aurora Reserved Instances follow the same model as standard RDS RIs — 1-year or 3-year terms with All-Upfront, Partial-Upfront, or No-Upfront payment options. The discount range is similar (40–60% for 1-year, 60–75% for 3-year). Aurora RIs cover the instance cost only, not storage or I/O. For predictable production Aurora workloads, RIs deliver substantial savings; for variable workloads, on-demand or Serverless v2 is more flexible. Note that Aurora RIs are not interchangeable with standard RDS RIs and cannot be applied across the line.

### What is Aurora Limitless and how does it price differently?
Aurora Limitless is the horizontally sharded Aurora variant — automatic sharding for PostgreSQL workloads beyond what a single Aurora cluster can handle. Pricing is based on routing layer + shard groups + standard Aurora storage. The routing layer bills similar to Aurora Serverless v2 ACUs; shard groups bill per provisioned ACU-equivalent capacity. Limitless is the right primitive for workloads that have outgrown vertical Aurora scaling and need automatic sharding without application-level partition management. The total cost is typically higher than a single Aurora cluster but covers workloads beyond what a single cluster can serve.

---

*Source: https://www.factualminds.com/blog/amazon-aurora-pricing-io-optimized-serverless-v2-global/*