GuideIntermediate
System Design Fundamentals
Learn to design a distributed system from scratch and scale it with judgment, not memorized answers. This guide teaches the complete method — clarifying requirements, estimating capacity with back-of-the-envelope math, modeling data, adding caching, scaling the database, balancing load, and reasoning through reliability and consistency tradeoffs — using a single real case study from start to finish: Enlace, a URL shortener that starts as a single box and scales module by module into a full distributed design. Every number that appears is calculated and executed in Python (QPS, storage, hit ratio, consistent hashing), never quoted from memory. By the end, you can take a vague prompt like "design a URL shortener" and produce a defensible design with numbers, a diagram, and explicit tradeoffs — exactly what's expected in an architecture review or a system design technical interview.
- 64
- lessons
- 8
- modules
- English · Spanish
- available in
- Free
- access
Outcomes
What you'll be able to do
- Turn a vague prompt into concrete functional and non-functional requirements, and scope a first design
- Master back-of-the-envelope math: read/write QPS, multi-year storage, bandwidth, and working-set memory
- Design the data model and generate short, unique identifiers (hashing vs. counter+base62 vs. random)
- Add caching with judgment on the read-heavy path: cache-aside, eviction policies (LRU), hit ratio, and average latency
- Scale a database beyond a single machine with replication (primary/replica), sharding, and consistent hashing
- Balance load across stateless servers (round-robin, least-connections, hash-based) and decide where state lives
- Reason through the reliability of a distributed system: redundancy, single points of failure, basic failover, CAP/PACELC, and the strong-vs-eventual consistency tradeoff
- Design and defend a complete distributed system end to end: requirements, estimation, high-level diagram, read/write path, and a justified list of tradeoffs
Before you start
What you need to bring
It's for you if...
- Backend devs who want to move from "writing features" to designing systems that hold up at real scale
- Devs preparing for system design technical interviews (URL shorteners, feeds, messaging systems)
- Anyone who needs to defend a design with numbers in an architecture review, not just intuition
- Devs who already use caching, replicas, or load balancers by recipe and want the numerical reasoning behind each one
Requirements and materials
- Basic Python (able to read and follow the estimation and ID-generation snippets; no advanced proficiency needed)
- General knowledge of relational databases and HTTP/REST APIs
- No prior experience with distributed systems or large-scale architecture design required
Content
The syllabus, module by module
Open any of them to see its lessons.
- 1. Module introduction: understand the problem before you draw
- 2. Functional vs. non-functional requirements
- 3. Asking the right clarifying questions
- 4. Scoping: cut the problem down to size
- 5. The 4-step framework
- 6. Enlace in a single box
- 7. Thinking in tradeoffs and where the box breaks
- 8. Mini-project: from a vague prompt to requirements and scope
- 1. Module introduction: the napkin before the server
- 2. The tools: powers of 10, seconds per day, and units
- 3. QPS: from requests per month to requests per second
- 4. Storage: how much disk in five years
- 5. Bandwidth: how many bytes per second come in and out
- 6. Memory: the working set and why it fits in RAM
- 7. Smart rounding and sanity checks
- 8. Project: Enlace's capacity table
- 1. Module introduction: from the number to the model
- 2. The `Link` record
- 3. SQL vs NoSQL for Enlace
- 4. Generating the code with a hash: collisions measured
- 5. Global counter + base62 (and random + verification)
- 6. `base62_encode`/`base62_decode`, run
- 7. Choosing the strategy
- 8. Project: Enlace's `short_code` generator
- 1. Module introduction: when the single box no longer holds up
- 2. When one database is not enough
- 3. Replication: primary and replica
- 4. Replication lag and reading from replicas
- 5. Sharding and the shard key
- 6. The `hash(key) % N` problem
- 7. Consistent hashing, executed
- 8. Project: a sharding and replica plan for Enlace
- 1. Module introduction: when the machine goes down and the network splits
- 2. Redundancy and single points of failure
- 3. Failover basics
- 4. The CAP theorem, explained (without the myth)
- 5. PACELC: beyond CAP
- 6. Strong versus eventual consistency, and Enlace's choice
- 7. SLA, SLO and the nines, executed
- 8. Project: choose and justify Enlace's consistency model and its SLO
- 1. Module introduction: the journey back
- 2. Step 1 — Requirements and scope for Enlace
- 3. Step 2 — The capacity table, executed
- 4. Step 3 — High-level design and the diagram
- 5. Step 4a — The write path
- 6. Step 4b — The read path and the cache
- 7. Step 4c — Scaling out: replicas, sharding, load balancing and consistency
- 8. Project: design Enlace end to end
Common questions
What people usually ask
No limit. It's a free guide: come in whenever you like, as often as you like.
No. Modules run from easier to harder, but you can jump to the one you need. Progress is saved per lesson.
Whatever is needed is listed under “What you need to bring”, above. If nothing is listed there, you can start from zero.
In the Club's WhatsApp group, and every two weeks there's a live with an instructor where questions get worked through.
Start whenever you like
What students say
These reviews are from enrolled students who completed at least 50% of the course. We moderate reviews only on content grounds (spam, offensive language, personal data), never for being critical or negative.
No approved reviews yet.
Be the first to share your experience!