Advanced6 min read

DynamoDB Adaptive Capacity: What It Does and What It Cannot

Your traffic rarely spreads as evenly as DynamoDB spreads your data. Burst capacity and adaptive capacity are the two automatic mechanisms that keep a skewed workload from throttling, up to a hard limit.

What is DynamoDB adaptive capacity?

Adaptive capacity is DynamoDB's automatic boost for a .

It raises that partition's throughput out of the table's unused capacity, so a skewed key doesn't throttle while the rest of the table idles. It cannot push one item past a partition's maximum.

  • Burst capacity keeps up to 300 seconds of unused throughput in reserve for short spikes. You can't size or tune it.
  • Adaptive capacity lifts a , bounded by the table's total capacity and by the partition maximum.
  • It can isolate a hot item onto its own partition, giving that one item up to 3,000 RCU / 1,000 WCU. AWS says it "might", so treat isolation as best-effort.
  • It doesn't replace key design. One item past the partition maximum, or a whole table past its capacity, still throttles.

Know the partition ceiling first

Every partition is designed to deliver at most 3,000 read units and 1,000 write units per second, and adaptive capacity applies on both provisioned and on-demand tables. (AWS, Best practices for designing partition keys.)

The full set of per-partition limits, and how partitions split, lives in physical partitions.

Coming from SQL, you reason about total server load. In DynamoDB the unit that throttles is the single partition, so one skewed key can throttle while the table sits 90% idle. Both mechanisms exist to narrow that gap.

Burst capacity absorbs the short spike

Whenever you don't fully use a partition's throughput, DynamoDB reserves a portion of the leftover. Up to 300 seconds of unused capacity is held back, and a sudden burst can drain it faster than your per-second rate would normally allow.

It's automatic and you can't size it. AWS also says DynamoDB can spend burst capacity on background maintenance "without prior notice". So plan against your expected peak, not against the burst reserve.

For a peak you know about, size for it directly. On a provisioned table, set RCU/WCU (or auto scaling) for the peak.

On either capacity mode, pre-warm with warm throughput before a launch or sale (aws dynamodb update-table --table-name <table> --warm-throughput ReadUnitsPerSecond=…,WriteUnitsPerSecond=…).

Adaptive capacity boosts the hot partition

Burst capacity handles short spikes. Adaptive capacity handles sustained skew. When one partition runs hot while its neighbors idle, DynamoDB raises the hot one's throughput, up to the table total and the partition maximum.

Say you run a fleet-telemetry table keyed VEHICLE#<id> (partition) and TS#<epoch> (sort), provisioned at 400 WCU across four partitions, so each partition's even share is 100 WCU.

One delivery van in a flash-sale zone pings so often that its partition needs 150 WCU, while the other three take 50 each.

Adaptive capacity lifts that one partition past its 100-WCU share, drawing on the 150 WCU the cold partitions leave unused.

You don't configure or pay for it, and since May 2019 it applies instantly. (AWS Database Blog, "How DynamoDB adaptive capacity accommodates uneven access patterns".)

Adaptive capacity, to scale
150 WCU/s

Four partitions share a 400-WCU table, 100 each. Push the hot partition past its share and watch the boost draw from the idle 150 WCU/s — then hit the wall where the idle pool ends.

The hot partition serves 150 WCU/s — its own 100 plus 50 borrowed from the cold partitions’ 150 idle WCU/s. No throttling.

PartitionProvisioned shareDemandedServedAdaptive boostThrottled
VEHICLE#A11005050——
VEHICLE#B71005050——
VEHICLE#C31005050——
VEHICLE#HOT100150150+50—

A teaching model of the steady-state reallocation rule only. Real adaptive capacity also interacts with burst credits and split-for-heat, and a single partition never serves more than 3,000 read units or 1,000 write units per second no matter what the table has provisioned.

The hot van's partition needs 150 WCU against a 100-WCU share; without the boost the extra 50 WCU would throttle once burst capacity ran out.

The 2022 USENIX ATC paper adds that DynamoDB internally "replaced adaptive capacity with global admission control (GAC)".

The developer guide still documents the behavior above under the adaptive-capacity name, and that behavior is what you observe.

Isolation: when one item is the problem

Skew isn't always spread over many items in a partition. Sometimes one item takes the traffic.

Say the app also keeps one position item per van, VEHICLE#HOT / LATEST, overwritten on every ping and read by every dispatcher screen.

If relentless traffic drives that one item, adaptive capacity "might rebalance your data so that a partition contains only that single, frequently accessed item".

Once isolated, that item can draw up to the partition maximum: 3,000 RCU and 1,000 WCU (AWS, Burst and adaptive capacity).

No automatic mechanism goes above that for one item. The 2022 paper adds that a partition hot on a single item "will not benefit from split".

A busy partition key is different: its item collection can be split by sort key, unless the sort key rises monotonically.

The van's telemetry is that exception. Every ping adds a new TS#<epoch> item at the leading edge of one collection, so split for heat (DynamoDB dividing a busy partition along its sort-key range) won't spread it; write sharding (below) does.

Adaptive capacity also won't split an across partitions when the table has a .

You can't drop an LSI from an existing table; LSIs exist only from CreateTable. If a collection must spread, create a new table that models the alternate sort order as a GSI, then move the data.

Until then, request ReturnItemCollectionMetrics: SIZE on writes to watch the 10 GB collection cap. GSI vs LSI covers the choice.

When adaptive capacity can't save you

Both mechanisms move throughput around; neither creates more than a partition, or the table, allows.

ScenarioBurstAdaptiveOutcome
Short spike, table has slackCovers itNo roleNo throttle
Sustained skew, cold neighborsNo roleBoosts hotNo throttle
One item, < 3K RCU / 1K WCUNo roleMay isolateUsually no throttle (isolation is best-effort)
One item, > partition ceilingDrained fastAt the roofThrottled: spread or cache that item
Many keys hot at once, table maxedDrained fastNothing idleThrottled: add table capacity (provisioned, auto scaling, warm)

When the whole table is over its capacity, a key redesign won't help: raise provisioned RCU/WCU or attach auto scaling.

On on-demand, raise the table-level quota in Service Quotas (or the maximum-throughput cap, if you set one), and pre-warm before known peaks. See on-demand vs provisioned.

When one item, or the leading edge of a monotonic sort key, needs more than 1,000 write units a second (1,000 writes/s of items up to 1 KB, fewer for larger items), spread its writes across more partition keys.

Write sharding does that: append a suffix (VEHICLE#HOT#0 … #9) and read the shards back. Hot partitions covers random vs calculated suffixes.

When one item needs more than 3,000 read units a second, switch those reads to eventually consistent (half the read units each), or put DAX in front of the item if your reads can tolerate eventual consistency.

See it on your own table

Adaptive capacity is invisible, so watch its symptom: which keys take the traffic. Turn on CloudWatch Contributor Insights for the table or GSI.

Its throttled-keys mode is cheap enough to leave on and names the most-throttled partition keys. Hot partitions walks through the diagnosis.

For the read side of skew, see Query vs Scan.

When you build a sharded write path, the Expression Builder generates the PutItem and Query syntax for a suffixed key.

To check how many items each key holds (collection size, which matters for the 10 GB LSI cap, not for traffic), download DynoTable and run a GROUP BY over your partition key in the SQL Workbench.

By Dmitriy · Updated