Coders {cookies} · Open-source skills, free for everyone

Overview

This track restructures your system design roadmap into stages and adds low level design and a reusable interview framework. It assumes basic networking, SQL, one backend language, and REST. Each stage builds intuition for why systems are designed the way they are, then moves to distributed components and real architectures. Use the drawing canvas in the app to diagram every design you study.

Prerequisites

0 of 5

Networking: HTTP and HTTPS, TCP and UDP, DNS, how a request travels
Databases: SQL queries, indexes, basic CRUD
One backend language at a working level
REST APIs: building and consuming
Linux basics and git

Stage 1: Beginner foundations (weeks 1 to 4)

Week 1: Scale and performance

0 of 3

Vertical versus horizontal scaling and stateless design
Latency versus throughput, bottlenecks
Availability, uptime targets, and redundancy

Week 2: Traffic distribution and caching

0 of 3

Load balancing: round robin, least connections, sticky sessions, layer four versus layer seven
Caching: cache aside, write through, TTL, Redis basics
DNS and content delivery networks, edge nodes, cache invalidation

Week 3: API design

0 of 3

REST versus GraphQL
Versioning, idempotency, pagination
Rate limiting basics

Week 4: Beginner designs

Build

Design a URL shortener, a pastebin, a rate limiter, and a tiny URL service

Stage 2: Intermediate distributed components (weeks 5 to 10)

Week 5: Databases and storage

0 of 2

SQL versus NoSQL and when to use each
ACID, indexing strategies, connection pooling

Week 6: Sharding and replication

0 of 2

Horizontal sharding
Read replicas and leader follower replication

Week 7: Consistency and the CAP theorem

0 of 2

Consistency, availability, partition tolerance trade offs
Consistency models: strong, eventual, causal, read your writes

Week 8: Messaging and microservices

0 of 3

Message queues: Kafka, RabbitMQ, publish and subscribe
At least once versus exactly once
Service decomposition, inter service communication, service mesh

Week 9: Resilience

0 of 2

Rate limiting: token bucket, leaky bucket, sliding window
Fault tolerance: retries, circuit breakers, bulkheads, timeouts

Week 10: Intermediate designs

Build

Design Instagram, WhatsApp, a Twitter feed, and Dropbox

Stage 3: Advanced architecture (weeks 11 to 16)

Week 11: Distributed systems

0 of 2

Consensus: Raft and Paxos
Distributed transactions: two phase commit and saga

Week 12: Event driven architecture

0 of 1

Event sourcing, CQRS, the outbox pattern, idempotent consumers

Week 13: Observability and search

0 of 2

Metrics, tracing with OpenTelemetry, logging, alerting, dashboards
Search systems: inverted indexes, Elasticsearch, relevance scoring, sharding search

Week 14: Security and capacity

0 of 2

Auth with OAuth2 and JWT, zero trust, secrets management, mutual TLS
Capacity planning: estimating queries per second, storage, bandwidth, back of the envelope math

Week 15: Reliability and trade offs

0 of 3

Service level indicators, objectives, and agreements
Chaos engineering, disaster recovery, multi region
Read heavy versus write heavy, strong versus eventual consistency

Week 16: Advanced designs

Build

Design Google Maps, Uber, YouTube, and a notification service

Low level design supplement

Object oriented design

0 of 4

SOLID principles applied to design
Design patterns: factory, strategy, observer, singleton, decorator, adapter
Class diagrams and responsibilities
Common LLD problems: parking lot, elevator, a vending machine, a rate limiter, a logging library, an in memory key value store, a movie booking system

Build

Design and implement two low level design problems with clean class structure

The interview framework

Use this for every design question. The phases are requirements, estimates, system interface, high level design, architecture deep dive, data model, and edge cases and failures.

Time split for a forty five minute interview:

Requirements and estimates: five minutes

High level diagram: ten minutes

Deep dive on two components: twenty minutes

Trade offs and failure modes: ten minutes

What interviewers look for: structured thinking, trade off awareness, failure thinking, estimation confidence, and clear communication.

Mistakes to avoid: jumping to a solution before clarifying requirements, over engineering for day one, ignoring failure modes, using buzzwords without justification, staying high level without one deep dive, and not asking clarifying questions.

Hands on projects

Build

A URL shortener, a rate limiter middleware, a job queue system, a key value store, a paste sharing app, a real time chat app, a notification service, a search autocomplete, a distributed task scheduler, an event driven order system, a multi tenant platform, and an AI agent orchestrator

Resource master reference

Books in reading order

Understanding Distributed Systems by Roberto Vitillo

System Design Interview Volume 1 by Alex Xu

Designing Data Intensive Applications by Martin Kleppmann

System Design Interview Volume 2 by Alex Xu

Software Architecture The Hard Parts by Neal Ford and others

Video resources

ByteByteGo by Alex Xu

Gaurav Sen

the freeCodeCamp system design course

Hello Interview

Repositories

the System Design Primer by donnemartin

System Design 101 by ByteByteGo

Interview focus

Common questions

Design a URL shortener

Design WhatsApp or Messenger

Design a news feed like Twitter

Design YouTube

Design a notification system

Design a distributed cache

Design a rate limiter

Design a payment system

Design Google Drive or Dropbox

Design a search engine