System Design

System Design Basics

Learn the fundamental principles behind building large-scale, reliable systems: scalability, availability, latency, and the key trade-offs that drive real-world architecture decisions.

Consistent Hashing

Understand the hash ring, virtual nodes, and why consistent hashing is the foundation of distributed caches (Redis Cluster, Memcached), distributed databases (Cassandra, DynamoDB), and CDN request routing.

Concurrency vs Parallelism

Untangle four words engineers constantly confuse: concurrency, parallelism, threads, and processes. Learn what runs truly simultaneously versus what merely interleaves, why Python's async model is single-threaded, and how getting this wrong causes real production bugs like sharing one database session across coroutines.

The CAP Theorem

Understand why distributed systems can only guarantee two of Consistency, Availability, and Partition Tolerance — and how real-world databases (Cassandra, Zookeeper, DynamoDB, Postgres) navigate this fundamental constraint.

Load Balancing

Understand how load balancers work, the algorithms they use (round-robin, least-connections, IP hash), Layer 4 vs Layer 7 differences, and how to design systems that stay healthy when servers fail.

Reliability, Resilience & Observability Patterns

Learn availability math, SLOs and error budgets, timeouts, retries with backoff and jitter, circuit breakers, bulkheads, load shedding, safe deploys, and the three pillars of observability, then apply them to a checkout service with a flaky payment provider.

Rate Limiting

Compare token bucket, leaky bucket, fixed window, sliding log and sliding window counter with worked numbers, then design a distributed rate limiter on Redis, handle 429 responses correctly, and reason about fail-open versus fail-closed when the limiter itself is down.

System Design Interview Framework & Capacity Estimation

Learn what system design interviewers actually grade, the four-step framework with time boxes, the latency, availability, and throughput numbers to memorise, and how to do back-of-envelope capacity estimation with fully worked examples.

Message Queues & Event Streaming

Learn when to put a queue or a Kafka-style log between services, how partitions bound ordering and parallelism, what exactly-once really means, and how the outbox pattern, idempotency keys and dead-letter queues keep an async pipeline correct under failure.

Design a URL Shortener (bit.ly / TinyURL)

Walk through a complete URL shortener design the way a strong candidate answers it: requirements and estimates, base62 vs hashing vs a key-generation service, 301 vs 302 redirects, hot-URL caching, sharding, expiry, analytics and abuse controls.

Caching Strategies

Master read and write caching patterns, TTL and invalidation, eviction policies, cache stampedes and hot keys, consistency races, hit-ratio sizing, and CDN caching, with a worked design of a 50k QPS product-page cache.

Design a Chat System (WhatsApp / Slack / Messenger)

Design a real-time chat system end to end: WebSocket architecture, message storage and ordering, 1:1 and group fan-out, delivery receipts, multi-device sync, presence, and how connection servers survive failure at millions of concurrent users.

API Design & Service Communication

Learn to design clean REST resources, choose between offset and cursor pagination, make payment endpoints idempotent, pick REST vs gRPC vs GraphQL, choose polling vs SSE vs WebSockets, and evolve schemas without breaking clients.

Distributed Transactions, Consensus & Coordination

Master why ACID breaks across shards, how two-phase commit and sagas coordinate multi-service writes, how Raft elects leaders and replicates logs safely, why lease-based locks need fencing tokens, and how linearizability differs from serializability.

Design a News Feed (Twitter / Facebook-style Timeline)

Walk through a complete news feed system design interview answer with real numbers: capacity estimation, APIs, data model, push vs pull fan-out and the hybrid for celebrities, Redis feed caches, cursor pagination, sharding, and failure modes.