API Design
The contract a service offers — its shape, its errors, and how it changes without breaking the clients you can't deploy.
15 topics
Resource Modelling & REST
Designing an API as nouns with a small fixed set of verbs, and knowing which parts of REST are dogma you can drop.
core25 minConditional Requests & API Caching
The validators a service emits — ETag, Last-Modified, Cache-Control — and how the same headers give you optimistic concurrency for free.
core20 minRequest Validation & Parsing
Turning untrusted bytes into a typed value at exactly one place in the service, and rejecting everything that doesn't fit.
core20 minAPI Errors Clients Can Act On
Designing an error response as a contract — a stable code the client branches on, a message a human reads, and enough context to fix the request.
core20 minPagination, Filtering & Sorting
Why cursor pagination beats offset for anything that changes, and how filters and sorts turn into an index you have to actually own.
core25 minVersioning & Evolving an API
What actually counts as a breaking change, the three places a version can live, and why most changes shouldn't need one.
core25 minRate Limits & Quotas
Choosing what to limit, what to key it on, and how to tell a client it was limited in a way its retry logic can respect.
core25 minGraphQL When It Earns Its Place
What GraphQL genuinely solves, the four costs it adds on the server, and the shape of team where the trade lands in its favour.
core25 minRPC & End-to-End Typed APIs
When the API is a function call between two halves of one codebase — tRPC, gRPC, server actions — and what you give up by leaving REST.
core20 minWebhooks & Callbacks
Both sides of an outbound HTTP event — signing and retrying the ones you send, verifying and deduplicating the ones you receive.
core25 minAPI Contracts
The agreement between a producer and its consumers about shape, meaning, and change — and the mechanisms that stop it drifting.
core25 minsharedCache Invalidation
Deciding when cached data stops being allowed to answer, which is the half of caching that actually goes wrong.
core25 minsharedCaching Strategies
The read/write patterns behind every cache, and the consistency you trade away for each.
core25 minsharedError Handling
Deciding which failures are expected and handled, which are bugs that should crash loudly, and who finds out either way.
core25 minsharedIdempotency
Making an operation safe to repeat, which is the only way a retry over an unreliable network can ever be correct.
core25 minshared