Learn DynamoDB

When to Use DynamoDB (and When Not To)

DynamoDB fundamentals — data types, item collections, and the composite primary key. The base mechanics everything else in the curriculum builds on.

0 of 9 readQuiz

When to use DynamoDB and when not to. The access-pattern, scale and cost signals that favor it over a relational database, and its wrong-fit workloads.

Beginner9 min read

DynamoDB Data Types: Every Type, with Examples

DynamoDB's ten data types — scalars (S, N, B, BOOL, NULL), documents (M, L) and sets (SS, NS, BS), how they look in DynamoDB-JSON, and which can be a key.

DynamoDB JSON & Marshalling

DynamoDB JSON and marshalling — why every value is wrapped in a type tag, how the format differs from plain JSON, and how to convert between the two.

The DynamoDB Item Size Limit (400 KB)

The DynamoDB 400 KB item size limit — what counts toward it, how attribute names and nesting add up, and how to model around unbounded item growth.

DynamoDB Item-Based Actions

DynamoDB item-based actions — GetItem, PutItem, UpdateItem and DeleteItem each address one item by its full primary key, and differ from Query and Scan.

DynamoDB Item Collections

What a DynamoDB item collection is — every item sharing a partition key — why it's the unit of efficient Query reads, and the limits to watch out for.

DynamoDB Composite Primary Key: Partition + Sort Key Explained

A DynamoDB composite primary key is a partition key plus a sort key — it groups related items together and unlocks range queries a simple key can't do.

DynamoDB Strongly vs Eventually Consistent Reads

DynamoDB strongly consistent vs eventually consistent reads — what each guarantees, the 2× RCU cost of ConsistentRead, and why a GSI is eventual-only.

Data Modeling

DynamoDB Single-Table Design: The Complete Guide

DynamoDB data modeling — single-table design, modeling from access patterns, the type attribute, denormalization, and when one table is the wrong call.

0 of 7 readQuiz

Single-table design in DynamoDB stores every entity in one table behind overloaded key prefixes, so a parent and its children return in one Query.

How to Model Data in DynamoDB

How to model data in DynamoDB access-pattern first. A game leaderboard walkthrough that turns four questions into partition keys, sort keys and a GSI.

When NOT to Use Single-Table Design in DynamoDB

When not to use single-table design in DynamoDB — heavy analytics, plain CRUD over unrelated entities, and entities that scale or fail independently.

The Type Attribute in DynamoDB

The DynamoDB Type attribute — why you stamp an entity type on every item to identify rows, filter a GSI to one entity, and survive future migrations.

Denormalization in DynamoDB

DynamoDB denormalization — why you duplicate data instead of joining, with a blog author-name example, the staleness footgun, and when to embed vs. duplicate.

Singleton Items in DynamoDB

DynamoDB singleton items — one fixed-key row holding global state like feature flags or config, read with GetItem and updated with condition expressions.

Relationships

One-to-Many Relationships in DynamoDB

Modeling relationships in DynamoDB — one-to-many, many-to-many, the adjacency list pattern, composite sort keys, and reference counts, all without joins.

0 of 6 readQuiz

Model one-to-many relationships in DynamoDB by giving the parent and its children one partition key, so a single Query returns the whole collection.

Many-to-Many Relationships in DynamoDB

Model many-to-many relationships in DynamoDB with the adjacency-list pattern — one edge item per link, plus an inverted GSI to read both directions.

The DynamoDB Adjacency List Pattern

The DynamoDB adjacency list pattern — model a follow graph as edge items in one table, then traverse both directions with a single flipped GSI.

Advanced8 min read

Composite Sort Keys in DynamoDB

Composite sort keys in DynamoDB — pack a hierarchy into one delimited sort key so a single Query reads a whole subtree, with a file-system tree example.

DynamoDB Reference Counts

Maintain a DynamoDB reference count — a denormalized tally like a post like-count — with one transaction that stays correct under concurrent writes.

Querying & Sorting

DynamoDB Query vs Scan: Which to Use, and Why (w/ Examples)

Querying and sorting DynamoDB — Query vs Scan, pagination, filter expressions, why Scan is slow, parallel scans, and sort-key strategies including zero-padding.

0 of 10 readQuiz

Query vs Scan in DynamoDB — Query reads one item collection and bills matched items, Scan reads the whole table before any FilterExpression runs.

DynamoDB Pagination: LastEvaluatedKey Explained (w/ Examples)

How DynamoDB pagination works — loop on LastEvaluatedKey and ExclusiveStartKey, why Limit is not a page size, and how to expose a stateless cursor.

DynamoDB Filtering Strategies

DynamoDB filtering strategies compared — partition key, sort key, sparse indexes, and FilterExpression — and which one actually cuts your read bill.

Why a DynamoDB Scan Is Slow and Expensive

Why a DynamoDB Scan is slow and expensive, what it actually bills you for, and how to turn a reflexive Scan into a keyed Query that costs a fraction.

How DynamoDB parallel scans split a full-table read across workers with Segment and TotalSegments, when they help, and the throughput footgun to avoid.

DynamoDB Parallel Scans

DynamoDB Sort Key Strategies: 3 Patterns and When to Use Each

DynamoDB sort key strategies for range reads — design a sort key whose byte order matches your read order, so one Query serves many access patterns.

How to Query DynamoDB in Descending Order

Query DynamoDB in descending order with ScanIndexForward=false — newest-first results, why sorting happens on the sort key, and why reverse reads are free.

Sorting DynamoDB on a Changing Attribute

Sorting DynamoDB on a changing attribute — why a key attribute is immutable, the delete-and-recreate pattern, and moving it to a GSI sort key instead.

Zero-Padding Sort Keys in DynamoDB

Why "10" sorts before "2" in a DynamoDB string sort key, and how fixed-width zero-padding makes lexicographic byte order match numeric order.

Indexes

GSI vs LSI in DynamoDB — the partition-key, consistency, capacity and 10 GB differences, and a simple rule for which secondary index to reach for.

What a global secondary index really costs in DynamoDB: measured GSI write amplification, a GSI vs LSI vs filter decision table, and the limits that bind.

0 of 7 readQuiz

DynamoDB GSI vs LSI

DynamoDB Index Projections

DynamoDB index projections — what KEYS_ONLY, INCLUDE and ALL copy into a GSI or LSI, the write-cost tradeoff, and why a missing attribute costs a read.

DynamoDB sparse indexes let a global secondary index hold only the items that carry its key — the cheapest way to query a small subset of a large table.

DynamoDB Sparse Indexes

Key Overloading in DynamoDB

Key overloading in DynamoDB — put many entity types under generic pk/sk names, encode the type in the value, and slice each one with begins_with.

Why a DynamoDB GSI Is Eventually Consistent

Why a DynamoDB GSI is eventually consistent — the read-right-after-write stale-result gotcha, the propagation mechanism behind it, and how to design around it.

Why a DynamoDB GSI throttles base-table writes

Why an under-provisioned DynamoDB GSI throttles your base-table writes — GSI back-pressure, hot index partitions, the exceptions to watch, and how to fix it.

Expressions

DynamoDB Condition Expressions: The Complete Guide (w/ Examples)

DynamoDB expressions — condition, update, key condition, and projection expressions, plus expression attribute names and values and when you must use them.

0 of 6 readQuiz

DynamoDB condition expressions enforce an invariant inside a single write. How they replace read-then-update, and why a rejected write still costs a WCU.

DynamoDB Update Expressions: SET, REMOVE, ADD, DELETE (w/ Examples)

How DynamoDB update expressions work — SET, ADD, REMOVE, DELETE — and which one to reach for, with a shopping-cart worked example.

DynamoDB Key Condition Expressions

How DynamoDB key condition expressions work — the operators allowed on the sort key, begins_with vs BETWEEN, and why a filter is not a substitute.

DynamoDB Projection Expressions

DynamoDB projection expressions return only the attributes you name. Why they cut payload but not read cost, and what to use instead for real RCU savings.

DynamoDB Expression Attribute Names and Values

How DynamoDB expression attribute names (#name) and values (:value) work, why reserved words like status and size break your query, and how to fix it.

Writes & Operations

DynamoDB Batch Operations

DynamoDB writes and operations — atomic counters, enforcing uniqueness across attributes, zero-downtime migrations, and diagnosing hot partitions.

0 of 8 readQuiz

DynamoDB batch operations — BatchGetItem reads 100 items per call, BatchWriteItem writes 25, why a batch is not a transaction, and how to retry leftovers.

How to Delete Multiple Items in DynamoDB

How to delete multiple items in DynamoDB — BatchWriteItem, TransactWriteItems, PartiQL batches and TTL — plus why there is no DELETE ... WHERE statement.

DynamoDB ReturnValues: Get the Old or New Item

DynamoDB ReturnValues hands back the old or new item from PutItem, UpdateItem or DeleteItem without a second read — the five options and when each helps.

DynamoDB Atomic Counters: How ADD Works, and When It Doesn't

How DynamoDB atomic counters work with an ADD update expression, why they aren't idempotent, and when to reach for a conditional update instead.

DynamoDB Uniqueness on Multiple Attributes

How to enforce a unique constraint on multiple DynamoDB attributes — unique email AND username — with marker items and a condition-guarded TransactWriteItems.

DynamoDB Migrations Without Downtime

DynamoDB migrations without downtime — how to add a new entity type and access pattern to a live table using lazy backfill, online GSIs, and dual-writes.

DynamoDB Hot Partitions: How to Find and Fix Them

A DynamoDB hot partition is when one partition key absorbs a disproportionate share of traffic and throttles — how to spot it and design it out.

PartiQL & SQL

DynamoDB PartiQL vs SQL: What Breaks

PartiQL and SQL on DynamoDB — what PartiQL is, what it cannot do, and how the DynoTable Workbench runs JOIN, GROUP BY and aggregates within DynamoDB's rules.

0 of 7 readQuiz

DynamoDB PartiQL looks like SQL but has no JOIN, GROUP BY, subqueries or aggregates. Every statement maps to one native operation. Here is what breaks.

PartiQL for DynamoDB by Example

PartiQL for DynamoDB by example — SELECT, INSERT, UPDATE, DELETE with SQL-like syntax, plus the gotchas around partition keys and full-table scans.

SQL for DynamoDB and the Limits of PartiQL

Can you query DynamoDB with SQL? PartiQL handles SELECT, INSERT, UPDATE and DELETE by key, but not JOIN, GROUP BY or COUNT(*). Here is what works.

DynamoDB JOIN: How to Join Tables

DynamoDB has no JOIN and PartiQL doesn't add one. Why, the four workarounds devs use, and how DynoTable's SQL Workbench runs a real JOIN.

Intermediate10 min read

DynamoDB GROUP BY: How to Aggregate Instead

DynamoDB and PartiQL have no GROUP BY, COUNT or SUM. The patterns that replace it — atomic counters, Streams + Lambda rollups, and app-side grouping.

Intermediate9 min read

How to COUNT, SUM and Aggregate in DynamoDB

How to COUNT, SUM and aggregate in DynamoDB — what Select=COUNT costs, why there is no native SUM or AVG, and the patterns that give you real totals.

Tooling

How to Run DynamoDB Local with Docker — Complete Guide

DynamoDB tooling — DynamoDB Local, LocalStack, the best GUI clients, viewing and editing data, copying tables, CSV export and MCP servers.

0 of 14 read

Run DynamoDB Local with Docker for offline development and tests — start the container, point the SDK at the local endpoint, and create a table.

How to Connect to DynamoDB Local and LocalStack

How to connect a GUI to DynamoDB Local and LocalStack — endpoint, fake creds, common errors. Browse and query local tables visually with DynoTable.

The Best DynamoDB GUI Clients in 2026

DynamoDB GUI clients compared hands-on for 2026 — NoSQL Workbench, Dynobase, Dynomate, DbVisualizer, DocKit, dynamodb-admin, DynoTable — with dated, verified pricing.

Beginner14 min read

DynamoDB Books Worth Reading in 2026

The two DynamoDB books worth your money in 2026, what each one costs, and exactly which DynamoDB features each was published too early to cover.

How to View, Browse and Edit DynamoDB Data

How to browse, filter and edit DynamoDB data, and which API operation each action runs — Scan, Query, GetItem, PutItem, UpdateItem, DeleteItem.

Copy a DynamoDB Table to Another Account/Region

Copy a DynamoDB table to another account or region — export the data, then restore with scan plus write, S3 export/import, AWS Backup, or global tables.

How to Export a DynamoDB Table to CSV (4 Ways)

How to export a DynamoDB table to CSV — a filtered one-click export in DynoTable, an AWS CLI scan with jq, the managed S3 export, or a script.

Beginner12 min read

Generate TypeScript Types from DynamoDB

DynamoDB stores no item schema, so DescribeTable cannot give you types. Hand-write an interface, use a schema-first library, or infer from real items.

How to Query DynamoDB with AI (Natural Language)

How to query DynamoDB in plain language. The API has no natural-language endpoint, so compare LLM-drafted PartiQL, MCP agents and schema-aware tools.

DynamoDB MCP server: Claude Code, Cursor, Codex

Give an AI agent live access to your DynamoDB tables over MCP — the options for Claude Code, Cursor and Codex, and how to avoid handing over your AWS keys.

DynamoDB MCP for Claude Code

Connect Claude Code to DynamoDB over MCP — the exact claude mcp add command, which scope to register it at, and how to keep your AWS keys out of the agent.

Connect Cursor to DynamoDB over MCP — the .cursor/mcp.json config, project vs global scope, enabling the server, and how to keep AWS keys out of your repo.

DynamoDB MCP for Cursor

Connect OpenAI Codex to DynamoDB over MCP — the ~/.codex/config.toml entry, the mcp_servers snake_case trap, transport choice, and startup timeouts.

DynamoDB MCP for Codex

ExtendDB: Run the DynamoDB API on Your Database

ExtendDB is an open-source AWS adapter that serves the DynamoDB API from a database you run, such as PostgreSQL. Your AWS SDKs work unchanged.

Operations & Cost

DynamoDB Cost Model: Why SQL Can Hide the Bill

DynamoDB operations and cost — transactions, Streams, TTL, on-demand vs provisioned capacity, global tables and backup/PITR, taught on one running SaaS.

0 of 11 readQuiz

Why SQL over DynamoDB can hide the bill — how joins, arbitrary WHERE filters and aggregates compile to Scans, and the RCU math behind Query vs Scan.

Intermediate4 min read

DynamoDB Transactions: The Complete Guide (w/ Examples)

DynamoDB transactions with TransactWriteItems — up to 100 all-or-nothing actions, a 4 MB limit, double write capacity, and how conflicts cancel.

DynamoDB Streams: The Complete Guide (w/ Examples)

DynamoDB Streams — the 24-hour change-data-capture log, the four StreamViewType options, per-item ordered records, and triggering Lambda on item changes.

DynamoDB TTL: The Complete Guide to Expiring Items

DynamoDB TTL auto-deletes items once a Unix-epoch timestamp attribute passes, typically within a few days, and those deletes cost no write capacity.

Intermediate4 min read

DynamoDB On-Demand vs Provisioned Capacity

DynamoDB On-Demand vs Provisioned capacity — pay-per-request against reserved throughput, when each is cheaper, and how traffic shape picks the mode.

How to Set Up DynamoDB Auto Scaling

Set up DynamoDB auto scaling on provisioned capacity — console and CLI steps, picking target utilization and min/max, and the limits that still throttle.

DynamoDB Throttling and How to Fix It

Why DynamoDB throttles — the four documented causes, per-partition limits of 3,000 read and 1,000 write units per second, and the fix for each.

DynamoDB Table Size and Item Count

Get a DynamoDB table size and item count from the free DescribeTable estimate, which lags up to six hours, or an exact count with Scan Select COUNT.

DynamoDB Global Tables: Multi-Region Replication Explained

DynamoDB Global Tables — multi-region active-active replication, last-writer-wins conflicts, the MREC and MRSC consistency modes, and the 99.999% SLA.

DynamoDB Backup and Point-in-Time Recovery: The Complete Guide

DynamoDB backup and point-in-time recovery — on-demand snapshots vs continuous PITR, the 1-to-35-day window, and the settings a restore doesn't bring back.

Internals

How DynamoDB Partition Keys Work

DynamoDB internals — how partition keys, adaptive capacity, GSI storage, physical partitions and request routing work, tracing back to the Dynamo paper.

0 of 8 readQuiz

How DynamoDB partition keys work — the hash that maps a key to a physical partition, why your key choice decides throughput, and how to dodge hot partitions.

DynamoDB Adaptive Capacity: What It Does and What It Cannot

DynamoDB adaptive capacity and burst capacity — how they absorb spikes and boost a hot partition automatically, and the partition ceiling neither can beat.

How a DynamoDB GSI Is Stored Internally

How a DynamoDB GSI is stored — its own partition space, asynchronous replication from the base table, projected attributes only, and isolated capacity.

Advanced8 min read

DynamoDB physical partitions

How DynamoDB physical partitions work — the 10 GB, 3000 RCU and 1000 WCU ceilings, how partitions split, and why a hot key throttles with capacity to spare.

How DynamoDB storage internals work

How DynamoDB storage internals work — partition hashing, the per-partition B-tree for sort-key ranges, and quorum replication across three AZs explained.

How DynamoDB Request Routing Works

How DynamoDB request routing works — the request router hashes your partition key to find the right storage node, and why that fixes per-key latency.

From the Dynamo Paper to DynamoDB

From the 2007 Amazon Dynamo paper to DynamoDB — what the original consistent-hashing, quorum design introduced, and what AWS kept versus quietly replaced.