57 System Design
Blueprints

Classic 3-tier architecture with CDN, load balancer, stateless app servers, PostgreSQL for transactional data, and Redis for product catalog and session caching. Models a full shopping cart and checkout flow. The canonical starting point for system design interviews — examiners expect you to evolve it toward microservices as scale grows.

Fully serverless architecture: API Gateway fronts Lambda functions that read/write DynamoDB and store files in S3. Zero servers to provision or patch. Demonstrates how event-driven compute changes cost structure — pay per invocation, scale to zero at idle. Ideal for internal tools, MVPs, and low-to-medium traffic APIs.

Cache-aside redirect service mapping short codes to long URLs. The API Gateway routes create requests to a URL Service that writes to the database, and redirect requests to a Redirect Service that checks the URL Cache first — falling through to the database on a cache miss. A go-to beginner system design interview question that teaches caching strategy.

Text snippet storage and sharing service. A Paste Service routes through a load balancer and manages two storage layers: metadata (title, expiry, access stats) goes to a relational database, while the actual paste content goes to S3-style object storage. A content cache absorbs the read-heavy workload for popular pastes.

CDN-backed file hosting with chunked upload support, S3 object storage, and a metadata database tracking file IDs, owners, and expiry. The CDN handles global distribution for downloads, while chunked uploads allow large files to resume after interruption. Demonstrates separation of data-plane storage from control-plane metadata.

Server-side rendered blog with CDN asset delivery, a content cache layer for rendered HTML, a relational database for post content and author metadata, and S3 for image and media storage. Demonstrates the classic read-heavy web application where caching at the CDN and application layer dramatically reduces database load.

Room booking system with real-time availability caching, pessimistic locking to prevent double-bookings, and an asynchronous confirmation notification flow. A classic high-contention problem: multiple users trying to book the same room simultaneously. Teaches distributed locking strategies and the tradeoffs between optimistic and pessimistic concurrency control.

Real-time parking spot management with event-driven status updates and in-memory availability tracking. When a vehicle enters or exits, the state changes are pushed through an event bus and reflected in the spot availability store. Demonstrates how to design low-latency read paths for high-churn state data.

Serverless image upload pipeline with automatic resizing and format conversion via Lambda, CDN delivery from the edge, and durable S3 storage. Upload triggers a Lambda that generates thumbnail variants and stores them alongside the original. The CDN caches all variants globally to minimize origin load.

Hybrid fan-out social platform with pre-computed timelines for regular users and fan-out-on-read for celebrity accounts (millions of followers). Async fan-out workers process each post and push to follower feed caches. CDN handles media delivery. Teaches the celebrity problem and when to switch from write-time to read-time feed generation.

Media-heavy social platform with serverless image processing, activity-driven feed updates via an event stream, and CDN delivery for photos and videos. Demonstrates how a social graph shapes read/write patterns — follower counts directly affect fan-out cost — and how object storage scales independently from the metadata layer.

Geohash-indexed business search with spatial indexing, a location cache for hot geo-cells, and media storage for photos and reviews. Geohashing divides the earth into a grid of cells — nearby businesses share the same prefix, enabling efficient radius queries. Demonstrates spatial indexing alternatives (geohash vs quadtree vs R-tree) and their tradeoffs.

Personalized music streaming with CDN audio delivery, a recommendation engine fed by play event analytics, and a microservices backend for catalog, user preferences, and playlist management. Demonstrates how a recommendation system can be decoupled from the serving layer and how CDN prefetching reduces buffering for sequential track playback.

Fan-out-on-write architecture for personalized social feeds. When a user posts, the Feed Service writes to a fan-out queue which asynchronously pre-populates every follower's feed cache. A Notification Lambda consumes from the same queue for push alerts. Teaches write amplification, eventual consistency, and when the fan-out approach breaks down at celebrity scale.

Automated build and deploy pipeline triggered by webhook on git push. The event queues a build job, workers compile and test in isolated containers, artifacts are stored in S3, and successful builds enqueue a deployment trigger. Demonstrates event-driven workflow orchestration with durable queues preventing lost build jobs during worker restarts.

Priority task queue with dedicated worker pools for high and low priority jobs, persistent task state tracking in a database, and scheduled job support via a cron-style dispatcher. Worker pools pull from their priority lanes and heartbeat status back to the task tracker. Demonstrates queue-based load leveling and at-least-once delivery semantics.

Multi-channel notification dispatcher routing to email, SMS, and push channels based on user preferences. An event queue decouples producers from channel-specific sender services. A user preference DB gates which channels receive each event type. Demonstrates channel fan-out, priority-based routing, and graceful degradation when a provider (e.g. Twilio) is slow or down.

High-concurrency event ticketing (concerts, sports) with distributed seat locking, payment integration, and queue-based confirmation delivery. Seat reservation holds a distributed lock for a timeout window while payment is processed — preventing overselling. Demonstrates the thundering herd at ticket-sale-open time and how a virtual waiting room queue absorbs burst traffic.

WebSocket-based chat system where clients maintain persistent connections to a WS Server cluster. Redis Pub/Sub bridges cross-server delivery: when Server 1 receives a message for a user on Server 2, Redis routes it in under 1ms. A presence cache tracks online status and which server each user is connected to. Persistent message store handles offline delivery and history retrieval.

Real-time leaderboard backed by Redis sorted sets, which natively support rank queries in O(log N). When a score update arrives, the sorted set is atomically updated and the change is pushed over WebSocket to connected clients. Demonstrates Redis data structures as a specialized compute layer — not just a cache — and how to avoid polling for rank changes.

Sub-10ms prefix suggestion service backed by an in-memory trie data structure with frequency-based ranking. Queries traverse from the root to the prefix node, then return the top-K descendants ordered by search frequency. A query cache layer handles the long tail of common searches. Demonstrates data-structure-driven architecture and why relational DBs fail for trie workloads.

Geospatial ride-matching platform with real-time driver location tracking (WebSocket heartbeats), a dispatch queue that matches riders to nearby drivers, and a route estimation service. Location updates flow into a geospatial index every few seconds. Demonstrates the supply-demand matching problem, location data ingestion at scale, and how surge pricing signals emerge from queue depth.

Sandboxed remote code execution with WebSocket session synchronization, session management, and an isolated container runtime (similar to Judge0 or Replit's execution layer). User code runs in an ephemeral container with CPU and memory limits. Results stream back over WebSocket. Demonstrates the security isolation problem and how container orchestrators handle untrusted workloads.

LMAX-style order matching engine with an event-sourced order book, nanosecond-latency matching loop, and market data pub/sub for broadcasting bid/ask changes. The disruptor pattern eliminates lock contention: a single writer thread processes orders sequentially in a ring buffer while reader threads consume results concurrently. One of the most latency-sensitive architectures in existence.

Real-time collaborative editor using Operational Transform (OT) to merge concurrent edits without conflicts. Each edit is transformed against concurrent edits before being applied, preserving intent. WebSocket sessions keep all collaborators in sync, while a version history store enables undo and conflict resolution replay. Alternatively models CRDT-based approaches as a comparison path.

Channel-based messaging platform with a WebSocket cluster, presence tracking, event-driven fan-out to channel members, and file storage for attachments. Messages published to a channel are fanned out to all member connections via Redis Pub/Sub. Presence (online/away/offline) is maintained via heartbeats and distributed to workspace members. Models Discord's guild-based sharding strategy for scaling.

API Gateway routing to multiple independent services (auth, orders, inventory, notifications), each with its own database following the database-per-service pattern. A message queue decouples inter-service events — for example, an order placement event triggers both inventory decrement and notification dispatch. Demonstrates service decomposition and the challenges of distributed data consistency.

High-reliability payment processing with multi-AZ database replication, event sourcing for an immutable transaction ledger, and an async notification service for payment receipts. Idempotency keys prevent duplicate charges from retries. Demonstrates the financial system requirement for strong consistency, at-least-once processing with deduplication, and regulatory audit trail via event sourcing.

Orchestrated saga pattern coordinating order, restaurant, and delivery services. The Saga Orchestrator drives the workflow: create order → confirm restaurant → assign driver → track delivery. On failure at any step, compensating transactions roll back prior steps. Real-time map routing updates delivery ETAs. Demonstrates distributed transaction management without two-phase commit.

Double-entry ledger wallet with fraud detection, idempotent transfer processing, external bank settlement, and event sourcing for a full audit trail. Every debit has a corresponding credit — the ledger always balances. Fraud detection runs as a synchronous check before transfer commit. Demonstrates why financial systems require strongly consistent, linearizable storage and how idempotency handles network failures.

2PC / Saga pattern coordinator that drives multi-service transactions with compensation event rollback, a durable transaction log, and a state cache for fast coordinator lookups. The coordinator tracks each participant's vote in Phase 1 and issues commit/abort in Phase 2. Demonstrates the fundamental tradeoff: 2PC guarantees atomicity at the cost of availability during coordinator failure.

CDN-heavy architecture for on-demand video delivery. Raw uploads land in S3, triggering a serverless transcoding pipeline that generates multiple bitrate variants (360p, 720p, 1080p, 4K). Adaptive bitrate (ABR) segments stream from CDN edge nodes closest to the viewer. Demonstrates how asynchronous media processing decouples upload from playback availability.

High-throughput IoT data ingestion pipeline designed for millions of devices sending sensor readings. An MQTT broker ingests device telemetry into a message queue, serverless workers process and enrich events, and a time-series database stores aggregated metrics for dashboards and anomaly detection. Demonstrates the asymmetry of IoT: massive write volume, relatively modest read volume.

Full-text search system with an inverted index, a document crawler feeding an index queue, and a search cluster handling queries with TF-IDF ranking. A query result cache absorbs repeated searches. Demonstrates how an inverted index maps terms to document lists for O(1) term lookup, and how sharding the index across nodes enables horizontal scaling of the search layer.

BFS-based web crawler with a URL frontier for scheduling, a distributed worker pool that fetches and parses pages, a DNS cache reducing resolver latency, and politeness controls (crawl-delay, robots.txt) to avoid overwhelming target servers. A deduplication store (Bloom filter) prevents re-crawling. Demonstrates large-scale distributed BFS and the politeness-vs-coverage tradeoff.

Tile-based map rendering with a graph-based routing engine (Dijkstra / A* over a road network graph), a geospatial database partitioned by region, and a live traffic data pipeline updating edge weights. Map tiles are pre-rendered and cached at CDN edge nodes. Demonstrates how geographic partitioning shapes database design and why routing engines need to operate on in-memory graphs for speed.

Video platform with asynchronous transcoding pipeline, multi-CDN streaming, recommendation engine driven by watch history analytics, and thumbnail generation. Upload triggers a DAG of transcoding jobs across GPU workers. Watch events stream into an analytics pipeline that feeds the recommendation model. Demonstrates the challenge of operating a petabyte-scale video store with real-time personalization.

Block-level deduplication file sync system. Files are split into fixed-size chunks; only modified chunks are uploaded (delta sync). A metadata service tracks file-to-chunk mappings and version history. Cross-device sync is triggered via a notification channel — other devices see the block diff and pull only changed chunks. Demonstrates content-addressable storage and how dedup cuts storage cost dramatically for corporate file sync.

Lambda architecture combining a real-time click stream (Kafka → Flink) for sub-minute aggregates and a batch layer (Spark on S3) for accurate historical aggregation. An OLAP query layer (ClickHouse-style) serves campaign dashboards. Demonstrates the Lambda pattern: speed layer for fresh results, batch layer for correctness, serving layer for queries against both. Counts must be exact for billing.

Online/offline feature store architecture with stream processing for real-time features (seconds-fresh), a batch training cluster for model updates, a model server for low-latency inference, and an inference cache for repeated predictions. Demonstrates the critical distinction between the training pipeline (throughput-optimized) and the serving path (latency-optimized) and how a feature store bridges the two.

Push-based metrics ingestion pipeline modeled on Prometheus/Datadog patterns. Agents push time-series data to a metrics receiver, a stream aggregator computes rollups, and a time-series database (TSDB) stores the data with efficient compression. A dashboard cache serves pre-computed queries. Threshold-based alerting rules trigger on aggregated metrics. Demonstrates why TSDBs outperform relational DBs for telemetry workloads.

Token-bucket rate limiting gateway protecting backend APIs from abuse. The API Gateway checks each request against a Rate Limiter service that reads/decrements counters stored in Redis. Rate limit rules (requests per second per client tier) are loaded from a Rules DB. Demonstrates the token bucket algorithm, sliding window alternatives, and why Redis atomics (INCR + EXPIRE) are the right tool for counters.

Distributed key-value store with consistent hashing across nodes and LSM-tree persistence. A load balancer routes requests to the correct node based on key hash ring position. Each node uses an LSM-tree (memtable → SSTable → compaction) for write-optimized persistence. Demonstrates how consistent hashing minimizes rehashing when nodes join or leave the cluster.

Distributed Snowflake-style ID generation with ZooKeeper coordination for worker ID assignment and leased ID ranges to reduce ZooKeeper round trips. Each ID encodes a timestamp (milliseconds), datacenter ID, worker ID, and sequence number — guaranteeing monotonicity and global uniqueness without a central sequence database. Demonstrates how time-based IDs enable range scans and how clock skew becomes a reliability concern.

Consistent hashing cache cluster modeled on Memcached and Redis Cluster. Data is sharded across nodes via a virtual node ring. Replication factor of 2 means each key is stored on two nodes for availability. Write-through persistence to a backing database on cache misses. Demonstrates cache eviction policies (LRU, LFU), and how adding a virtual node ring reduces rebalancing impact.

Distributed rate limiting gateway with token-bucket counters stored in Redis, a rules engine for per-client and per-endpoint policies, and a configuration database for rule management. Unlike a simple rate limiter, this gateway handles multi-tier customers, burst allowances, and policy versioning. Useful for SaaS platforms monetizing API access across free, pro, and enterprise tiers.

Partitioned distributed log with broker replication, ZooKeeper coordination for leader election, and a schema registry for message format governance. Each topic partition is replicated across brokers (replication factor 3 typically). Producers write to the leader, followers replicate asynchronously. Consumer groups read from assigned partitions with offset tracking. Kafka architecture blueprint for engineers evaluating event streaming platforms.

Raft consensus protocol with leader election, append-entries log replication, and state machine application. A leader is elected when followers time out without a heartbeat. The leader appends log entries and waits for a majority quorum before committing. Followers apply committed entries to their state machines. Demonstrates why consensus is hard: split-brain, log divergence, and the role of election timeouts.

Pull-based CDN with global edge Points-of-Presence (PoPs), DNS-based anycast routing, an origin server, and cache invalidation propagation. When a user requests content, DNS routes them to the nearest PoP. On a cache miss, the PoP pulls from origin and caches locally. Invalidation events propagate to all PoPs via a control plane. Demonstrates how CDNs trade consistency (stale cache) for latency.

Distributed object store with a metadata service (naming, ACL, versioning), data nodes storing actual chunks with erasure coding for space-efficient redundancy, and a name cache reducing metadata lookup latency. Erasure coding (e.g. Reed-Solomon) recovers data from any k-of-n fragments — providing stronger durability than replication at lower storage cost. Models how S3 achieves eleven 9s of durability.

Hierarchical DNS resolution with a recursive resolver, root nameservers, TLD nameservers, and authoritative nameservers. A client asks the recursive resolver, which walks the hierarchy and caches responses at each level (TTL-bounded). Demonstrates why DNS is eventually consistent by design, how TTL choices affect propagation latency vs server load, and why negative caching matters for NXDOMAIN responses.

Single-agent MCP setup with an API gateway, an agent runtime, a tool registry, and one MCP server for hands-on tool-calling fundamentals. The agent receives a goal, queries the tool registry to discover available tools, and dispatches calls via the gateway to the MCP server. The ideal starting point for understanding the Model Context Protocol before adding multi-server routing or policy enforcement.

Hybrid assistant combining retrieval-augmented generation over a vector store with MCP action tools for external system updates. The agent retrieves grounded context from an embedded document corpus (with a session-local context cache to reduce repeated retrieval), then can take side effects — creating tickets, sending messages, updating records — via MCP Action Tools. Demonstrates the separation between knowledge retrieval and action execution in production AI assistants.

Supervisor pattern coordinating specialist agents — Research, Code, and Review — with a task queue providing backpressure and retry semantics and a Workflow State DB enabling long-running jobs to resume without losing context. The Supervisor decomposes goals, delegates subtasks, monitors progress, and aggregates outputs into a final response. Demonstrates the orchestration tradeoffs: specialization quality vs inter-agent coordination overhead.

Central MCP control plane for policy enforcement, tool routing, and audit metering across internal and external MCP server pools. All tool calls pass through a Policy Gateway (RBAC, data sensitivity checks, rate limits) before reaching an MCP Router that dispatches to internal tools (trusted, private network) or external tools (third-party, stricter guardrails). Usage records feed an Audit + Metering DB for governance and cost visibility. The governance layer AI platform teams need before scaling MCP across an enterprise.

Tracing, cost metering, and replay architecture for debugging and operating LLM agent workflows. The Agent Runtime emits structured events (prompts, tool calls, token counts, failures) to a Telemetry Collector. A Trace Queue buffers high-volume streams during incident spikes. Aggregated metrics land in a Trace + Cost DB; raw traces go to a Replay Artifact Store for deterministic failure reproduction. An Ops Dashboard surfaces KPIs and loads replay sessions for triage — similar to LangSmith-style observability stacks.