llms.txt
Compare with other sites' llms.txt files →# System Design Atlas
> Concept modules and worked system design problems, with architecture diagrams and trade-offs.
System Design Atlas is a reading site for system design interviews. Concepts are read in order, designs are ranked by how often they come up in interviews, technology pages say what each system is for, and the coding track draws algorithms as they run. Pages marked (premium) need Lifetime Access; their link leads to a public summary.
## Concepts
- [Foundations](https://systemdesignatlas.dev/docs/01-foundations): Latency versus throughput, percentiles and tail amplification, scaling directions, load balancing, and estimation that ends in a decision.
- [Data Storage](https://systemdesignatlas.dev/docs/02-data-storage): Picking a database from access patterns, how indexes really cost you, replication lag, sharding strategies, and consistent hashing.
- [Consistency and Distributed Systems](https://systemdesignatlas.dev/docs/03-consistency-and-distributed-systems): CAP stated correctly, PACELC, the consistency spectrum, quorums, Raft, idempotency, sagas, and the outbox pattern.
- [Caching](https://systemdesignatlas.dev/docs/04-caching): Cache patterns and eviction, why hit rate dominates latency, invalidation, and the three named failure modes with fixes for each.
- [Async Messaging and Event-Driven Architecture](https://systemdesignatlas.dev/docs/05-async-messaging-and-event-driven): Queues versus pub/sub, Kafka partitions and consumer groups, delivery semantics, retries with jitter, dead letter queues, CQRS and event sourcing.
- [Fan-out, Feeds and Timelines](https://systemdesignatlas.dev/docs/06-fanout-and-feeds): Push versus pull, the read/write cost asymmetry, the celebrity problem, and the hybrid that resolves it. The most reused pattern in the field.
- [APIs and Real-Time Communication](https://systemdesignatlas.dev/docs/07-apis-and-communication): REST, gRPC and GraphQL compared; polling through WebSockets; cursor pagination; API gateways; and four rate limiting algorithms.
- [Reliability and Operations](https://systemdesignatlas.dev/docs/08-reliability-and-operations): Error budgets, failover and split-brain, timeouts and circuit breakers, graceful degradation, observability, and safe schema migration.
- [Specialized Building Blocks](https://systemdesignatlas.dev/docs/09-specialized-building-blocks): Inverted indexes, object storage, batch versus stream processing, Bloom filters, Snowflake IDs, and geospatial indexing.
- [Building with LLMs](https://systemdesignatlas.dev/docs/10-building-with-llms): Fifty terms for building with language models, in the order you meet them: how a model reads text, how you steer it, how it gets tools and knowledge, how you judge it, how it is trained and served, and what it takes to ship. (premium)
- [The Interview Playbook](https://systemdesignatlas.dev/docs/11-interview-playbook): The 45-minute framework phase by phase: minute budgets, clock checkpoints, checklists, weak and strong answers side by side, the sentences that score, what loses points, and the rubric you're graded against. (premium)
## Designs
- [Twitter / Instagram Feed](https://systemdesignatlas.dev/docs/01-twitter-instagram-feed): A home timeline serving 150k reads per second, where one post can reach a hundred million followers.
- [Chat / Slack](https://systemdesignatlas.dev/docs/02-chat-slack): Fifty million concurrent sockets, ordered message delivery, and users who go offline mid-conversation.
- [URL Shortener](https://systemdesignatlas.dev/docs/03-url-shortener): A hundred million links a day and a hundred to one read skew. The classic estimation warm-up.
- [Distributed Rate Limiter](https://systemdesignatlas.dev/docs/04-rate-limiter): One global limit enforced across a fleet of stateless API servers, at a million requests per second.
- [Notification System](https://systemdesignatlas.dev/docs/05-notification-system): Events from many producers, matched to recipients, delivered in-app, by email and by push, without losing any.
- [Search and Typeahead](https://systemdesignatlas.dev/docs/06-search-typeahead): A billion documents, a hundred thousand queries a second, and autocomplete firing on every keystroke.
- [Uber / Delivery Tracking](https://systemdesignatlas.dev/docs/07-uber-delivery-tracking): Five million drivers publishing position every four seconds, matched to riders in real time.
- [Video Streaming](https://systemdesignatlas.dev/docs/08-video-streaming): Upload, transcode and deliver video at twenty-five terabits per second of egress.
- [Web Crawler](https://systemdesignatlas.dev/docs/09-web-crawler): Ten billion pages, ten thousand fetches a second, without hammering any single domain.
- [Payment System](https://systemdesignatlas.dev/docs/10-payment-system): Charges, captures, refunds and payouts across an unreliable external processor, with a ledger that has to balance.
- [Ticketmaster / Booking](https://systemdesignatlas.dev/docs/11-ticketmaster-booking): Fifty thousand people wanting the same hundred best seats in the same second.
- [Dropbox / File Sync](https://systemdesignatlas.dev/docs/12-dropbox-file-sync): Syncing files across devices without re-uploading a two gigabyte file because one paragraph changed.
- [Ad Click Aggregation](https://systemdesignatlas.dev/docs/13-ad-click-aggregation): A million events a second aggregated into dashboards that are fast and billing numbers that are exact.
- [Distributed Cache](https://systemdesignatlas.dev/docs/14-distributed-cache): Building Redis: a hundred nodes holding a terabyte of hot data with sub-millisecond reads.
- [Google Docs](https://systemdesignatlas.dev/docs/15-google-docs-collaborative-editing): Many people typing into one document at once, with no perceptible lag and no lost edits.
- [AI Agent Platform / Lindy](https://systemdesignatlas.dev/docs/16-ai-agent-platform): Businesses build narrow agents that wake on an email, a webhook or a schedule, call a dozen SaaS APIs and wait days for a human to approve, and every run has to finish exactly once. (premium)
- [Researcher–Participant Chat](https://systemdesignatlas.dev/docs/17-researcher-participant-chat): Two strangers, one of them anonymous, allowed to talk only while a study says so, at a scale where the hard part is policy rather than throughput. (premium)
- [AI App Builder / Lovable](https://systemdesignatlas.dev/docs/18-ai-app-builder-lovable): A prompt becomes a running web app in seconds: model-written code, built and served on your machines, that a bad generation must never break. (premium)
- [ChatGPT](https://systemdesignatlas.dev/docs/19-chatgpt): A billion people a week type a message and watch the answer stream back, and every one of those answers occupies a GPU for its whole length. (premium)
- [RL Environment Platform](https://systemdesignatlas.dev/docs/20-rl-environment-platform): Run thousands of isolated, reproducible agent episodes for evaluation and RL training, and hand the trainer a reward it can trust. (premium)
- [ElevenLabs](https://systemdesignatlas.dev/docs/21-elevenlabs): Text in, a cloned or library voice streamed back within a few hundred milliseconds, for millions of developers, billed per character. (premium)
- [Figma](https://systemdesignatlas.dev/docs/22-figma): A browser-based design tool where hundreds of people can be in one file, every drag shows up on everyone's screen within a fraction of a second, and a file with millions of layers still opens. (premium)
- [Online Chess / Chess.com](https://systemdesignatlas.dev/docs/23-online-chess): Two players, one board, a minute each: every move checked and timed by the server, a fair opponent found in seconds, and millions more watching, replaying and solving puzzles at the same time. (premium)
- [Collaborative Whiteboard / Miro](https://systemdesignatlas.dev/docs/24-collaborative-whiteboard): An endless canvas that whole teams scribble on together: sticky notes, shapes, arrows and pen strokes appear on every screen as they're made, and a board that has grown for years still opens in a second. (premium)
## Technologies
- [PostgreSQL](https://systemdesignatlas.dev/docs/01-postgres): The relational default: transactions, joins and constraints on one primary, until scale forces you off it. (premium)
- [Redis](https://systemdesignatlas.dev/docs/02-redis): Sub-millisecond memory with useful data structures: caches, counters, locks, leaderboards and rate limits.
- [Memcached](https://systemdesignatlas.dev/docs/03-memcached): A cache that does nothing but get and set — fewer features than Redis, and that is the argument for it.
- [Cassandra](https://systemdesignatlas.dev/docs/04-cassandra): Masterless, write-optimised storage that scales linearly — as long as every query is known in advance.
- [DynamoDB](https://systemdesignatlas.dev/docs/05-dynamodb): Key-value and document storage with flat latency at any size, as long as you design for the key.
- [Elasticsearch](https://systemdesignatlas.dev/docs/06-elasticsearch): An inverted index with relevance ranking — a derived view of your data, never the source of truth.
- [OLAP stores](https://systemdesignatlas.dev/docs/07-olap): Columnar databases — ClickHouse, Druid, BigQuery — that aggregate billions of rows and cannot do point updates.
- [Kafka](https://systemdesignatlas.dev/docs/08-kafka): A durable, replayable, partitioned log — the backbone of nearly every asynchronous design. (premium)
- [Flink](https://systemdesignatlas.dev/docs/09-flink): Stateful computation over unbounded streams: windows, joins and aggregates that survive a crash.
- [Object storage](https://systemdesignatlas.dev/docs/10-object-storage): S3-style storage for bytes: effectively unlimited, extremely durable, and never in the request path.
- [CDN](https://systemdesignatlas.dev/docs/11-cdn): Caches near the user that cut latency, absorb read spikes, and shift most traffic off your origin.
- [API gateway](https://systemdesignatlas.dev/docs/12-api-gateway): The front door: TLS, routing, auth, rate limits and timeouts, in one place instead of every service.
- [WebSockets](https://systemdesignatlas.dev/docs/13-websockets): Persistent connections for server push — and the stateful tier, routing and reconnect story they drag in.
- [gRPC](https://systemdesignatlas.dev/docs/14-grpc): Typed, binary, streaming RPC over HTTP/2 — the default for service-to-service calls behind the edge.
- [ZooKeeper](https://systemdesignatlas.dev/docs/15-zookeeper): A small, strongly consistent store for the decisions a cluster must agree on: who leads, who is alive, who owns what.
- [Vector databases](https://systemdesignatlas.dev/docs/16-vector-databases): Find the stored vectors nearest to a query vector, fast enough to sit in a request: the retrieval layer under RAG, semantic search and recommendations. (premium)
## Coding
- [Hash Tables](https://systemdesignatlas.dev/coding/01-hash-tables): An array you index by content instead of position. The one structure that turns a nested loop into a single pass, and the one whose O(1) comes with conditions.
- [Two Pointers](https://systemdesignatlas.dev/coding/02-two-pointers): Two indices walking the same array under a rule that lets each move retire part of the search. The technique that collapses a nested loop into one pass — when the data has an order to exploit.
- [Sliding Window](https://systemdesignatlas.dev/coding/03-sliding-window): A contiguous span with two edges that only ever move forward. Turns "check every subarray" into one pass — as long as the window's validity is monotone.
- [Binary Search](https://systemdesignatlas.dev/coding/04-binary-search): Halve the candidate set on every comparison. Trivial to describe, easy to write wrong, and far more general than "find a value in a sorted array".
- [Stacks](https://systemdesignatlas.dev/coding/05-stacks): Last in, first out — and the structure behind matching, undo, recursion, and the monotonic trick that answers "next greater" for every element in one pass.
- [Linked Lists](https://systemdesignatlas.dev/coding/06-linked-lists): Nodes connected by references, with no index and no locality. Almost every question is pointer surgery: rewire the links without losing the rest of the list.
- [Trees and Traversals](https://systemdesignatlas.dev/coding/07-trees): Recursive structure, recursive solutions. Most tree questions are one traversal with the work moved to the right point in the recursion — and the cost is decided by the height, not the count.
- [Heaps](https://systemdesignatlas.dev/coding/08-heaps): A tree stored in an array that keeps only one promise: the best element is at the front. Cheaper than sorting, and the right answer whenever a problem says top-k, median, or merge.
- [Tries](https://systemdesignatlas.dev/coding/09-tries): A tree keyed by characters, where the path spells the word. The structure that answers prefix questions a hash map cannot answer at all.
- [Graphs](https://systemdesignatlas.dev/coding/10-graphs): Nodes and edges, and two traversals that answer most questions about them. The hard part is usually recognising that a problem is a graph at all.
- [Backtracking](https://systemdesignatlas.dev/coding/11-backtracking): Depth-first search over decisions, with the decision undone on the way back out. The answer to every "generate all…" and "find an arrangement that works" question.
- [Dynamic Programming](https://systemdesignatlas.dev/coding/12-dynamic-programming): Recursion that refuses to solve the same sub-problem twice. Exponential becomes polynomial the moment the repeated work is written down and reused.
- [Intervals](https://systemdesignatlas.dev/coding/13-intervals): Ranges with a start and an end. Sort them the right way and almost every question becomes one linear pass — the difficulty is choosing which end to sort by.
## Courses
- [AI Engineering: Overview](https://systemdesignatlas.dev/docs/ai-engineering-00-overview): A course that builds one production AI application end to end: a support assistant that answers from product docs with citations and opens tickets behind a human approval. Eight lessons, each a working layer of the same codebase. (premium)
- [AI Engineering: Foundations](https://systemdesignatlas.dev/docs/ai-engineering-01-foundations): The layer every other lesson stands on: a model client behind your own types, answers streamed over SSE, errors classified into policy, prompts versioned like code, and a fake model so the whole stack runs in tests. (premium)
- [AI Engineering: Tools and agents](https://systemdesignatlas.dev/docs/ai-engineering-02-tools-and-agents): The agent loop in about a hundred lines: tools defined once as typed schemas, model input validated and contained, reads run in parallel, writes paused for a human who approves the exact arguments, and every side effect executed at most once. (premium)
- [AI Engineering: Retrieval (RAG)](https://systemdesignatlas.dev/docs/ai-engineering-03-retrieval): Give the model your product's knowledge at question time: chunk by structure, embed with context, store in Postgres with pgvector, search by meaning and by keyword in parallel, fuse with RRF, rerank, fence the passages as data, and check every citation. (premium)
- [AI Engineering: Evals](https://systemdesignatlas.dev/docs/ai-engineering-04-evals): Turn quality into a number you can gate on: a golden dataset built around the failures you fear, deterministic retrieval metrics on every pull request, answers graded by code first and an LLM judge second, a judge that is itself checked against human labels, and honest statistics. (premium)
- [AI Engineering: Observability and cost](https://systemdesignatlas.dev/docs/ai-engineering-05-observability-and-cost): See what each request did and what it cost: one trace per turn with GenAI attributes, one instrumented choke point for every model call, metrics labelled by model and purpose, a price table, and the cost levers in the order to pull them: prompt caching, response caching, effort, routing and context size. (premium)
- [AI Engineering: Safety](https://systemdesignatlas.dev/docs/ai-engineering-06-safety): Assume the model will be persuaded, by a user, a document or a tool result, and design so that being persuaded is not enough to cause harm: a threat model, five layers against indirect injection, an output guard that checks text before it streams, identity, rate limits and spend caps that hold under concurrency. (premium)
- [AI Engineering: Shipping](https://systemdesignatlas.dev/docs/ai-engineering-07-shipping): Production means it starts the same way everywhere, degrades instead of dying, keeps its state through a deploy, and lets whoever is on call answer "why was this answer wrong?" from a trace: a reproducible image, a CI pipeline with a container smoke test, failover, a circuit breaker, degraded mode, shared state and a runbook. (premium)
- [AI Engineering: Advanced patterns](https://systemdesignatlas.dev/docs/ai-engineering-08-advanced): Five techniques that are easy to over-apply, each with what it costs and the measurement that decides whether you need it: multi-agent for privilege separation, MCP in both directions, vector indexes at scale, fine-tuning a small router, and OIDC for end users. Then the principles that carry across the course. (premium)
- [Frontend System Design: Overview](https://systemdesignatlas.dev/docs/frontend-system-design-00-overview): A course for the frontend system design round: how to shape a 45-minute answer, then rendering, client state, networking, performance, real-time collaboration, accessibility and browser security, ending with four component designs worked as interviews. (premium)
- [Frontend System Design: Rendering strategies](https://systemdesignatlas.dev/docs/frontend-system-design-01-rendering): Where the HTML is made and when: client rendering, server rendering, static generation, incremental regeneration, streaming, islands and React Server Components, what each costs, and how to choose per route instead of per app. (premium)
- [Frontend System Design: State and data](https://systemdesignatlas.dev/docs/frontend-system-design-02-state-and-data): The client's data model: telling server cache from client state, keys and staleness, normalising entities, optimistic updates with rollback, persisting for offline, syncing an outbox and handling conflicts when two copies disagree. (premium)
- [Frontend System Design: Networking from the client](https://systemdesignatlas.dev/docs/frontend-system-design-03-networking): The client's side of the API: choosing REST, GraphQL or RPC for a screen, designing pagination for infinite lists, retries and timeouts that do not make outages worse, cancelling and deduplicating requests, and picking between polling, SSE and WebSockets for live data. (premium)
- [Frontend System Design: Performance](https://systemdesignatlas.dev/docs/frontend-system-design-04-performance): Making a web app fast on the devices people really use: Core Web Vitals and what moves each one, JavaScript budgets and code splitting, images and fonts, virtualised lists, prefetching, keeping the main thread free, and measuring in the field rather than on a laptop. (premium)
- [Frontend System Design: Real-time and collaborative clients](https://systemdesignatlas.dev/docs/frontend-system-design-05-realtime-and-collaboration): The client half of multiplayer products: applying edits locally and reconciling with the server, operational transformation and CRDTs as the client runs them, presence and live cursors on a lossy channel, undo in a shared document, and rendering a canvas that many people change at once. (premium)
- [Frontend System Design: Accessibility, i18n and design systems](https://systemdesignatlas.dev/docs/frontend-system-design-06-accessibility-i18n-design-systems): The parts that are cheap on day one and ruinous to retrofit: semantic structure, keyboard and focus management, live regions and the ARIA patterns interviews ask for; tr