Beginner Track
20 modules.
One coherent arc.
Start at Module 01 and work forward. Each module builds on the last — the order matters. No sign-up, no cost, no fluff. Just the concepts you need to design real systems.
Phase A — Request & Response · Modules 01–04
M.01
→
M.02
→
M.03
→
M.04
→
What is a System?
Strip away the jargon. We define system, trace one HTTP request end-to-end, and introduce the four atoms every system is built from: client, server, network, data store.
Client–Server
Why is there always an asker and an answerer? We explore the fundamental asymmetry of the client–server model — and what it costs in each direction.
HTTP & HTTPS
Every web interaction runs on HTTP. We cover methods (GET, POST, PUT, DELETE), status codes, headers, cookies, and how TLS turns HTTP into HTTPS.
REST APIs
How services talk to each other. We define REST, work through the constraints that make an API "RESTful", and cover versioning, pagination, and error formats.
Phase B — Storage & Speed · Modules 05–08
M.05
→
M.06
→
M.07
→
M.08
→
SQL vs NoSQL
Relational vs document vs key-value vs column stores. When each wins, when each loses, and how to make the call for a given system.
Indexes & B-Trees
Why some queries take 4ms and others take 4 seconds. We walk through B-tree structure, index types, composite indexes, and the cost of over-indexing.
Caching
Cache-aside, write-through, write-behind, TTL, cache stampedes, and invalidation. The patterns that make systems 10× faster and the bugs that make them wrong.
Latency & Throughput
Measuring what matters. Latency percentiles (p50, p99), throughput vs concurrency, Little's Law, and how they trade off against each other under load.
Phase C — Scale & Distribution · Modules 09–13
M.09
→
M.10
→
M.11
→
M.12
→
M.13
→
Scaling
Vertical vs horizontal scaling — when to buy a bigger machine and when to buy more machines. Sharding, replication, and the CAP theorem.
Load Balancing
Round-robin, least-connections, IP hash, consistent hashing. How to distribute traffic across servers and what happens when one goes down.
DNS
How a hostname becomes an IP address. The full resolver walk — root servers, TLD, authoritative — TTL, caching, and how DNS is used for load balancing.
CDNs
Edge servers, Points of Presence, origin pull vs push, cache-control headers. How content delivery networks serve users faster by serving them locally.
Statelessness
Why stateless servers can scale horizontally and stateful ones can't. Session affinity, where state actually lives, and how to design around it.
Phase D — Production Systems · Modules 14–16
M.14
→
M.15
→
M.16
→
Auth
Sessions, cookies, JWTs, OAuth 2.0, and API keys. How identity is established, maintained, and verified across stateless requests at scale.
Logging & Metrics
Structured logs, metrics, traces — the three pillars of observability. How to know what your system is doing in production before your users tell you it's broken.
Reliability
SLAs, SLOs, SLIs, error budgets, redundancy, failover, circuit breakers. The engineering practices that separate systems that stay up from systems that go down.
Phase E — Build & Apply · Modules 17–20
M.17
→
M.18
→
M.19
→
M.20
→
Build: URL Shortener
End-to-end architecture walk. We design a production URL shortener from scratch — hashing, storage, redirects, analytics, and scaling to millions of clicks.
Build: Image App
Design an Instagram-like image sharing system — upload pipelines, object storage, CDN delivery, async processing, and feed generation at scale.
Reading Architecture Diagrams
Master the C4 model — Context, Container, Component, Code. Learn to read any architecture doc in minutes and spot the six red flags that mean a diagram is lying to you.
Interview Toolkit
The framework, vocabulary, back-of-envelope estimates, and templates for any system design interview. Put everything together and walk in confident.