← All topics
🏗️

System Design

A 20-module, staff-level curriculum: from back-of-the-envelope estimation to consensus, consistency models, and real-world case studies.

21 posts · Engineering

  1. 1

    How to Learn System Design From Scratch (20-Step Path)

    A clear 20-step roadmap to learn system design from CRUD apps to distributed systems - what to study, in what order, and how to actually make it stick.
  2. 2

    Back-of-the-Envelope Estimation: Size Any System Fast

    Learn back-of-the-envelope estimation to size any system for millions of users in ten minutes. QPS, storage, Little's Law, and percentiles, explained simply.
  3. 3

    Why Some Websites Feel Instant (and Yours Doesn't)

    Learn how networking and protocols like TCP, TLS, and HTTP/3 add round-trips that make sites slow - and the simple fixes that make pages feel instant.
  4. 4

    API Design: How Services Talk Without Breaking

    Learn API design that lasts: REST vs GraphQL vs gRPC, idempotency keys, cursor pagination, versioning, and webhooks that never double-charge a customer.
  5. 5

    Database Internals: Why Your Queries Are Slow (and How to Fix Them)

    A clear guide to database internals: how storage engines, indexes, transactions, and MVCC really work, and why understanding them makes your queries fast.
  6. 6

    SQL vs NoSQL: How to Actually Choose (and Model) Your Data

    A practical guide to SQL vs NoSQL data modeling: when joins break, how to pick a partition key, single-table DynamoDB design, and polyglot persistence.
  7. 7

    Caching Explained: How One Layer Saves (or Sinks) Your App

    A practical caching deep dive: how cache hit ratio protects your database, the read/write patterns to use, and the four failures that turn caches into outages.
  8. 8

    Load Balancing and Scaling: How Web Apps Survive Traffic Spikes

    Learn how load balancing, stateless design, and autoscaling let one web app grow into a fleet that handles huge traffic spikes without crashing.
  9. 9

    Replication and Sharding: How Big Sites Never Go Down

    Learn how replication keeps copies of your data alive and how partitioning (sharding) splits huge datasets across machines, plus the failures that bite at 3am.
  10. 10

    CAP, PACELC & Consistency Models, Finally Made Clear

    CAP theorem and PACELC made clear. Learn what your database really guarantees during a network partition and how to choose the right consistency model.
  11. 11

    Distributed Consensus: How Computers Agree When Some Crash, Lie, or Freeze

    Learn how distributed systems reach agreement when nodes crash or stall - Paxos, Raft, distributed locks, fencing tokens, and why consensus is hard.
  12. 12

    Distributed Transactions: Sagas, Outbox & Idempotency Explained

    Distributed transactions break the moment data crosses two services. See how sagas, the transactional outbox, and idempotency keys keep systems correct.
  13. 13

    Message Queues vs Kafka: Event-Driven Architecture Explained

    Message queues vs Kafka, delivery guarantees, ordering, and dead-letter queues, explained in plain language so you can design event-driven systems.
  14. 14

    Event Sourcing & CQRS: Store What Happened, Not Just the Result

    Event sourcing stores every change as an immutable fact, and CQRS splits reads from writes. Learn how both work, when they pay off, and when they're overkill.
  15. 15

    Stream Processing Explained: React the Moment Data Arrives

    Learn how stream processing reacts to data the instant it arrives. Event time, watermarks, exactly-once, Lambda vs Kappa, and real pipelines made simple.
  16. 16

    Probabilistic Data Structures: Count Billions in Kilobytes

    Probabilistic data structures like Bloom filters and HyperLogLog count billions of items in kilobytes, trading a little accuracy for huge memory savings.
  17. 17

    Rate Limiting and Resiliency: Keep Systems Standing Under Load

    Learn rate limiting and resiliency patterns that keep systems alive under load: token buckets, circuit breakers, retries with jitter, bulkheads, and more.
  18. 18

    Observability and SRE: Knowing Your System Is Healthy

    Learn observability the practical way: metrics, logs, traces, SLIs and SLOs, error budgets, smart alerting, and deploys that recover without a second outage.
  19. 19

    Monolith vs Microservices: When to Split (and When Not To)

    A clear guide to monolith vs microservices: how to find real service boundaries, migrate safely with strangler-fig, and cap blast radius with cells.
  20. 20

    When Postgres Says No: Search, Geo & Time-Series Stores

    Learn when a standard database can't answer your query, and which specialized database to reach for instead: search, geospatial, time-series, or analytics.
  21. 21

    System Design Interview: A 7-Step Framework That Works

    A repeatable 7-step framework for the system design interview, plus 10 worked case studies from URL shorteners to payments. Walk in calm, control the room.