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:
- Consistent Hashing and virtual nodes: Distribute data and load across nodes.
- Sloppy Quorum and Hinted Handoff: When some nodes are down, other nodes temporarily accept writes on their behalf and hand the data back later.
- Merkle Trees: Minimize the amount of data transferred when comparing replicas in the background to repair divergence (Anti-Entropy).
- Gossip protocol: Lets nodes exchange state with each other and detect whether peers are operating normally.
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 Dimension | 2007 Dynamo Paper | 2012 DynamoDB Service |
|---|---|---|
| Consistency Guarantees | Eventual only; conflicts resolved by the application | Per-read choice between Eventual and Strongly Consistent |
| Conflict Detection | Exposes Vector Clocks to the client | Resolved server-side; version clocks hidden from the API |
| Storage Hardware | Commodity 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 Architecture | Tunable N replicas, Sloppy Quorum | Automatic synchronous replication across at least three Availability Zones (AZs) in a Region |
| Query Model | Pure key-value point lookups | Supports 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:
- 1,000 WCUs (Write Capacity Units; 1 WCU supports 1 standard write per second for an item up to 1 KB)
- 3,000 RCUs (Read Capacity Units; 1 RCU supports 1 strongly consistent read per second for an item up to 4 KB)
- Approximately 10 GB of storage per partition
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:
- Global Secondary Index (GSI): Can choose a PK and SK different from the base table’s, organizing data around another query pattern. GSI storage and capacity are managed independently, and base-table changes update the index asynchronously.
- Local Secondary Index (LSI): Shares the same PK as the base table and therefore must share the exact same physical partition as the base table. This locks the total size of a single Item Collection to a hard 10 GB ceiling (it cannot split automatically across partitions)—a common pitfall in production architecture design.
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:
- 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.0throughuser#1001.9to a hot PK). - 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 Service | Capacity Cost (Single Item) | Latency Baseline | Scope and Limitations |
|---|---|---|---|
| Eventually Consistent Read (Eventual) | 0.5 read units | Single-digit ms | Default read mode for base tables, LSIs, and GSIs |
| Strongly Consistent Read (Strong) | 1 read unit | Single-digit ms | Supported on base tables and LSIs; not supported on GSIs |
| DAX In-Memory Cache | 0 database read units on cache hit | Microseconds | Accelerates eventually consistent reads; cache cluster billed separately |
| Transactions | 2 read units per read; 2 write units per write | Single-digit ms | Up to 100 items and 4 MB total within a single Region; not supported with MRSC |
- Eventually Consistent Read (default): Reading an item up to 4 KB consumes 0.5 read units. For a few hundred milliseconds to a second after a write is acknowledged, a read may return a stale value.
- Strongly Consistent Read: Reading an item up to 4 KB consumes 1 read unit, twice the cost of an eventually consistent read, and is guaranteed to return the most recent successfully acknowledged write. Note that GSIs do not support strongly consistent reads at all: passing
ConsistentRead=trueto the API immediately throws aValidationException, because a GSI is an independent replica updated asynchronously. - DAX (DynamoDB Accelerator): A managed in-memory cache cluster that lowers read latency to microseconds, though DAX only provides eventual consistency; strongly consistent requests automatically bypass the cache and hit the database directly.
- Transactions:
TransactWriteItemsandTransactGetItemsprovide ACID transactions across multiple items within the same account and Region, capped at 100 items and 4 MB in total. Because each item is read or written once during the prepare phase and once during the commit phase, transactional reads consume 2x the capacity of standard strongly consistent reads, and transactional writes consume 2x the capacity of standard writes.
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):
- Eventual mode:
ceil(9 / 4) * 0.5 = 1.5read units - Strong mode:
ceil(9 / 4) * 1.0 = 3.0read units
Break-Even Math: Provisioned vs. On-Demand
DynamoDB offers two billing modes:
- Provisioned mode: Fixed allocation of WCUs and RCUs (
us-east-1pricing is $0.00065 per WCU-hour and $0.00013 per RCU-hour), which can be paired with Auto Scaling. - 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:
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:
- 2017 (v1): First-generation Global Tables, supporting multi-Region active-active writes backed by asynchronous replication.
- 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.
- 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:
- Pick MREC if latency hurts most: Read-heavy workloads that demand ultra-low global latency and can tolerate minor data loss during a regional failure.
- Pick MRSC if data loss hurts most: Workloads that must read the latest data across Regions and cannot lose any acknowledged write during a failover. The trade-off is higher latency—since writes must wait for remote Region acknowledgment—and retryable conflict errors when concurrent writes target the same item.
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:
- Good fit: Systems with well-known access patterns, fixed schemas, and strict latency and scale requirements (such as game saves, shopping carts, and IoT telemetry).
- Poor fit: Startup projects still exploring product requirements, businesses with shifting reporting queries, or naturally relational data—where a multi-table design or Amazon RDS avoids unnecessary modeling and refactoring overhead.
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?
- Known and fixed access patterns (exact point lookups or range queries by primary key) DynamoDB (delivers single-digit millisecond latency and horizontal scalability).
- Shifting or unknown access patterns (requiring ad-hoc SQL, multi-table JOINs, foreign key constraints, and complex reporting) Amazon RDS / Aurora.
- Fully serverless architectures (Lambda + API Gateway) or workloads requiring multi-Region active-active replication: DynamoDB reduces the operational burden of self-managing databases and replication pipelines.
Six Common Billing Traps
When reviewing a DynamoDB bill, pay close attention to these six areas:
- 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.
- 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.
- 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.
- 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.
- 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.
- 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:
ThrottledRequests,ReadThrottleEvents,WriteThrottleEvents: Monitor whether partitions or tables are being throttled.ConsumedReadCapacityUnitsandConsumedWriteCapacityUnits: In Provisioned mode, compare these againstProvisionedReadCapacityUnitsandProvisionedWriteCapacityUnitsto observe overall capacity utilization.SuccessfulRequestLatency: Track the millisecond latency baseline for point lookups and queries.
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.