System Design Roadmap — 12 Weeks

Why Prior Engineering Experience Helps

If you already work with large applications like Odoo or similar ERP systems, you already know more than you think:

Modules → service decomposition thinking
ORM + PostgreSQL → data modeling, indexing, query optimization
Multi-company / multi-db → multi-tenancy patterns
Job queues (cron, queue_job) → async processing concepts
RPC / REST APIs → API design fundamentals

Use these anchors when new concepts feel abstract.

Phase 1 — Foundations (Weeks 1–3)

Goal: Understand the building blocks every system design assumes you know.

Client–server model, DNS, HTTP/HTTPS, TCP vs UDP
Load balancers (L4 vs L7, round-robin, least-connections)
Caching — where, eviction policies (LRU, LFU), cache invalidation
Databases — SQL vs NoSQL, ACID vs BASE
CAP theorem
Horizontal vs vertical scaling

Resources: System Design Interview Vol 1 Ch 1–5 (Alex Xu) · ByteByteGo YouTube

Phase 2 — Core Patterns (Weeks 4–7)

Goal: Patterns that appear in 90% of system design discussions.

SQL at scale — read replicas, sharding, connection pooling
Message queues — Kafka vs RabbitMQ, async decoupling
Rate limiting — token bucket, leaky bucket, sliding window
Consistent hashing — solves rebalancing in distributed caches
Indexes deep dive — B-tree, composite, covering indexes
API design — REST vs GraphQL vs gRPC, pagination, versioning
Blob / object storage — S3 model, when NOT to use PostgreSQL for files
Search — Elasticsearch, full-text vs structured

Resources: Alex Xu Vol 1 Ch 6–13 · Designing Data-Intensive Applications Ch 1–5 (Kleppmann)

Phase 3 — Distributed Systems (Weeks 8–12)

Goal: Reason about systems that span multiple machines and fail independently.

Replication — leader-follower, multi-leader, leaderless
Consensus — Raft basics (understand the problem, not the implementation)
Distributed transactions — 2PC, saga pattern
Event sourcing + CQRS
Microservices trade-offs — when monolith wins
Service mesh basics — sidecar, service discovery
Observability — metrics, logs, traces, OpenTelemetry

Resources: DDIA Ch 6–9 · Martin Fowler’s blog · MIT 6.824 lectures (free)

Phase 4 — Design Practice (Ongoing from Week 6)

The 45-Minute Framework

0–5 min    Clarify requirements — scale, users, core features
5–15 min   High-level design — boxes and arrows, happy path only
15–25 min  Deep dive — pick 2 hard components, go deep
25–35 min  Bottlenecks — what breaks at 10x load?
35–45 min  Trade-offs — what did you give up?

Systems to Design (in order of difficulty)

URL shortener
Pastebin / note sharing
Rate limiter
Key-value store
Unique ID generator
Web crawler
Notification system
News feed (Twitter/Facebook)
Chat system (WhatsApp)
Video upload + streaming (YouTube)
Multi-tenant SaaS ERP — 10,000 tenants

Reference Card

Latency Numbers

Operation	Latency
L1 cache hit	~1 ns
RAM read	~100 ns
SSD read	~100 µs
Network roundtrip (same DC)	~500 µs
Disk seek	~10 ms
Network roundtrip (cross-continent)	~150 ms

Scale Numbers

Unit	Value
1 million req/day	~12 req/sec
1 billion req/day	~12,000 req/sec

When To Use What

Need	Tool
Fast reads, key lookup	Redis / Memcached
Full-text search	Elasticsearch
High-throughput event streaming	Kafka
Relational + ACID	PostgreSQL
Flexible schema, horizontal scale	MongoDB / DynamoDB
Async job processing	RabbitMQ / Celery

Scalability Checklist

What’s the read/write ratio?
What data must never be lost?
What can tolerate eventual consistency?
Where is the single point of failure?
What’s the bottleneck at 10x current load?

Book Order

System Design Interview Vol 1 — Alex Xu
System Design Interview Vol 2 — Alex Xu
Designing Data-Intensive Applications — Kleppmann
Building Microservices — Sam Newman (optional)