How do gp3, io2, Aurora Standard and Aurora I/O-Optimized charge for I/O?

Each model prices the same resource, storage that can serve reads and writes, but they put the cost risk in different places.

Model Storage charge I/O charge Who carries the risk Suits
gp3 Per GB-month Baseline IOPS and throughput included; extra IOPS and throughput provisioned and billed separately You size the ceiling Steady, moderate I/O
io2 Per GB-month Per provisioned IOPS-month, billed whether used or not You pay for the reserved peak Latency-sensitive, consistently high I/O
Aurora Standard Per GB-month, billed on what is actually stored Per million I/O requests You pay for actual usage Low or spiky I/O
Aurora I/O-Optimized Higher per GB-month None per request; instance rates are higher Fixed premium Heavy, sustained I/O

gp3 separates capacity from performance. You can raise IOPS or throughput without buying disk you don't need. The baseline is enough for many workloads, so you only pay extra when the workload needs more.

io2 sells guaranteed, consistent performance. The provider reserves that capacity for you, so you pay for it every hour even when the database is idle.

Aurora Standard reflects Aurora's shared, distributed storage layer. There is nothing to provision, so I/O is metered like a utility. That is cheap for quiet databases but hard to forecast for busy ones.

I/O-Optimized turns that variable charge into a fixed premium on instances and storage. You trade a higher baseline cost for a predictable bill.

Aurora's billed I/O counts are not the same unit as EBS IOPS. Aurora counts reads that miss the buffer cache and go to the storage layer, and it counts writes in its own units. A number such as "5,000 IOPS on gp3" therefore does not translate directly into an Aurora I/O bill. Measure each one separately.

How do you measure your actual database I/O before choosing storage?

Measure the workload you actually run before comparing prices. On RDS instances, CloudWatch publishes ReadIOPS, WriteIOPS, ReadThroughput and WriteThroughput per instance. Pull them at one-minute granularity over at least a full business cycle, including month-end jobs, batch windows and backups. Look at Maximum and high percentiles such as p95 and p99, not Average. A daily average of 2,000 IOPS can hide 15-minute bursts at 12,000. On gp3 those bursts hit the provisioned ceiling, queue depth rises, and query latency spikes. Size provisioned IOPS and throughput for the peaks you must absorb. Use the average only to estimate request volume.

A stable way to pull this data is aws cloudwatch get-metric-statistics with these arguments:

  • --namespace AWS/RDS
  • --metric-name WriteIOPS
  • --dimensions Name=DBInstanceIdentifier,Value=<your-instance>
  • --period 60
  • --statistics Maximum Average
  • --extended-statistics p99 if you want percentiles

On Aurora, use VolumeReadIOPs and VolumeWriteIOPs with the DBClusterIdentifier dimension. These are the I/O counts that Aurora Standard bills, so summing them over a month gives the request volume behind the charge. Then check that total against the I/O line items in Cost Explorer for the same cluster over a representative billing period. If the two disagree, your sampling window probably missed a heavy job.

Any conversion from RDS IOPS to an Aurora I/O estimate remains approximate, because the two engines count and cache I/O differently. To get a reliable figure, restore a snapshot to Aurora, replay or mirror production traffic, and measure the result.

#!/usr/bin/env bash
# Pull one day of 1-minute RDS I/O data, then Aurora billed I/O for comparison.
# Requires GNU date. GetMetricStatistics returns at most 1,440 points per call,
# so loop this over each day of your business cycle.
set -euo pipefail

INSTANCE="orders-db-prod"      # RDS instance identifier (placeholder)
CLUSTER="orders-aurora-prod"    # Aurora cluster identifier (placeholder)
DAY="2026-10-31"                # include month-end, batch and backup days
START="${DAY}T00:00:00Z"
END="$(date -u -d "${DAY} + 1 day" +%Y-%m-%dT00:00:00Z)"

for METRIC in ReadIOPS WriteIOPS ReadThroughput WriteThroughput; do
  # Peak and average. Size IOPS and throughput for the peak. Use the average only for request volume.
  aws cloudwatch get-metric-statistics \
    --namespace AWS/RDS --metric-name "$METRIC" \
    --dimensions Name=DBInstanceIdentifier,Value="$INSTANCE" \
    --start-time "$START" --end-time "$END" --period 60 \
    --statistics Maximum Average \
    --query 'max_by(Datapoints, &Maximum).[Timestamp,Maximum]' --output text

  # Percentiles need a separate call: --statistics and --extended-statistics
  # cannot be combined in the same request.
  aws cloudwatch get-metric-statistics \
    --namespace AWS/RDS --metric-name "$METRIC" \
    --dimensions Name=DBInstanceIdentifier,Value="$INSTANCE" \
    --start-time "$START" --end-time "$END" --period 60 \
    --extended-statistics p95 p99 --output json > "${METRIC}-${DAY}-pct.json"
done

# Aurora: each datapoint is billed I/O per 5-minute interval, so summing the
# datapoints gives the day's billed volume. Compare monthly totals with the
# I/O line items in Cost Explorer for the same cluster.
for METRIC in VolumeReadIOPs VolumeWriteIOPs; do
  aws cloudwatch get-metric-statistics \
    --namespace AWS/RDS --metric-name "$METRIC" \
    --dimensions Name=DBClusterIdentifier,Value="$CLUSTER" \
    --start-time "$START" --end-time "$END" --period 300 \
    --statistics Average --query 'sum(Datapoints[].Average)' --output text
done

Collects one day of 1-minute peak, average and p95/p99 RDS I/O metrics, then sums Aurora's billed VolumeReadIOPs and VolumeWriteIOPs for the same day so you can reconcile the totals with Cost Explorer.

When should you use Aurora I/O-Optimized vs Standard?

Pull 30 to 90 days of billing data for the cluster, including a month with your usual batch jobs. Split it into instance hours, storage GB-months and I/O requests, then compute the I/O share of the total. Next, reprice the same usage at the current published I/O-Optimized rates for your region and compare the two full bills. Comparing only the I/O line is misleading, because I/O-Optimized raises the instance and storage rates to cover I/O.

Illustrative estimate. All prices below are assumptions, not published rates. Plug in current regional pricing before deciding.

  • Standard: instances $1,000/month, storage 1,000 GB at $0.10, I/O at $0.20 per million requests.
  • I/O-Optimized: the same instances at $1,300 and storage at $0.225/GB, with no I/O charge.
Monthly I/O requests Standard total I/O-Optimized total
1.0 billion $1,300 $1,525
2.125 billion $1,525 $1,525
4.0 billion $1,900 $1,525

The fixed premium is $425, so the crossover sits at about 2.1 billion requests, when I/O is roughly 28% of the Standard bill. With these assumptions, each 10% change in I/O volume moves the Standard bill by about $40 to $45.

Avoid I/O-Optimized for storage-heavy, low-I/O clusters, where the higher storage rate dominates. Also avoid it for clusters with many large instances, because the instance uplift scales with fleet size while your I/O may not.

Predictability is part of the price. On Standard, I/O cost has no ceiling and follows traffic. A bad query plan, a backfill or a cache-cold restart after failover can spike the bill. I/O-Optimized caps that risk, but you pay its premium even in quiet months.

# Illustrative estimate: compare full Aurora bills, not just the I/O line.
# All prices are ASSUMPTIONS. Replace them with current published rates for your region.
INSTANCES_STD = 1000.00       # $/month, Standard instance spend
INSTANCES_IOOPT = 1300.00     # $/month, same instances at I/O-Optimized rates
STORAGE_GB = 1000             # average GB-months from billing data
STORAGE_STD = 0.10            # $/GB-month, Standard
STORAGE_IOOPT = 0.225         # $/GB-month, I/O-Optimized
IO_PER_MILLION = 0.20         # $/million I/O requests, Standard only

def standard_total(io_requests):
    io_cost = io_requests / 1_000_000 * IO_PER_MILLION
    return INSTANCES_STD + STORAGE_GB * STORAGE_STD + io_cost

def io_optimized_total():
    # No I/O charge; the cost moves into higher instance and storage rates.
    return INSTANCES_IOOPT + STORAGE_GB * STORAGE_IOOPT

# Fixed premium you pay on I/O-Optimized every month, busy or quiet.
premium = io_optimized_total() - (INSTANCES_STD + STORAGE_GB * STORAGE_STD)
crossover = premium / IO_PER_MILLION * 1_000_000
print(f"Fixed premium: ${premium:,.0f}/month")
print(f"Crossover: {crossover / 1e9:.3f} billion I/O requests/month")

# Sensitivity: how the Standard bill moves with I/O volume.
for billions in (1.0, 2.125, 4.0):
    io = billions * 1e9
    std = standard_total(io)
    io_share = (std - INSTANCES_STD - STORAGE_GB * STORAGE_STD) / std
    print(f"{billions:>6.3f}B I/O: Standard ${std:,.0f} "
          f"(I/O share {io_share:.0%}) vs I/O-Optimized ${io_optimized_total():,.0f}")

# A +10% swing in I/O near the crossover changes the Standard bill by:
print(f"+10% I/O at crossover: ${standard_total(crossover * 1.1) - standard_total(crossover):,.0f}")

A self-contained Python calculation, using assumed prices as an illustrative estimate, that reprices the same usage under Aurora Standard and I/O-Optimized, finds the crossover I/O volume, and shows how sensitive the Standard bill is to I/O swings.

Should you choose io2 or gp3 for RDS storage?

For most RDS workloads, gp3 is the right starting point. You provision IOPS and throughput separately from capacity, so a small, busy database doesn't need a bloated volume just to get I/O headroom. One caveat: RDS ties gp3 configurability to engine-specific storage thresholds, so very small volumes may need to cross a size boundary before extra IOPS can be provisioned. Check the limits for your engine.

io2 is worth its cost under narrower conditions. The workload should need sustained high IOPS with consistently low latency, or have durability requirements that justify io2's higher design target, and the provisioned level should match what you measured. io2 bills for provisioned IOPS whether you use them or not, so an over-sized volume charges the full rate through every quiet night and weekend. If you size to a quarterly peak, the extra IOPS can cost more than the slow queries they prevent.

gp3's weakness is latency consistency under sustained heavy load. Average latency can look fine while p99 drifts upward, and in latency-sensitive OLTP those tail requests stack up as lock waits and connection pile-ups. Judge gp3 on percentile latency, not means.

Factor gp3 io2
Billing model Capacity plus IOPS/throughput above baseline Capacity plus every provisioned IOPS
Latency under sustained load Tail latency can widen Consistent
Cost of over-provisioning Low High, billed continuously
Best fit Most services, bursty or moderate OLTP, dev/staging High-throughput OLTP with strict p99 SLOs and steady load

Teams with steady, measured, latency-critical load should evaluate io2. Everyone else should run gp3 and revisit only when tail latency, not cost intuition, says otherwise.

How do Multi-AZ deployments and read replicas change storage costs?

Multi-AZ changes the arithmetic because RDS bills every volume it provisions, and a Multi-AZ instance deployment provisions two: the primary's and the standby's. Storage and provisioned IOPS are charged for both, so whatever you over-provision on io2 you pay for twice. Read replicas work the same way: each one gets its own volume, billed separately.

Aurora separates compute from storage. All instances in a cluster read from one shared cluster volume. Aurora keeps multiple copies of that volume across Availability Zones, but you are billed once for storage regardless of replica count. Replicas are not free, though. Each instance is billed for compute, and on Aurora Standard any read that misses a replica's buffer cache is billed I/O, the same as a read on the writer.

RDS Multi-AZ                         Aurora cluster
------------                         --------------
[Primary]      [Standby]             [Writer] [Replica] [Replica]   <- $ per instance
    |              |                     \        |        /
[Volume A]     [Volume B]                 [Shared cluster volume]  <- $ storage, once
 $ GB + IOPS    $ GB + IOPS               Standard: $ per I/O from any instance
                                          I/O-Optimized: no per-I/O charge

Illustrative estimate (assumed numbers, not a benchmark). Assume io2 provisioned at 20,000 IOPS, a measured peak of 8,000, and an assumed price P of $0.10 per IOPS-month.

Monthly waste = (provisioned − needed) × P × volume count = (20,000 − 8,000) × 0.10 × 2 = $2,400

The same over-provisioning costs $1,200 on a Single-AZ instance and $2,400 on Multi-AZ.

 RDS Multi-AZ (instance)          Aurora cluster
 -----------------------          --------------

 +---------+     +---------+     +--------+ +---------+ +---------+
 | Primary |     | Standby |     | Writer | | Replica | | Replica |
 | (AZ a)  |     | (AZ b)  |     |        | |         | |         |
 +---------+     +---------+     +--------+ +---------+ +---------+
  $ compute       $ compute       $ compute  $ compute   $ compute
      |               |              |           |           |
      v    sync       v              v           v           v
 +---------+     +---------+     +--------------------------------+
 | Vol A   |---->| Vol B   |     |     Shared cluster volume      |
 | io2     |     | io2     |     |   copies kept across AZs       |
 +---------+     +---------+     +--------------------------------+
  $ GB + IOPS    $ GB + IOPS     $ storage: billed once
  (primary)      (standby)       Standard: $ per I/O from any instance
                                 I/O-Optimized: no per-I/O charge

  Two volumes: unused io2 IOPS
  are billed on both A and B

RDS Multi-AZ bills storage and provisioned IOPS on both the primary and standby volumes, while an Aurora cluster bills its shared volume once and charges compute per instance, plus per-I/O charges on Aurora Standard.

How can you reduce database I/O before paying for more of it?

Every read served from memory is one you don't pay for, so start with the working set. If the hot tables and indexes don't fit in the buffer pool (shared_buffers in PostgreSQL, innodb_buffer_pool_size in MySQL), the engine keeps evicting and re-reading the same pages. A larger instance class can cost less than the I/O it eliminates. Compare the price difference against your measured read I/O before ruling it out.

To find which queries generate the I/O, sort pg_stat_statements by shared_blks_read, not by execution time. Blocks read come from storage, while shared_blks_hit came from cache. A fast query that runs thousands of times a minute can outweigh one slow report. Run EXPLAIN (ANALYZE, BUFFERS) on the top offenders. A sequential scan that reads many buffers to return a few rows usually needs an index. On MySQL, the Performance Schema statement digest tables and EXPLAIN serve the same purpose.

On the write side, batch inserts and updates into fewer transactions. Each commit forces a log flush, so many single-row commits cost far more I/O than one multi-row statement. Move reporting and analytics off the primary to a replica or a separate analytical store, so large scans stop evicting the transactional working set.

After each change, measure I/O again and redo the Aurora comparison from section 3. Cutting read I/O substantially can make Standard cheaper than I/O-Optimized again.

-- Requires the pg_stat_statements extension (enabled via the DB parameter group
-- shared_preload_libraries, then CREATE EXTENSION pg_stat_statements;).
-- total_exec_time is the PostgreSQL 13+ column name (total_time before 13).

-- 1. Rank statements by blocks read from storage, not by runtime.
SELECT
  left(query, 80)                         AS query_start,
  calls,
  shared_blks_read,                       -- pages fetched from storage (billable I/O)
  shared_blks_hit,                        -- pages served from shared_buffers
  round(100.0 * shared_blks_hit
        / nullif(shared_blks_hit + shared_blks_read, 0), 1) AS cache_hit_pct,
  round(total_exec_time::numeric, 0)      AS total_ms
FROM pg_stat_statements
ORDER BY shared_blks_read DESC
LIMIT 10;

-- 2. Inspect a top offender. ANALYZE actually runs the query, so use a
--    representative read-only statement. BUFFERS shows shared hit vs read.
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, status, total
FROM orders
WHERE customer_id = 4821;
-- A "Seq Scan on orders" with a large "Buffers: shared read=" value that
-- returns a handful of rows suggests a missing index:
CREATE INDEX CONCURRENTLY idx_orders_customer_id ON orders (customer_id);

-- 3. Batch writes: one transaction and one multi-row INSERT instead of
--    many single-row autocommits, so the log is flushed once.
BEGIN;
INSERT INTO events (device_id, recorded_at, reading) VALUES
  (101, now(), 21.4),
  (102, now(), 19.8),
  (103, now(), 22.1);
COMMIT;

-- 4. After deploying changes, reset counters and re-measure before repricing.
SELECT pg_stat_statements_reset();

Finds the PostgreSQL statements that read the most blocks from storage with pg_stat_statements, confirms a full scan with EXPLAIN (ANALYZE, BUFFERS), adds an index, batches writes, and resets the counters so I/O can be measured again before repricing Aurora.

What operational constraints and alternatives affect the decision?

Storage decisions are harder to reverse than instance decisions, so check these constraints before you commit to a configuration.

RDS allocated storage can grow but cannot shrink in place. If you over-provision gp3 or io2 to reach an IOPS or throughput target, you keep paying for that capacity. Getting back to a smaller volume means creating a new instance and moving the data, for example with a dump and restore or logical replication. Storage modifications also have a cooldown period, so you cannot make a series of quick adjustments during an incident.

Aurora lets you switch a cluster between Standard and I/O-Optimized, but the switch is rate-limited. Check the current rules before you plan to toggle around month-end batch jobs. Reserved instance pricing differs between the two Aurora configurations, so price each one separately rather than assuming one discount applies to both.

Option Main constraint Why it matters
gp3 / io2 resize Grows only, with a cooldown Over-provisioning is costly to undo
Aurora storage mode switch Rate-limited Not a lever for short-term tuning
Reserved instances Priced per configuration Commitment can tie you to one mode
Migrating RDS to Aurora Engine testing, different failover and backups Storage savings may not cover the migration effort

Moving from RDS to Aurora is a valid option, but it is a migration project. You need to test engine compatibility and update runbooks for different failover and backup behavior. Storage savings alone rarely justify that work.

Re-check the decision on a regular schedule, for example quarterly, against current billing data. Pricing changes, regions differ, and workloads grow, so a choice that was cheapest a year ago may no longer be.

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 io optimized vs standard, 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.