# accesspatterns.dev

> Learn DynamoDB access patterns by running real queries in your browser and seeing what each one costs. A real DynamoDB-compatible engine, backed by SQLite, runs in the tab.

The in-browser engine is a preview build. It has not been run against the conformance suite that backs dynoxide's native build, so treat its behaviour as illustrative rather than authoritative.

## Lessons

- [Items, not rows](https://accesspatterns.dev/lessons/items-and-attributes): Two items in one table can have completely different attributes.
- [The key is the address](https://accesspatterns.dev/lessons/primary-keys): GetItem needs the whole primary key: partition and sort.
- [One query, a whole collection](https://accesspatterns.dev/lessons/query-a-partition): Items that share a partition key are read together in one Query.
- [The sort key is a query language](https://accesspatterns.dev/lessons/sort-key-conditions): Conditions on the sort key narrow a Query before it reads, for free.
- [A filter is not an index](https://accesspatterns.dev/lessons/the-filter-trap): A FilterExpression runs after the read: you pay for everything scanned.
- [Read the latest first](https://accesspatterns.dev/lessons/latest-first): A sorted timestamp makes 'the most recent' a direction, not a sort in your code.
- [Read a page, keep the bookmark](https://accesspatterns.dev/lessons/pagination): Limit caps a page; LastEvaluatedKey is the bookmark you feed back to resume.
- [PutItem replaces](https://accesspatterns.dev/lessons/putitem-replaces): PutItem writes a whole item and overwrites any item with the same key.
- [UpdateItem edits in place](https://accesspatterns.dev/lessons/updateitem-in-place): UpdateItem changes named attributes and can increment a counter atomically.
- [Claim it, or fail](https://accesspatterns.dev/lessons/conditional-writes): A ConditionExpression lets a write happen only if the data still allows it.
- [No silent clobbers](https://accesspatterns.dev/lessons/optimistic-locking): A version check lets an update land only if nobody changed the item since you read it.
- [Model a one-to-many with one partition](https://accesspatterns.dev/lessons/one-to-many): A parent and its children share a partition key, so one Query fetches them together.
- [One key, every level](https://accesspatterns.dev/lessons/hierarchical-keys): A path in the sort key lets one begins_with read any level of a hierarchy.
- [A different key for a different question](https://accesspatterns.dev/lessons/secondary-index): A secondary index re-keys your items so you can Query them on a new axis.
- [Traverse a relationship both ways](https://accesspatterns.dev/lessons/inverted-index): An index that swaps the partition and sort keys reads the same edges from the other side.
- [Absence as a filter](https://accesspatterns.dev/lessons/sparse-index): An item appears in an index only if it has the index's key, so leaving the key off filters it out.
- [Keep the total where you read it](https://accesspatterns.dev/lessons/aggregate-counter): A denormalised count on the parent turns an aggregate into a single GetItem.
- [One index, many questions](https://accesspatterns.dev/lessons/key-overloading): Different entity types share generic index keys, so one index serves several access patterns.
- [An index holds only what you project](https://accesspatterns.dev/lessons/gsi-projection): Projection decides which attributes an index carries, trading storage against an extra read.
- [One table, an application's worth of questions](https://accesspatterns.dev/lessons/single-table-capstone): Generic keys and one overloaded index answer five access patterns with no join and no scan.

## Models

- [URL Shortener](https://accesspatterns.dev/library/url-shortener): A hash-only table keyed by short code, the classic key-value lookup.
- [SaaS Multi-Tenant](https://accesspatterns.dev/library/saas-multi-tenant): Organisations and their members in one table, isolated by partition.
- [Game Leaderboard](https://accesspatterns.dev/library/game-leaderboard): Per-game high scores, ranked with a secondary index on score.
- [Maintainers & Projects](https://accesspatterns.dev/library/maintainers-projects): A many-to-many between people and projects, read from either side.