How Does DynamoDB Store Data? Partitions, Consistency, and Billing Trade-offs

In AWS cloud architectures, Amazon DynamoDB is often the default choice for a serverless database. AWS certification exams and standard training materials cover the familiar rules around primary key design, capacity modes, and caching.

For example, a primary key consists of a Partition Key and a Sort Key; the Partition Key needs enough distinct values (high cardinality) to spread traffic and avoid hot spots. Capacity comes in Provisioned and On-demand modes, and reads can be accelerated with a DAX cache.

Behind each of these rules lies a specific distributed systems trade-off. Starting from the 2007 Dynamo paper, this article examines how DynamoDB manages physical partitions, balances read consistency against transaction costs, implements Multi-Region Strong Consistency (MRSC, launched in 2025), and the practical limits that shape architecture selection and billing.


1. Evolution: From Distributed Systems Paper to Managed Service

The 2007 Dynamo Paper: Shopping Carts and Write Availability

Dynamo traces its origins to a landmark paper presented at SOSP 2007 by Giuseppe DeCandia and colleagues, “Dynamo: Amazon’s Highly Available Key-value Store”. Right in Section 1, the authors state that e-commerce customers must always be able to add items to their shopping carts:

“even if disks are failing, network routes are flapping, or data centers are being destroyed by tornados”

For Amazon’s retail business, a customer who cannot add an item to their cart may abandon the purchase altogether. If the storage system had to wait for replicas to acknowledge a write before completing it, network interruptions or node failures could cause the operation to fail. Dynamo chose to prioritize write availability and allow replicas to diverge temporarily—a trade-off in replica consistency, not constraint consistency in the ACID sense.

The paper noted that forcing workloads that only need primary-key access into a relational database is not just inefficient; it limits horizontal scalability and availability.

Before Dynamo, AWS had already made two early forays into managed storage: S3 proved the massive demand for cloud object storage but was not built for low-latency, item-level reads and writes; SimpleDB offered query capabilities but hit a hard 10 GB capacity ceiling per Domain (its unit of data collection). The Dynamo paper was written to fill this exact gap: key-value access, horizontal scalability, and controlled latency.

To achieve this, the paper established an Always Writeable design goal: when some nodes are unreachable, other available nodes accept the write and leave version conflicts to be resolved later. This reflects a system-level priority to keep write operations available—not a guarantee that every individual replica node can accept writes under any failure condition.

Conflict resolution is pushed to read time. Using Vector Clocks to detect diverging versions of an object, the system hands conflicts back to the application layer for semantic merging (such as combining two diverged shopping carts from different devices) or falls back to Last-Write-Wins (LWW). The result is eventual consistency.

Four core mechanisms work together to make this design work:

DynamoDB in 2012: From Self-Hosted Software to Fully Managed Service

Why did AWS launch DynamoDB in 2012 after building Dynamo in 2007? One major reason: internal engineers did not want to operate Dynamo themselves.

As Amazon CTO Werner Vogels looked back in his January 18, 2012 announcement post, Dynamo was still “a piece of software that needed to be installed and operated,” and internal teams voted with their feet for the fully managed experience of S3 and SimpleDB—nobody wanted to spend time running underlying storage infrastructure unless they had to.

AWS drew a clear lesson: developers wanted a Service, not Software. (Community rumors occasionally claim DynamoDB was born out of a major S3 outage, but both the paper and the launch post make clear that the real drivers were shopping-cart availability targets and the demand for fully managed operations.)

DynamoDB kept the spirit of distributed partitioning while making key adjustments in the product implementation:

Design Dimension2007 Dynamo Paper2012 DynamoDB Service
Consistency GuaranteesEventual only; conflicts resolved by the applicationPer-read choice between Eventual and Strongly Consistent
Conflict DetectionExposes Vector Clocks to the clientResolved server-side; version clocks hidden from the API
Storage HardwareCommodity spinning disks (HDD)Solid-state drives (SSD) across the fleet
Write Indexing—Synchronously updates only the primary key index on write to keep write latency low
Replica ArchitectureTunable N replicas, Sloppy QuorumAutomatic synchronous replication across at least three Availability Zones (AZs) in a Region
Query ModelPure key-value point lookupsSupports range queries via Composite Keys (PK + SK)

At launch, DynamoDB adopted the capacity calculation it still uses today: for the same number of Read Capacity Units (RCUs), eventually consistent reads can serve twice as many requests per second as strongly consistent reads.


2. Physical Storage Architecture: Partitions, Hashing, and Split for Heat

From Partition Key to Physical Partitions

DynamoDB uses the Partition Key (PK) to determine which physical partition stores an item. When an application writes an item, DynamoDB hashes the PK value and places the item into the physical partition corresponding to that numeric hash range.

Each physical partition uses dedicated SSD storage and automatically maintains synchronous replicas across 3 AZs. According to published details from the AWS Database Architecture team, each physical partition has the following design limits:

When a partition’s data volume grows past 10 GB or cumulative load exceeds these limits, DynamoDB automatically splits the partition in two (Partition Split) and divides its hash range.

A newly created On-demand table defaults to supporting throughput equivalent to 4,000 WCUs and 12,000 RCUs—roughly four physical partitions at initial scale. To clear up a common misconception: some community posts claim the single-partition limit was raised to 10,000 WCUs / 30,000 RCUs in 2023, but those numbers come from table-level warm throughput examples in the official docs; the underlying per-partition baseline remains 1,000 / 3,000.

When a table uses a Composite Key—combining a PK and a Sort Key (SK) to identify each item—all items sharing the same PK form an Item Collection.

Items with the same PK are sorted by Sort Key, a storage layout that favors Query operations across a specified SK range. However, sort order does not guarantee that items occupy contiguous SSD addresses, nor can query latency be inferred from sort order alone.

Secondary Indexes provide query paths beyond the primary key, and their key design and maintenance behavior must be evaluated separately:

Hot Partitions and Two Generations of Defense

Because a single physical partition has a hard ceiling of 1,000 WCUs / 3,000 RCUs, heavily skewed data access triggers a Hot Partition bottleneck. Suppose a table uses CountryCode as its PK and 90% of traffic hits TW. Even if the table is provisioned with tens of thousands of RCUs overall, requests concentrated on that single partition will still be throttled.

DynamoDB has developed two generations of defenses against hot partitions:

  1. First generation (design-time defense): Engineers address hot keys in the data model by choosing high-cardinality PKs (such as UUIDs or composite keys) or implementing Write Sharding in the application layer (appending a random suffix like user#1001.0 through user#1001.9 to a hot PK).
  2. Second generation (server-side defense):
    • Adaptive Capacity: Enabled by default on all tables since 2018, it dynamically borrows unused partition capacity to absorb traffic bursts on hot partitions, preventing a single hot spot from dragging down overall availability.
    • Split for Heat: An internal mechanism released in 2023. When the system detects sustained heat on a physical partition, it automatically splits that partition along a Sort Key boundary into two physical partitions, distributing the Item Collection’s traffic across two independent sets of hardware.
 +-----------------------------------------------------+
 | Overheated Partition (> 1000 WCU)                   |
 | +-------------------------------------------------+ |
 | | PK: tenant#42 | SK: 2026-01-01 ... 2026-12-31   | |
 | +-------------------------------------------------+ |
 +-----------------------------------------------------+
                            |
                    Split by Sort Key
                            v
 +-----------------------------------------------------+
 | Partition A (SK: 01 to 06)                          |
 | +-------------------------------------------------+ |
 | | PK: tenant#42 | SK: 2026-01-01 ... 2026-06-30   | |
 | +-------------------------------------------------+ |
 | Partition B (SK: 07 to 12)                          |
 | +-------------------------------------------------+ |
 | | PK: tenant#42 | SK: 2026-07-01 ... 2026-12-31   | |
 | +-------------------------------------------------+ |
 +-----------------------------------------------------+

Whether Split for Heat can break up a hot spot on the same PK depends on whether the items have distinct Sort Keys. If traffic is concentrated entirely on a single PK with no SK (or on the exact same item), the system has no available split boundary to spread traffic across partitions. In that case, you still need write sharding or caching in the application layer.


3. Read/Write Modes and the Capacity Billing Model

Trade-offs Across Read Consistency, Caching, and Transactions

Eventual consistency and strong consistency determine whether a read sees the latest write; DAX accelerates reads with a cache; transactions coordinate reads and writes across multiple items. They are not four sequential rungs on a single consistency ladder.

The table below compares single-item capacity consumption, using up to 4 KB as the baseline for reads and up to 1 KB as the baseline for writes.

Operation or ServiceCapacity Cost (Single Item)Latency BaselineScope and Limitations
Eventually Consistent Read (Eventual)0.5 read unitsSingle-digit msDefault read mode for base tables, LSIs, and GSIs
Strongly Consistent Read (Strong)1 read unitSingle-digit msSupported on base tables and LSIs; not supported on GSIs
DAX In-Memory Cache0 database read units on cache hitMicrosecondsAccelerates eventually consistent reads; cache cluster billed separately
Transactions2 read units per read; 2 write units per writeSingle-digit msUp to 100 items and 4 MB total within a single Region; not supported with MRSC

Provisioned mode expresses per-second throughput in RCUs and WCUs; On-demand mode bills in Read Request Units (RRUs) and Write Request Units (WRUs). Both calculate consumption from item size and operation type.

Capacity billing is metered in units of 4 KB for reads and 1 KB for writes, rounding any partial unit up to a full one. Reading a 9 KB item, for instance, counts as three 4 KB units (ceil below denotes rounding up):

Break-Even Math: Provisioned vs. On-Demand

DynamoDB offers two billing modes:

  1. Provisioned mode: Fixed allocation of WCUs and RCUs (us-east-1 pricing is $0.00065 per WCU-hour and $0.00013 per RCU-hour), which can be paired with Auto Scaling.
  2. On-demand mode: Pay per actual request. After AWS cut On-demand prices by 50% on November 1, 2024, current rates are $0.625 per million writes and $0.125 per million reads.

Starting with write costs: if 1 WCU runs at full capacity for 1 hour (1 write per second, totaling 3,600 writes of 1 KB), that equates to roughly $0.18 per million writes. Compared against On-demand at $0.625 per million writes:

Cost Ratio=$0.625$0.1805≈3.46×\text{Cost Ratio} = \frac{\$0.625}{\$0.1805} \approx 3.46\times

In other words, at full utilization, On-demand costs roughly 3.5x as much as Provisioned mode. Provisioned capacity must be paid for even when underutilized, whereas On-demand charges strictly for actual requests. As a result, write costs between the two modes break even when average utilization sits around 29% (1 / 3.46) of provisioned capacity.

If a workload’s average utilization is below 29% (for example, sharp traffic spikes with zero overnight traffic), On-demand is cheaper and eliminates capacity-scheduling risk. If load is steady and long-term utilization exceeds 30%, using Provisioned mode with Auto Scaling or Reserved Capacity saves substantial spend.

For major marketing campaigns, AWS introduced Warm Throughput in 2024, allowing engineers to specify expected throughput 48 to 72 hours before an event so backend partitions pre-split—eliminating the tedious manual process of dialing capacity up to pre-warm a table and dialing it back down afterward.


4. Advanced Architecture: Streams, Global Tables, and the Single-Table Debate

Streams and Event-Driven Architectures

DynamoDB Streams records data modifications in order and in near real time, retaining records for 24 hours. Four view types record the primary key (KEYS_ONLY), the item after modification (NEW_IMAGE), the item before modification (OLD_IMAGE), or both before and after images (NEW_AND_OLD_IMAGES).

Streams is commonly paired with AWS Lambda to build event-driven architectures. When an order status updates to SHIPPED, for example, Streams records the change; the Lambda service reads the record and invokes a function to send notifications, sync a data warehouse, or update statistics. Streams provides the change log, while downstream consumers execute the business logic.

Streams can also drive cross-table projections: updating a second table from changes to the primary table so the second table is dedicated to serving a specific query. If a 24-hour log replay window is too short, enabling Kinesis Data Streams integration extends retention up to 365 days.

Global Tables: From Asynchronous LWW to MRSC in 2025

Multi-Region replication architecture has gone through three major evolutionary stages:

  1. 2017 (v1): First-generation Global Tables, supporting multi-Region active-active writes backed by asynchronous replication.
  2. 2019 (v2): Moved to a replica-group architecture where cross-Region asynchronous replication resolves conflicts by timestamp using Last-Write-Wins (LWW). The upside is low write latency (each Region acknowledges locally), but during a regional disaster, un-replicated writes from the last few seconds may be lost. Recovery Point Objective (RPO) measures how long a window of data loss is tolerable during a failure; here RPO > 0 means zero data loss is not guaranteed.
  3. June 2025 GA (MRSC): Multi-Region Strong Consistency (MRSC). Write requests must be synchronously replicated and acknowledged by remote Regions before completing, delivering Zero RPO and cross-Region strongly consistent reads.
 +-----------------------------------------------------+
 | Multi-Region Replication Evolution                  |
 |                                                     |
 | MREC: Multi-Region Eventual Consistency             |
 | +-------------------------------------------------+ |
 | | Region A (Client)            Region B (Replica) | |
 | | 1. Write OK                                     | |
 | |    |-- Async Replication ------> 2. Sync OK     | |
 | | (Low Latency, LWW, Risk: RPO > 0)               | |
 | +-------------------------------------------------+ |
 |                                                     |
 | MRSC: Multi-Region Strong Consistency (2025 GA)     |
 | +-------------------------------------------------+ |
 | | Region A (Client)            Region B (Replica) | |
 | | 1. Write Request                                | |
 | |    |-- Sync Replication -------> 2. Receive     | |
 | |    |<-- Ack from Region B ------                | |
 | | 3. Write Confirmed                              | |
 | | (Zero RPO, Sync Latency, Retry Conflict)        | |
 | +-------------------------------------------------+ |
 +-----------------------------------------------------+

AWS now presents the two modes side by side as MREC (asynchronous LWW) and MRSC (synchronous strong consistency). From the 2007 paper prioritizing write availability to 2025’s cross-Region strong consistency, DynamoDB lets users choose the replication model that fits their requirements.

Choosing between them means weighing write latency against data-loss risk:

Zero RPO means fault recovery will not lose acknowledged writes; it does not mean business operations like balance deductions or inventory deductions are automatically correct. Applications still need conditional updates and must handle concurrent writes. Furthermore, MRSC does not support DynamoDB transaction APIs, so it cannot be used for multi-item ACID transactions.

A Pragmatic Look at Single-Table Design

Championed by Rick Houlihan at re:Invent, Single-Table Design once swept the community by advocating that all data entities across an entire system be consolidated into a single table.

The approach makes different entity types share the PK and SK attributes while encoding the entity type in the value itself, such as PK=ORG#123 and SK=USER#456. This is known as PK/SK Overloading. Combined with careful GSI key design, this approach lets an application fetch related records that are needed together in a single Query.

In 2020, Alex DeBrie published a systematic analysis dissecting Single-Table Design while also pointing out its cost: once business query patterns change, refactoring a single-table schema is far more expensive than refactoring multiple tables. Evaluating whether to adopt Single-Table Design comes down to access patterns and how frequently requirements change:


5. DevOps in Practice: Architecture Selection, Observability, and Cost Control

Architecture Selection: When Should You Use DynamoDB?

When selecting a database, the core question is: Are your data access patterns known and enumerable?

Six Common Billing Traps

When reviewing a DynamoDB bill, pay close attention to these six areas:

  1. Item-size rounding waste: Reads round up by 4 KB and writes by 1 KB. Avoid item sizes that barely cross a boundary: a standard 1.1 KB write consumes 2 write units, and a strongly consistent 4.1 KB read consumes 2 read units.
  2. Strong consistency and transaction overhead: Strongly consistent reads consume 2x the capacity of eventually consistent reads; transactional reads consume 2x standard strongly consistent reads, and transactional writes consume 2x standard writes. Keep the comparison baseline clear when estimating budgets.
  3. Long-term high utilization: Stable workloads with long-term average utilization above 30% should switch from On-demand back to Provisioned mode or purchase Reserved Capacity to cut costs.
  4. Global Tables cross-Region write multiplier: Every target Region independently charges for replicated write capacity, so a three-Region active-active setup requires planning for a 3x write budget.
  5. Independent GSI capacity billing: When a base-table change updates a GSI, the change also consumes write capacity on the index. Index updates are asynchronous, but the cost still applies—drawing from each GSI’s provisioned WCUs in Provisioned mode or billing per index write request in On-demand mode.
  6. Storage class boundaries: Standard-Infrequent Access (Standard-IA) lowers storage cost by roughly 60% but charges more per read and write; it suits cold archival tables where data accumulates over long periods and is rarely read after being written.

Operational Monitoring and Takeaways

In CloudWatch, monitor these key metrics:

For local development, pair DynamoDB Local (Docker container) for testing with NoSQL Workbench for visual data modeling and access-pattern validation.

Common DynamoDB operational issues can be understood directly from its underlying mechanics: a GSI cannot serve strongly consistent reads because its replication is asynchronous; a table with ample aggregate capacity can still suffer throttling when requests concentrate on a single partition and exceed its throughput ceiling.

Transactions coordinate reads and writes across multiple items within a single Region so operations succeed or fail together, while increasing capacity consumption; MRSC’s cross-Region strong consistency does not replace that guarantee. Selecting the right architecture and estimating costs requires weighing access distribution, consistency requirements, and transaction scope together.