System Design Library

A system design interview asks you to make useful decisions while the problem is still incomplete.

Preparation works best as a loop: learn one mechanism, retrieve it from memory, apply it to a new prompt, and review where your explanation failed.

A complete interview framework with a worked notification design.

Use core concepts as tools for explaining a workload, not as vocabulary to recite.

Choose a technology from required behavior and operating constraints.

Patterns are reusable responses to recurring constraints.

A question breakdown is a worked example of the delivery framework, not a diagram to memorize.

Before a request reaches your application, several separate conversations may occur.

An API is a promise between independently failing programs.

Begin with questions the product must answer, not a choice between SQL and NoSQL.

A cache stores a reusable answer closer to the caller or cheaper than the source.

Sharding divides data across independent storage owners so one machine does not need to hold or process everything.

A placement rule should not move nearly every key whenever membership changes.

CAP concerns what a distributed system can guarantee while communication is partitioned.

An index is an extra access path that trades storage and write work for less read work.

Estimation is a way to expose constraints, not a memory contest about hardware constants.

Design a short-link service with creation, redirection, editing, and expiration.

Design file upload and synchronization with separate metadata and bytes.

Design a service that matches customers placing local orders with couriers, tracks pickup and delivery, and communicates changes.

The hard part of a ticket sale is scarce inventory under a burst, not drawing a payment box.

Design a feed from posts and a follow graph, with ranking, pagination, deletion, and privacy.

Design a location-aware discovery and matching service with profile cards, likes, mutual matches, and messaging handoff.

Design an online code judge that executes untrusted submissions.

Design a messaging service around three separate facts: the server accepted a message, a device received it, and a person read it.

Design an admission control service that limits requests by a documented identity and time policy.

Design video upload, processing, and playback as distinct lifecycles.

Design comments for a live video room.

Find the most viewed videos over a time range, such as the top 100 during the last hour.

Design ride matching by separating approximate discovery from exclusive assignment.

A crawler is a scheduler with a fetch-and-discover loop.

Count ad clicks per campaign and time window while accepting retries, late arrivals, and reprocessing.

Design search across posts while respecting audience visibility, deletion, and recent edits.

Design nearby business search with text, category, and geographic filters.

Design photo publishing, processing, and a personalized home feed.

Design activity recording and fitness discovery: mobile uploads, route samples, summaries, segment matching, and social feeds.

Design a cache cluster that serves key/value reads through node failures and membership changes.

An auction needs an authoritative rule for bid acceptance and closing.

Design a service that runs delayed and recurring jobs with retries, cancellation, and multiple worker regions.

Design a personalized list of articles collected from publishers.

Design price history and threshold alerts for products collected from merchant pages or feeds.

Design a multi-tenant notification service for transactional alerts and bulk campaigns across email and push. Show the lifecycle from accepted intent to a reconciled outcome.

Design a brokerage-style order and portfolio service for an interview.

Design collaborative editing for a shared document with low-latency updates, offline clients, reconnect, and durable snapshots.

A payment service must represent uncertainty without creating another charge.

A monitoring platform ingests time series, stores recent and historical samples, serves queries, and evaluates alerts.

Design turn-based online chess with authoritative legal moves, clocks, reconnects, and game history.

Design a conversational AI product at the platform level: accepting turns, streaming generated output, managing conversation context, routing inference, and enforcing usage budgets.

Design a high-demand sale for a limited inventory item.

Real-time is a freshness requirement, not a transport name.

Contention occurs when concurrent operations compete over the same mutable fact.

A business process that crosses databases or external services cannot usually be rolled back like one local transaction.

Read scaling is a sequence of decisions about cost and freshness.

A write path is limited by the slowest sustained stage, not by the length of its queue.

Large files should not usually pass through application workers that only need to authorize and track them.

Long tasks outlive ordinary HTTP requests and often outlive the process that started them.

Redis offers in-memory data structures that can make shared counters, caches, rankings, and short-lived coordination convenient.

Search engines organize text and other fields for retrieval rather than ordinary transactional ownership.

Kafka is a partitioned durable log.

Temporal is a workflow platform for durable application processes that must wait, retry, and resume across worker failure.

An API gateway is an edge entry point for routing and selected cross-cutting policies.

Cassandra encourages query-first modeling: design tables around known access patterns and bounded partitions.

DynamoDB is a managed key-value/document database whose efficient access depends on known partition and sort key patterns.

PostgreSQL is useful when relationships, constraints, and transactional state transitions matter.

Flink processes unbounded and bounded event streams with stateful operators, event-time windows, and checkpoint recovery.

ZooKeeper coordinates small amounts of critical shared state using an ordered replicated service and client sessions.

Advanced topics help when a baseline design hits a specialized data or scale constraint.

Proximity search asks for objects near a point, but the best index depends on whether objects are static businesses or rapidly moving drivers.

A time-series system stores measurements keyed by time and one or more dimensions.

Approximate data structures trade a stated error for lower memory or communication.

Vector retrieval finds items whose embeddings are close under a chosen distance function.

Change data capture (CDC) publishes database changes for downstream projections and event consumers.

Read production engineering posts as evidence with a scope and date.

Shopify’s account describes replacing Redis reservations with MySQL.

Discord’s account describes moving its message store from Cassandra to ScyllaDB and adding Rust data services.

Slack describes a Redis queue outage caused by backlog and memory pressure.

Figma describes a centralized collaboration design inspired by CRDTs, not operational transformation.

Spotify’s RAP account describes an external index that maps lookup keys to files and row locations in existing Parquet data.

Meta describes ZGateway as a managed proxy tier before ZippyDB.