System Design Guide — Step-by-Step Curriculum

A deliberate sequence through system design for interviews: fundamentals, core components, advanced patterns, and full case studies.

introduction

  • What is System Design? — Welcome to the deep end. Instead of just coding logic, System Design is the art of defining the architecture, interfaces, and data for systems that can handle scale, failure, and change.
  • The Interview Process — This isn't a quiz; it's a roleplay. Learn the RESPECT framework, manage the 45-minute clock, and avoid the junior traps that kill your chances.

fundamentals

  • Performance vs Scalability — Performance is how fast you can run. Scalability is how much weight you can carry. Mixing them up is the #1 reason systems crash on Black Friday.
  • Latency vs Throughput — Latency is how fast a car travels. Throughput is how many cars pass the toll booth. If you confuse them, you'll optimize the wrong thing.
  • Consistency & Availability — The eternal trade-off. Learn why you can't have it all (CAP), how to handle the 99% of time when things ARE working (PACELC), and how to tune your truth.
  • Back-of-Envelope Estimation — Before you touch architecture, you need numbers. Learn the mental math that turns vague requirements into concrete scale targets — the skill interviewers test before everything else.

components

  • DNS (Domain Name System) — The Phonebook of the Internet. But unlike a physical phonebook, this one is distributed, hierarchical, and capable of intelligent routing based on who is asking.
  • Proxies — Every major system sits behind a proxy. Learn the difference between forward and reverse proxies, why the distinction matters, and how CDNs and API gateways are just specialised reverse proxies under the hood.
  • CDN (Content Delivery Network) — Speed isn't just about fast servers; it's about physics. Learn how CDNs beat the speed of light by moving content closer to your users.
  • Load Balancing — The unsung hero of scalability. It protects your servers from crushing load and gives you the freedom to fail without downtime.
  • API Gateway — The bouncer, the receptionist, and the translator. It decouples your messy backend microservices from the clean public-facing API.
  • Databases: SQL vs NoSQL — The heart of your architecture. Choosing the wrong database is the most expensive mistake you can make. Learn the 5 families of databases and when to use them.
  • Storage: Block, File & Object — Databases store structured records. Storage systems store everything else — photos, videos, backups, logs. Learn the three storage primitives and how to design large-scale file systems from first principles.
  • Caching — The single most effective way to scale a system. Learn the patterns (Write-Through vs Write-Back), the Eviction policies, and the dangers of the Thundering Herd.
  • Message Queues — The secret to calming down a chaotic system. Learn how to decouple your services, smooth out traffic spikes, and choose between the two giants: RabbitMQ and Kafka.
  • Communication Protocols — Systems need a language to talk. Compare REST (The Text Message), gRPC (The High-Speed Binary), and WebSockets (The Phone Call). Learn when to Poll and when to Push.
  • Service Discovery — How microservices find each other at runtime — without hardcoded IP addresses.

advanced patterns

  • Performance Antipatterns — You can use the fastest language and the biggest server, but bad design will still kill you. Learn how to spot the 'N+1', the 'Sync Chain', and the 'God Object'.
  • Monitoring & Observability — Any system will eventually fail. The difference between a minor glitch and a major outage is how fast you spot it. Learn the 3 Pillars: Logs, Metrics, and Traces.
  • Distributed System Patterns — Microservices break things: Transactions, Consistency, and Reliability. Learn the patterns (Circuit Breaker, Saga, Outbox) we use to glue them back together.
  • Security — Security is not a feature; it is the foundation. Master AuthN vs AuthZ, the endless Session vs JWT debate, and how to define against the OWASP Top 10.

case studies

  • Design a URL Shortener — Design Bit.ly from scratch. Cover hashing strategies, redirect performance, analytics storage, and why this deceptively simple system is a masterclass in read-heavy scaling.
  • Design a Social News Feed — Design Twitter's home timeline or Facebook's news feed. The core problem is fanout — how do you push one post to millions of followers fast enough that the feed feels real-time?
  • Design a Chat System — Design WhatsApp or Slack. The hard problems are message ordering, presence detection, offline delivery, and keeping millions of persistent WebSocket connections alive.
  • Design Search Autocomplete — Design Google's search suggestion box. Every keystroke is a query. The system must return ranked suggestions in under 100ms — using a Trie or precomputed prefix tables backed by a fast cache.
  • Design a Notification System — Design a system that sends push, email, and SMS notifications at scale. The hard problems are fanout to millions of recipients, at-least-once delivery, deduplication, and user preference enforcement.
  • Design a Video Streaming Platform — Design YouTube or Netflix. The upload pipeline encodes one video into dozens of formats. The delivery pipeline uses CDN edge nodes to stream the right quality to each viewer's network. Both must work at planetary scale.
  • Design a Ride Sharing Platform — Design Uber or Lyft. The core challenges are real-time location tracking, geo-indexed driver matching, dynamic pricing, and the trip state machine that coordinates rider, driver, and payment simultaneously.
  • Design a Payment System — Design Stripe or a payment processing backend. The hard problems are idempotency (never charge twice), consistency (money must not appear or disappear), and reconciliation (detecting when distributed systems disagree about what happened).