Skip to content
Senior Dev Notes

Field notes from production

System design, explained like a mentor would.

Rate limits, retries, caches, queues, replicas. The ideas that keep real systems standing. Each one starts from the problem that made it necessary. You can watch it move in a simulation, run it in Python and JavaScript, and walk into the interview ready to explain it.

Start the starter pathSee the roadmap
topics published
11
on the roadmap
137
tracks
14
A small production system, liveThree clients, a phone, a laptop and a script, send requests to a load balancer, which spreads them across two app servers. The app servers read from a cache, which answers in about 2 ms, and a database, which answers in about 40 ms. Requests travel down as blue dots and answers travel back up as green dots; one slow query comes back amber.phonelaptopscriptload balancerapp 1app 2cachehit · 2 msdatabasequery · 40 ms

Who this is for

You can code. Nobody taught you production.

Section titled “You can code. Nobody taught you production.”

You are in your final year of a CS degree, fresh out of a bootcamp, or a year or two into your first job. You can write Python or JavaScript, you know roughly what an HTTP request is, and you have created a database table or two. Then someone says “put a rate limiter in front of it” or “make that endpoint idempotent”, and everyone nods except you.

Every page here is written the way a patient senior engineer would explain it at your desk. We start with the problem that made people invent the thing, look at what people try first and why it breaks, then go deep on how it really works. No hand-waving, no assumed background beyond the basics, and every term is defined the first time it shows up.

  • p99 budget

    Problem first

    Every mechanism exists because something hurt. Each page opens with that moment, so you know why before you learn how.

  • 5 / s

    See it move

    Diagrams show the structure. Simulations let you change the numbers and watch queues fill, tokens drain and replicas fall behind.

  • $ python by_hand.pydns 40 mstls 24 ms ok

    Code that runs

    Every snippet comes in Python and JavaScript, grows from naive to production-shaped, and has a runnable twin in the repository.

  • Ready for interviews

    Each topic ends with typical interview questions, what a strong answer covers, and a short self-check with hidden answers.

Fresh from the notebook

Latest notes

Section titled “Latest notes”
  • CachingCaching Strategies

    A cache is a smaller, faster copy of data that lives somewhere else. Every strategy is an answer to what happens when the two disagree, and what to throw away when it is full.

    intermediate38 min
  • Traffic & edgeLoad Balancing

    Every balancer decides with a partial, slightly old view of the pool. The algorithms that work are the ones built for that.

    intermediate29 min
  • FoundationsLatency vs Throughput

    Latency explodes long before a server is full. The reason is a queue you are not looking at.

    beginner26 min

One shape, every page

How to read a topic page

Section titled “How to read a topic page”

Every topic follows the same shape, so after the first one you always know where you are. If a page lists topics under Read first, those are the ideas it builds on. Skim them if any feel unfamiliar; the page still makes sense without them, but it makes more sense with them.

  1. The story

    A realistic production moment that makes you feel the problem. It ends with the question the page answers.

  2. The problem, properly

    Why the problem exists at all, who it hurts, and the key terms, each defined the first time it appears.

  3. The obvious fix, and why it breaks

    What most people try first, and the neighbouring ideas it gets confused with.

  4. The core idea

    One everyday analogy, where that analogy stops working, and the overview diagram.

  5. How it works

    Each mechanism step by step, with numbers, diagrams and a simulation you can drive. Then a side-by-side comparison and code you build yourself.

  6. The real world

    How well-known systems do it, sourced war stories, the trade-offs, and when not to use it.

  7. Check yourself

    Interview questions, a quiz with hidden answers, a recap to revise from, and where to go next.

The curriculum

The tracks

Section titled “The tracks”

The curriculum is split into fourteen tracks. Within a track, topics are in reading order, and each dot is one topic: filled once it is published.

  • 01
    Foundations

    What Happens When You Type a URL · Back-of-the-envelope estimation · Latency vs Throughput …

    2 of 5 published

  • 02
    Networking & APIs

    DNS · TCP vs UDP · TLS and Encryption in Transit …

    4 of 13 published

  • 03
    Traffic & edge

    Reverse proxies · Load Balancing · API gateways …

    2 of 7 published

  • 04
    Databases

    SQL vs NoSQL · ACID and isolation levels · Database indexing (scan vs seek) …

    15 topics planned

  • 05
    Caching

    Caching Strategies · Cache invalidation · Cache stampede (thundering herd) …

    1 of 5 published

  • 06
    Distributed systems

    CAP and PACELC · Consistency models · Eventual consistency …

    14 topics planned

  • 07
    Messaging & async

    Message queues · Pub/Sub · Event-driven architecture …

    11 topics planned

  • 08
    Resilience

    Timeouts · Retries, exponential backoff and jitter · Circuit breakers …

    1 of 12 published

  • 09
    Security

    Authentication vs authorization · Storing passwords safely · Sessions vs tokens …

    14 topics planned

  • 10
    Performance & runtime

    Scaling up vs scaling out · Autoscaling · Concurrency and thread safety …

    8 topics planned

  • 11
    Delivery & infrastructure

    Docker and containers · Kubernetes · Helm charts …

    10 topics planned

  • 12
    Observability & operations

    Observability: the big picture · Logging · Metrics and monitoring …

    8 topics planned

  • 13
    AI-era systems

    Model Context Protocol (MCP): the big picture · MCP authorization: OAuth 2.1, DCR and CIMD · Retrieval-augmented generation (RAG) …

    6 topics planned

  • 14
    Case studies

    Design a URL shortener · Design a rate limiter service · Design a notification system …

    1 of 9 published

Start here

The starter path

Section titled “The starter path”

New to all of this? Read these twenty in order. Together they cover the ideas that come up in almost every production system and almost every system design interview.

  1. What Happens When You Type a URLFoundations
  2. DNSNetworking & APIs
  3. TCP vs UDPNetworking & APIs
  4. TLS and Encryption in TransitNetworking & APIs
  5. REST API DesignNetworking & APIs
  6. Latency vs ThroughputFoundations
  7. Load BalancingTraffic & edge
  8. Caching StrategiesCaching
  9. Database indexing (scan vs seek) soonDatabases
  10. Connection pooling soonDatabases
  11. N+1 queries soonDatabases
  12. Timeouts soonResilience
  13. Retries, exponential backoff and jitter soonResilience
  14. Idempotency keys soonMessaging & async
  15. Rate LimitingResilience
  16. Circuit breakers soonResilience
  17. Message queues soonMessaging & async
  18. Replication soonDatabases
  19. Logging soonObservability & operations
  20. SLIs, SLOs and error budgets soonObservability & operations
Edit page

Last updated:

Senior Dev Notes

System design, explained like a mentor would.

Written by Uday. Every page is researched, reviewed by a human, and every code example was run before it was published.