How DynamoDB Request Routing Works
Every read or write you send reaches a fleet of request routers first, and the router decides which partition, and which copy of it, serves the request.
How does DynamoDB request routing work?
A request router authenticates your request, hashes the partition key, looks up which partition owns that hash in a cached partition map, and forwards the request to one of that partition's three replicas.
Per the 2022 USENIX ATC paper, latency stays flat as a table grows from megabytes to hundreds of terabytes.
- The router owns none of your data. It authenticates the request and finds where the data lives, using a partition map it caches from DynamoDB's metadata service.
- The partition key picks the partition. For a large or busy item collection that has split, the sort key also decides which slice holds the item.
- The leader takes writes and strong reads. Each partition has three replicas in different AZs; any replica can serve an eventually consistent read.
- Bad keys defeat the design. A low-cardinality or "hot" partition key funnels traffic to one partition however well the router does its job.
Start with the problem routing solves
Coming from SQL, you picture a query planner: it reads statistics, picks an index, maybe scans. The cost scales with how much data it touches.
That model doesn't fit a key-value store that has to answer in single-digit milliseconds at any size.
DynamoDB makes a single-item lookup a direct address. The partition key is the input to a hash, and a partition-map lookup turns that hash into where the data physically lives, so there are no statistics to read and no plan to choose.
That's the trade you accept when you move off relational thinking: you give up ad-hoc query flexibility, and lookups by key stay fast however big the table gets.
Meet the request router
When a request arrives, it doesn't go straight to storage. It hits a request router, a horizontally scaled fleet that fronts the whole service. (The USENIX ATC '22 DynamoDB paper describes this request-router fleet.)
Per that paper, the router does three things:
- Authenticates and authorizes the request against IAM, caching the results.
- Finds the partition: it hashes the partition key and looks up the owning partition in its partition-map cache, refreshed from the metadata service.
- Forwards the request to a storage node holding a replica of that partition.
If the map is stale because a partition moved or split, the storage node it contacted answers with an error or the new membership, and the router looks the partition up again.
Follow one read through the router
Take a telemetry table for a drone fleet. Items are keyed by DroneId (partition
key) and ReadingTs (sort key), with attributes like BatteryPct and AltitudeM.
You ask for one drone's readings from June 23:
PK = "DRONE#A19F"
SK begins_with "2026-06-23"
The router hashes DRONE#A19F, finds the partition that owns that hash, and forwards
the Query to one of its replicas. Without ConsistentRead, any replica can answer;
with ConsistentRead: true, the leader does.
The hash points at the partitions that hold one item collection, so adding drones, and the partitions they need, doesn't slow this lookup down.
Where the request lands
A partition is a unit of storage and throughput with fixed per-partition limits, and DynamoDB splits it as it grows or runs hot. Physical partitions covers the limits and the splits, including when an LSI or a monotonic sort key blocks one.
Each partition is a group of three replicas in three Availability Zones with one elected leader.
The leader takes every write and every strongly consistent read; any replica, leader included, can serve an eventually consistent read at half the cost. Storage internals covers the write quorum and the read table.
To ask for the leader, pass ConsistentRead: true on GetItem, Query or Scan. It works
on tables and LSIs; a GSI rejects it with a ValidationException.
Where throttling happens
The router is also where a request can be turned away. Per the ATC '22 paper, each router keeps local token buckets for admission control and refills them from a global admission control service every few seconds.
When a request is throttled, you get a ProvisionedThroughputExceededException (or a ThrottlingException) whose ThrottlingReasons field names the cause.
The AWS SDKs retry it automatically with exponential backoff; if retries keep failing, reduce the request rate. Throttling maps each reason to its fix.
Name the footgun: a hot partition key
Say you key that telemetry by Region instead of DroneId. Every drone in
us-east-1 now shares one partition key, so the whole fleet funnels into one item
collection. The router is doing its job; your key is the problem.
The fix is a higher-cardinality partition key, or a write-sharding suffix when one key must stay hot. To find which key is hot, turn on CloudWatch Contributor Insights for the table and each GSI. Hot partitions covers both.
When you build a key condition in the
Expression Builder, the value you compare
PK to is the value the router hashes.
How this ties back to your access patterns
Request routing is what makes the single-table design rules non-negotiable: you model around the partition key because the partition key is the address.
It's also why a Query beats a Scan: a Query reads one item collection (usually one partition, more if the collection has split), while a Scan reads every partition.
A global secondary index has its own partitions and its own routing: a GSI is routed by its own partition key, independent of the base table's, which is why a GSI can be hot even when the table isn't.
The fix is the same: a high-cardinality GSI partition key. A local secondary index shares the base table's partitions.
Next steps
Design keys that route to many partitions, not one. Sketch the PK = … condition in the
Expression Builder, then download DynoTable
to run those queries against your own tables and see which items each key condition returns.