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 DynamoDB over a relational database, and the workloads where it's the wrong fit.

Beginner5 min read

DynamoDB Data Types

DynamoDB data types explained — the scalar (S, N, B, BOOL, NULL), document (M, L) and set (SS, NS, BS) types, how they appear in DynamoDB-JSON, and how each is sized.

Beginner3 min read

DynamoDB JSON & Marshalling

DynamoDB JSON and marshalling — why DynamoDB wraps every value in a type descriptor like {"S":"..."}, how it 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, why the cap exists, and how to model around unbounded item growth.

DynamoDB Item-Based Actions: GetItem, PutItem, UpdateItem, DeleteItem

DynamoDB item-based actions — GetItem, PutItem, UpdateItem and DeleteItem — the four single-item operations, how each addresses an item by its full primary key, and how they differ from Query and Scan.

Beginner5 min read

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.

Beginner8 min read

DynamoDB Composite Primary Key

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 Consistent vs Eventually Consistent Reads

DynamoDB strongly consistent vs eventually consistent reads — what each guarantees, why eventual reads can return stale data, the 2× RCU cost of ConsistentRead, and which indexes support strong reads.

Data Modeling

Single-Table Design in DynamoDB

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 — why one table with overloaded keys beats a table-per-entity, with a concrete order/customer example and the GSI overloading pattern.

Intermediate4 min read

How to Model Data in DynamoDB

How to model data in DynamoDB the access-pattern-first way — a step-by-step walkthrough that turns a multiplayer leaderboard's queries into partition and sort keys.

Intermediate8 min read

When NOT to Use Single-Table Design in DynamoDB

When NOT to use single-table design in DynamoDB — the workloads where multiple tables win (heavy analytics, simple CRUD, independent scaling), with concrete examples.

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 that holds global state like feature flags or config, why you fetch it with GetItem, and how to update it without races.

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

How to model one-to-many relationships in DynamoDB so a parent and all its children come back in a single Query — worked through a SaaS workspace→projects schema.

Many-to-Many Relationships in DynamoDB

How to model many-to-many relationships in DynamoDB with an adjacency-list pattern — students ↔ courses, duplicated edge items, and a GSI to query both directions.

The DynamoDB Adjacency List Pattern

The DynamoDB adjacency list pattern — model a social follow graph as edge items in one table, then traverse both directions of the relationship with a single 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

How to maintain a DynamoDB reference count — a denormalized tally like a post's like-count — with a single transaction that stays correct under concurrency.

Querying & Sorting

Query vs Scan in DynamoDB

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

When to use Query vs Scan in DynamoDB, why Scan is almost never what you want, and how to model your keys so Query covers your access patterns.

Paginate DynamoDB results correctly with LastEvaluatedKey and ExclusiveStartKey, why Limit isn't a page size, and how to expose a stateless cursor to clients.

Pagination in DynamoDB

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

DynamoDB sort key strategies — design sortable sort keys for range queries, ordering, and multiple access patterns in one item collection, with a worked audit-log example.

Intermediate8 min read

How to Query DynamoDB in Descending Order

How to query DynamoDB in descending order with ScanIndexForward=false — newest-first results, why sort happens on the sort key, and how to page backward efficiently.

Beginner5 min read

Sorting DynamoDB on a Changing (Mutable) Attribute

Sorting DynamoDB on a changing attribute — why you can't update a key attribute in place, the delete-and-recreate pattern, and using a GSI so the volatile value lives off the base-table key.

Zero-Padding Sort Keys in DynamoDB

DynamoDB zero-padding sort keys — why "10" sorts before "2" in a string sort key, and how fixed-width zero-padded numbers make string 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.

DynamoDB secondary indexes — GSI vs LSI, sparse indexes, key overloading, GSI eventual consistency, and why a GSI can throttle your base table writes.

0 of 7 readQuiz

GSI vs LSI in DynamoDB

Beginner3 min read

DynamoDB Index Projections: KEYS_ONLY, INCLUDE & ALL

DynamoDB index projections — KEYS_ONLY, INCLUDE, and ALL — what each copies into a GSI/LSI, the storage and write-cost tradeoff, and why a missing attribute forces a base-table fetch.

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 — store many entity types under generic PK/SK names, encode the type in the key value, and serve every access pattern from one table.

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 GSI throttles base-table writes in DynamoDB

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

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

How DynamoDB condition expressions enforce invariants like "no overdraft" inside a single write, why they replace SELECT-then-UPDATE, and how to write them.

DynamoDB Update Expressions

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 — cut payload and item size. What they do (and don't) save on read cost, with a worked example.

Expression Attribute Names and Values in DynamoDB

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: BatchGetItem & BatchWriteItem

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

0 of 7 readQuiz

DynamoDB BatchGetItem and BatchWriteItem — reading and writing up to 25/100 items per round trip, why batches aren't transactions, and how to handle unprocessed items.

DynamoDB ReturnValues: Get the Old or New Item From a Write

DynamoDB ReturnValues — how to get the old or new item back from PutItem, UpdateItem and DeleteItem without a second read, the five options, and when each saves a round trip.

Intermediate3 min read

DynamoDB Atomic Counters

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

Enforcing uniqueness on multiple attributes in DynamoDB

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.

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

DynamoDB Hot Partitions

PartiQL & SQL

DynamoDB PartiQL vs SQL: What's Different (and What Breaks)

PartiQL and SQL on DynamoDB — what PartiQL is, what it can't 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 isn't — no JOIN, GROUP BY, subqueries, or aggregates. Here's what's different, what breaks, and how DynoTable's SQL Workbench runs the queries PartiQL can't.

Beginner7 min read

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.

Beginner2 min read

SQL for DynamoDB: What Works, What Doesn't, and the Workbench

Can you query DynamoDB with SQL? PartiQL is SQL-flavored but limited — no JOIN, GROUP BY, or aggregates. See what works, what doesn't, and how DynoTable runs real SQL.

Beginner7 min read

DynamoDB JOIN: How to Join Tables (and Why You Usually Can't)

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.

Intermediate9 min read

DynamoDB GROUP BY: How to Aggregate Without a GROUP BY Clause

DynamoDB and PartiQL have no GROUP BY or COUNT/SUM/AVG. Learn the aggregation patterns (atomic counters, Streams + Lambda rollups, app-side grouping) and how DynoTable runs GROUP BY directly.

Intermediate9 min read

How to COUNT, SUM and Aggregate in DynamoDB

How to count items, SUM and aggregate in DynamoDB — what Select=COUNT does, what it can't, and how DynoTable's SQL Workbench runs COUNT/SUM/AVG like SQL.

Beginner8 min read

Tooling

Running DynamoDB Local with Docker

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

0 of 8 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.

Beginner2 min read

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

An honest 2026 roundup of DynamoDB GUI clients — NoSQL Workbench, Dynobase, TablePlus/DataGrip, dynamodb-admin/DynamoIt, and DynoTable — with what each is actually good at.

Beginner9 min read

How to View, Browse and Edit DynamoDB Data

How to view, browse, filter and edit DynamoDB data — scan or query a table, inline-edit items, and run queries — mapped 1:1 to the operations DynoTable's GUI runs for you.

How to Copy a DynamoDB Table to Another Account or Region

Copy or migrate a DynamoDB table to another account or region — scan+write, S3 export/import, AWS Backup, and global tables — with the throughput and consistency gotchas.

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

How to export a DynamoDB table to CSV or Excel — AWS CLI scan, S3 export, a script, or one-click export in DynoTable — and why nested attributes and DynamoDB JSON break the naive approaches.

Beginner10 min read

DynamoDB MCP server: connect Claude Code, Cursor & Codex safely

How to give an AI agent — Claude Code, Cursor, Codex — live access to your DynamoDB tables through an MCP server, and how to do it without handing the agent your AWS credentials or direct write access. The safe, reviewed-staging way vs. the servers that write straight to your tables.

ExtendDB: Run the DynamoDB API on Your Own Database

ExtendDB is AWS's open-source, DynamoDB-wire-protocol-compatible adapter (Rust) backed by pluggable storage like PostgreSQL — run the DynamoDB API on your own database, then browse it in DynoTable.

Operations & Cost

DynamoDB transactions with TransactWriteItems — grouping writes into one all-or-nothing operation, the 100-item and 4 MB limits, doubled capacity cost, and condition-based conflict handling.

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

0 of 7 readQuiz

DynamoDB Transactions

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

DynamoDB Streams

DynamoDB TTL — auto-expiring items with a Unix-epoch timestamp attribute, the up-to-48-hour deletion window, why TTL is free, and how it pairs with Streams for archiving.

DynamoDB TTL

Intermediate4 min read

DynamoDB On-Demand vs Provisioned Capacity

DynamoDB On-Demand vs Provisioned capacity — pay-per-request vs reserved throughput, when each is cheaper, auto-scaling, and how spiky audit-log traffic picks the mode.

DynamoDB Global Tables — multi-region active-active replication, last-writer-wins conflict resolution, eventual cross-region consistency, and the 99.999% availability SLA.

DynamoDB Global Tables

DynamoDB Backup & Point-in-Time Recovery

DynamoDB backup and point-in-time recovery — on-demand backups vs continuous PITR, the configurable 1-to-35-day window, per-second restore granularity, and restoring to a new table.

Internals

How DynamoDB Partition Keys Work

DynamoDB internals — how partition keys, adaptive capacity, GSI storage, physical partitions, storage, 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

DynamoDB adaptive capacity and burst capacity explained — how DynamoDB absorbs spikes and boosts hot partitions automatically, and where it still can't save you.