How does DynamoDB pricing work in on-demand vs provisioned mode?
DynamoDB offers two capacity modes, and the main difference is what you pay for. Provisioned mode bills per read capacity unit (RCU) and write capacity unit (WCU) per hour for the throughput you reserve, whether or not traffic arrives. It is designed for workloads you can forecast. On-demand mode bills per read request unit (RRU) and write request unit (WRU) actually consumed, with no capacity to declare. It is designed for traffic you cannot forecast, or for tables that sit idle most of the time.
Both modes size requests the same way. Reads are metered in 4 KB increments and writes in 1 KB increments, rounded up. Consistency level and transactions then multiply that base:
| Request type | Provisioned (per request, per increment) | On-demand (per request, per increment) |
|---|---|---|
| Eventually consistent read (4 KB) | 0.5 RCU | 0.5 RRU |
| Strongly consistent read (4 KB) | 1 RCU | 1 RRU |
| Transactional read (4 KB) | 2 RCU | 2 RRU |
| Standard write (1 KB) | 1 WCU | 1 WRU |
| Transactional write (1 KB) | 2 WCU | 2 WRU |
For example, a strongly consistent read of a 9 KB item costs 3 units in either mode. Because of this, raw request counts are not comparable across tables or mode choices. Convert traffic to capacity units first, then compare prices.
Several costs are identical in both modes and drop out of the break-even calculation: storage, backups, streams, and data transfer. Table class does affect throughput prices. Standard-IA lowers storage cost and raises the per-unit price of reads and writes, so run the comparison using the unit prices for your table's class.
Who should use this break-even analysis?
The analysis is for engineers and teams who own DynamoDB tables and are responsible for their cost or their reliability. In practice that usually means:
- Backend and platform engineers deciding the capacity mode for a new table, or revisiting the mode of a table that has been running for months.
- Teams whose DynamoDB bill has grown and who need to know which tables and indexes are worth tuning and which should be left alone.
- Teams planning a reserved capacity purchase, who need a measured floor before they commit to one or three years of throughput.
- On-call owners of throttling-sensitive paths, such as checkout or authentication, who need to weigh throttling risk against cost savings.
It is less useful for accounts made up only of small, low-traffic tables. If the throughput line on the bill is small, on-demand is usually the right default, and the time spent on detailed analysis is better spent elsewhere. The method pays off on the few tables and GSIs with enough sustained traffic for the choice of mode to make a visible difference.
How does the break-even comparison work?
The comparison reduces to one question: how much of the capacity you would provision is actually used? The procedure in the rest of this article follows four steps:
- Normalize traffic to capacity units. Convert reads and writes into RCUs/RRUs and WCUs/WRUs using item size, consistency level and transactions, as in the table above. Both modes use the same units, so prices become directly comparable.
- Compute the break-even utilization from prices. Divide the cost of one provisioned unit running fully busy for an hour by the cost of the same 3,600 requests on demand. The result is the utilization above which provisioned is cheaper.
- Measure your real utilization. Use CloudWatch one-minute consumed-capacity metrics to get the average rate and the per-minute peak you would need to provision for. The ratio of average to peak is your achievable utilization if capacity is fixed at peak.
- Adjust for how you would actually provision. Auto scaling headroom and lag reduce effective utilization. Reserved capacity lowers the provisioned unit price and moves the break-even point.
Each step runs separately for reads and writes, and separately for the base table and for every GSI, because each has its own prices, traffic shape and, in provisioned mode, its own capacity settings.
How do you calculate the break-even utilization between the two modes?
Both modes bill the same unit of work: one write unit covers a write of up to 1 KB, and one read unit covers a strongly consistent read of up to 4 KB. Eventually consistent reads cost half in both modes. Because the units match, you can compare prices directly. A provisioned capacity unit costs the same each hour whether you use it or not. Run at 100% for an hour, one unit serves 3,600 requests:
- Provisioned cost per million requests at full use =
hourly_unit_price / 3600 × 1,000,000 - Break-even utilization =
that figure / on_demand_price_per_million
If the result is 0.15, provisioned is cheaper whenever your average consumed-to-provisioned ratio stays above 15%. Below that, on-demand wins. Total request volume does not decide this. A table serving billions of requests a month can still be cheaper on demand if those requests arrive in short bursts and capacity sits idle the rest of the time.
As a spreadsheet, enter the current prices for your region and table class:
B1: provisioned price per WCU-hour (placeholder)B2: on-demand price per million write request units (placeholder)B3:=B1/3600*1000000B4:=B3/B2(break-even utilization)
Repeat the calculation for reads, and keep reads and writes separate. Reads and writes have different prices and usually different traffic shapes, so each has its own break-even point.
In provisioned mode, every GSI also has its own capacity settings, so each index is a separate break-even problem. Index writes are often the largest line item. A base-table write that touches projected attributes also writes to every affected index. An update that changes an index key attribute costs a delete plus a put on that index. A table with three GSIs can therefore spend more on index writes than on the base table.
def break_even(hourly_unit_price, on_demand_per_million):
"""Utilization fraction at which both modes cost the same."""
# One unit at 100% for an hour serves 3,600 requests.
provisioned_per_million = hourly_unit_price / 3600 * 1_000_000
return provisioned_per_million / on_demand_per_million
PRICES = {
# kind: (provisioned price per unit-hour, on-demand price per million request units)
"writes": (0.0010, 1.00), # placeholder
"reads": (0.0002, 0.20), # placeholder
}
capacities = [
# (name, price kind, avg consumed units/s, provisioned units/s)
("base table writes", "writes", 120, 400),
("base table reads", "reads", 900, 1500),
("gsi_by_status writes", "writes", 240, 600), # frequent key changes
("gsi_by_owner writes", "writes", 60, 400),
]
for name, kind, consumed, provisioned in capacities:
threshold = break_even(*PRICES[kind])
utilization = consumed / provisioned
cheaper = "provisioned" if utilization > threshold else "on-demand"
print(f"{name:22} util={utilization:5.0%} break-even={threshold:5.0%} -> {cheaper}")
A Python script that uses placeholder prices to compute the break-even utilization separately for reads and writes, then compares the measured average utilization of the base table and of each GSI against it.
Worked example: steady, diurnal, and spiky workloads with the same request count
To see where the break-even line falls, hold the monthly request count constant and change only the traffic shape. Every figure below is an illustrative estimate built on assumed inputs. Plug in your region's current prices and your own traffic; do not reuse these numbers.
Assumptions:
- Traffic: 100 million writes per month, each item under 1 KB (one write unit per write), over a 730-hour month.
- Assumed prices: $1.25 per million on-demand writes and $0.00065 per provisioned WCU-hour. At those prices, one WCU costs about $0.47 per month.
- Provisioning: capacity is fixed at peak with no auto scaling.
Under these assumptions:
- On-demand costs $125 for every workload. Its price depends on request count, not on shape.
- Average rate is about 38 writes per second for every workload.
- Break-even is about 263 provisioned WCU. That is a peak-to-average ratio of roughly 7.
| Workload (assumed) | Per-minute peak | Peak ÷ average | WCU provisioned | Provisioned cost | On-demand cost | Cheaper mode |
|---|---|---|---|---|---|---|
| Steady | ~46/s | ~1.2 | 50 | ~$24 | $125 | Provisioned |
| Diurnal | ~152/s | ~4 | 160 | ~$76 | $125 | Provisioned |
| Nightly 2-hour batch | ~463/s | ~12 | 500 | ~$237 | $125 | On-demand |
All three tables have the same average rate, so a monthly average cannot tell you which mode is cheaper. Provisioned capacity has to cover the busiest minute, because writes above it get throttled. You pay for that peak capacity during every quiet hour too. The batch job uses its capacity for about 2 of every 24 hours, so most of what it pays for sits idle.
Use the per-minute peak-to-average ratio as the deciding number. Compare it with your own break-even ratio: on-demand monthly cost divided by the monthly cost of one WCU, then divided by your average rate. If your ratio is lower, provisioned is cheaper. If it is higher, on-demand is cheaper.
Same input for all: 100M writes/month, avg ~38/s (all figures assumed)
|
+-------------------+-------------------+
| | |
v v v
+-----------------+ +-----------------+ +-----------------+
| Steady | | Diurnal | | 2-hour batch |
| peak ~46/s | | peak ~152/s | | peak ~463/s |
| peak/avg ~1.2 | | peak/avg ~4 | | peak/avg ~12 |
+--------+--------+ +--------+--------+ +--------+--------+
| | |
v v v
+-----------------+ +-----------------+ +-----------------+
| 50 WCU, ~$24/mo | | 160 WCU, ~$76/mo| | 500 WCU,~$237/mo|
+--------+--------+ +--------+--------+ +--------+--------+
| | |
v v v
+---------------------------------------------------------+
| Break-even ~263 WCU = peak/avg ~7; on-demand $125/mo |
+---------------------------------------------------------+
| | |
v v v
below line below line above line
PROVISIONED PROVISIONED ON-DEMAND
Recalculate with your own prices and traffic; do not reuse.
Illustrative estimate with assumed prices: three workloads with the same 100M monthly writes and ~38/s average land on different sides of break-even because provisioned capacity must cover the per-minute peak.
How do you measure your table's real utilization in CloudWatch?
Both comparisons need two numbers from your own table: the average consumption rate and the peak rate you would have to provision for. CloudWatch publishes both under the AWS/DynamoDB namespace.
Pick the window first
Measure across a full business cycle. For most systems that means at least one week, so weekday and weekend patterns both appear. It should also include any month-end batch jobs. A quiet Tuesday will make provisioned capacity look cheaper than it is.
Keep CloudWatch retention in mind. One-minute datapoints are kept for 15 days and five-minute datapoints for 63 days. After that, only hourly data remains, and hourly data hides the short peaks that drive provisioning.
Pull consumed and provisioned metrics
Call aws cloudwatch get-metric-statistics once for each metric:
ConsumedReadCapacityUnitsandConsumedWriteCapacityUnits: pass--dimensions Name=TableName,Value=<table>,--period 60, and--statistics Sum.ProvisionedReadCapacityUnitsandProvisionedWriteCapacityUnits: pull these too if the table is already provisioned, so you can see how much headroom you are paying for.
A single call returns at most 1,440 datapoints, so split a week of one-minute data into daily requests.
Turn the output into a ratio
- Add up every
Sumvalue in the window. That total is your billable unit count, which you can price directly in either mode. - Divide the total by the number of seconds in the window. The result is your average units per second.
- Find the largest single one-minute
Sumand divide it by 60. That is your peak units per second. - Divide the average by the peak. Compare this average-to-peak ratio with your break-even ratio.
Minute-level peaks are the right basis for sizing provisioned capacity because hourly averages smooth over the bursts that cause throttling.
Repeat for every GSI
Each global secondary index has its own capacity and its own bill. Rerun the same calls with an added Name=GlobalSecondaryIndexName,Value=<index> dimension, and evaluate each index on its own.
#!/usr/bin/env bash
set -euo pipefail
METRIC="ConsumedWriteCapacityUnits" # rerun with ConsumedReadCapacityUnits
DIMS=("Name=TableName,Value=orders")
DAYS=7
START_EPOCH=$(date -u -d "2026-10-26" +%s) # must be within the last 15 days for 1-minute data
OUT=$(mktemp)
for i in $(seq 0 $((DAYS - 1))); do
s=$(date -u -d "@$((START_EPOCH + i * 86400))" +%Y-%m-%dT%H:%M:%SZ)
e=$(date -u -d "@$((START_EPOCH + (i + 1) * 86400))" +%Y-%m-%dT%H:%M:%SZ)
aws cloudwatch get-metric-statistics \
--namespace AWS/DynamoDB \
--metric-name "$METRIC" \
--dimensions "${DIMS[@]}" \
--start-time "$s" --end-time "$e" \
--period 60 --statistics Sum \
--query 'Datapoints[].Sum' --output json >> "$OUT"
done
jq -s --argjson secs $((DAYS * 86400)) '
add as $v | ($v | add) as $total | (($v | max) / 60) as $peak |
{total_units: $total,
avg_per_sec: ($total / $secs),
peak_per_sec: $peak,
avg_to_peak: (($total / $secs) / $peak)}' "$OUT"
rm -f "$OUT"
Pulls a week of one-minute Sum datapoints in daily requests with aws cloudwatch get-metric-statistics, then uses jq to compute the total billable units, average and peak units per second, and the average-to-peak ratio for the table or a GSI.
How do auto scaling and reserved capacity shift the break-even point?
Auto scaling does not deliver its target utilization as an average. Three effects pull effective utilization (consumed divided by provisioned, summed over the billing period) below the setting:
- Headroom is intentional. A 70% target means about 30% of provisioned capacity is meant to sit idle to absorb short bursts.
- Scale-up lags. Auto scaling acts on CloudWatch alarms that need a sustained breach over several minutes. During a ramp you either throttle or rely on burst capacity, and the new capacity is billed after the peak that triggered it.
- Scale-down is rate-limited. DynamoDB caps how many times a table can lower its capacity per day. After a spike, you keep paying for the higher level until a decrease is allowed and the alarms fire.
When you use the break-even formula, put in the measured ratio from the previous section, not the target. For spiky workloads, the gap between the two can be large.
Reserved capacity
Reserved capacity is a one- or three-year commitment to a fixed amount of provisioned throughput in a region, at a lower hourly rate. A lower unit price moves the break-even further in favor of provisioned capacity, but only for capacity you actually keep busy. The common pattern is a hybrid: reserve the floor your traffic never drops below, and let auto scaling handle everything above it at standard provisioned rates.
The risk is that the commitment outlives the workload. If traffic falls, a schema change consolidates tables, or a migration moves data to on-demand or to another store, you keep paying for the reservation. Reservations apply at the account level across all eligible tables in the region, not to a single table. Size them against the combined baseline of the account, and check that baseline again before you renew.
When should you avoid provisioned capacity, and when should you avoid on-demand?
Avoid provisioned capacity when traffic can jump faster than auto scaling reacts. Auto scaling responds to CloudWatch metrics after a delay, so a sudden burst exceeds the provisioned limit before new capacity arrives. Throttled requests trigger SDK retries, which raise latency and can surface as user-facing errors. Treat that risk as a cost. If one throttling incident on a checkout path costs more than a month of on-demand premium, provisioning tightly is false economy.
Avoid on-demand when you need a hard spend limit. Provisioned capacity acts as a cost circuit breaker: a runaway backfill or a retry storm hits the ceiling and throttles. On-demand serves the extra traffic and bills for it, so cost grows in proportion to the bad traffic until someone notices. If you choose on-demand, set billing alarms.
Engineering time also has a cost. Every provisioned table and global secondary index needs scaling policies, alarms, and periodic capacity reviews. For dozens of small, low-traffic tables, on-demand removes that work, and the savings from provisioning them are usually too small to justify it.
| Concern | Provisioned | On-demand |
|---|---|---|
| Sudden spikes | Throttles until auto scaling catches up | Absorbs spikes relative to the previous traffic peak |
| Runaway cost | Capped by provisioned limits | Grows with traffic |
| Operational effort | Per-table and per-index tuning | Minimal |
| Hot partitions | Throttles | Throttles |
On-demand is not unlimited from the first request. New or idle tables scale based on previous peak traffic, so a cold table that receives a large launch-day burst can still throttle. Pre-warm the table or switch it from provisioned mode ahead of the event. AWS limits how often you can switch a table between modes, so check the current documentation before you plan a switch. Hot partitions throttle in both modes, and no capacity mode fixes poor key design.
How can this analysis save engineering time?
The direct output of the analysis is a cost decision, but much of its value is in the work it lets you stop doing.
- It tells you which tables to ignore. Running the break-even check across an account usually shows that a small number of tables and GSIs carry most of the throughput cost. Everything else can stay on on-demand with no scaling policies, no capacity alarms and no tuning reviews. That removes a recurring maintenance task for every table you leave alone.
- It replaces debate with a repeatable check. Without a shared method, capacity-mode discussions turn into opinions about whether traffic is "spiky enough". With the formula and the CloudWatch script, the answer comes from two measured numbers and a price comparison, and anyone on the team can rerun it.
- It reduces throttling incidents. Choosing on-demand for tables whose per-minute peaks outrun auto scaling avoids the throttling, retry storms and pages that tightly provisioned tables produce. Each avoided incident saves on-call time and follow-up investigation, which is often worth more than the throughput savings that provisioning would have produced.
- It avoids wasted capacity planning on new tables. Launching unknown workloads on on-demand means nobody has to guess initial RCU and WCU values or fix them after the first throttling event. The measurement step later gives you real data to decide with.
- It can run unattended. The bash script above uses only the AWS CLI and
jq, so it can run on a schedule against each important table and GSI, with the results compared against your break-even thresholds. The periodic review then becomes reading a short report instead of pulling metrics by hand. - It de-risks reservation purchases. Sizing reserved capacity from a measured account-level floor avoids the later work of explaining, and living with, an over-committed reservation.
The trade-off runs the other way for the few tables that dominate the bill. There, the time spent setting up provisioned capacity, auto scaling and possibly reservations is justified, and the analysis tells you which tables those are.
What decision procedure should teams follow to choose a capacity mode?
Treat the choice as a recurring, evidence-based review rather than a one-time setting.
- Launch new or unknown workloads on on-demand. You pay more per request, but you collect real traffic data instead of guessing. A guessed provisioned table either throttles or wastes capacity while you learn.
- Wait for a stable shape. Observe several full weekly cycles. A launch week or a single marketing push is not representative.
- Move to provisioned with auto scaling only with margin. Measured utilization should clear the break-even point comfortably. If it only barely clears it, scaling lag and required headroom can erase the savings.
- Reserve only the proven floor. The floor is the capacity consumed at the quietest periods across the whole observation window. You pay for reserved capacity whether or not you use it.
- Schedule mode changes ahead of known spikes. Migrations, backfills and launches are the usual cases. Plan these changes within the switching limits described earlier.
- Re-run the analysis on a fixed cadence, and again after major product changes. Traffic shape drifts as features ship and usage patterns change.
| Option | Best fit | Main risk |
|---|---|---|
| Pure on-demand | New, spiky or low-volume tables | Highest per-request cost at sustained load |
| Provisioned + auto scaling | Predictable, gradual load changes | Throttling during sudden ramps |
| Provisioned + reservations | Long-lived, steady floor | Paying for unused commitment |
| Hybrid (reserved floor, auto-scaled peak) | Large tables with diurnal patterns | Operational complexity |
Evaluate these options at the account level, not table by table. Reserved capacity is purchased for a region rather than for a single table, so the floor that matters is the combined usage of all eligible tables. Dozens of small tables can reasonably stay on-demand. Spend your review effort on the few tables that dominate the bill.
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 dynamodb on-demand 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.
- Changing a route's URL or method automatically notifies the services that consume it — no hunting through repos for callers.
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.
- Consumers learn about a breaking change at review time rather than from production errors.
- 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.