All roadmaps
Roadmap

System Design

From first principles to staff-level system design mastery, the complete interview preparation path.

18stages166topics~22hours

Curated from the best, MDN · Kubernetes · AWS · OWASP · Google SRE & more

Essential for senior and staff roles. Skills: architecture blueprints, scalability, load balancers, caches, databases, CDNs, queues, monitoring, and security measures.

The complete path, 15 of 166 topics have lessons here; the other 151 are marked learn anywhere. We won't pretend we cover everything.

Ready to build? See capstone projects
01
Stage 1 / 18 · 9 topics · 0 lessons

System Design Foundations

The mental models and vocabulary every design conversation assumes. Start here before touching any component.

What System Design Interviews TestSignal hiring managers seek: structured thinking, trade-offs, communication, not memorized answers. System Design Primer
Functional vs Non-Functional RequirementsSeparate features from qualities like latency, availability, durability, and scalability. Wikipedia
Scalability: Vertical vs HorizontalScaling up a machine versus scaling out across many; cost and limit trade-offs. Azure Architecture Center
Latency, Throughput, and Tail LatencyDistinguish response time, request rate, and p99/p999 tail behavior. AWS Builders Library
Latency Numbers Every Engineer KnowsMemory, SSD, disk, and cross-datacenter timings used for back-of-envelope reasoning. Interactive Latency Numbers
Back-of-the-Envelope EstimationEstimate QPS, storage, bandwidth, and server counts quickly and defensibly. System Design Primer
Powers of Two and Data UnitsrecKB/MB/GB/TB/PB intuition for sizing storage and memory. System Design Primer
Availability vs Reliability vs DurabilityNines of uptime, mean time between failures, and never-lose-data guarantees. Google SRE Book
Single Points of FailureIdentify and eliminate components whose failure takes the whole system down. Wikipedia
02
Stage 2 / 18 · 10 topics · 0 lessons

Networking and Communication Fundamentals

How bytes actually move between machines. Underpins every distributed design decision.

OSI and TCP/IP ModelsrecLayered networking model and where each protocol lives. Cloudflare Learning
TCP vs UDPReliable ordered streams versus low-latency connectionless datagrams. Cloudflare Learning
DNS ResolutionHow hostnames resolve to IPs, caching, TTLs, and DNS-based routing. Cloudflare Learning Lab
HTTP, HTTPS, and TLSRequest/response semantics, methods, status codes, and encrypted transport. Cloudflare Learning
HTTP/1.1, HTTP/2, HTTP/3recKeep-alive, multiplexing, head-of-line blocking, and QUIC over UDP. MDN
TLS Handshake and CertificatesoptionalKey exchange, certificate chains, and the cost of connection setup. Cloudflare Learning
WebSockets and Long PollingPersistent bidirectional channels versus polling for real-time updates. MDN
Server-Sent EventsrecOne-way server push over HTTP for streaming updates to clients. MDN
RPC and gRPCRemote procedure calls, Protobuf serialization, and streaming RPCs. gRPC docs
Forward and Reverse ProxiesrecIntermediaries for routing, caching, security, and load distribution. Wikipedia
03
Stage 3 / 18 · 9 topics · 0 lessons

API Design

The contract between clients and services. Interviewers expect clean, evolvable interfaces.

RESTful API DesignResource modeling, HTTP verbs, statelessness, and idempotency. restfulapi.net
GraphQLrecClient-specified queries, single endpoint, over/under-fetching trade-offs. GraphQL docs
gRPC for Service APIsrecSchema-first contracts and efficient binary communication between services. gRPC docs
Pagination StrategiesOffset versus cursor-based pagination and their consistency trade-offs. Azure Architecture Center
Idempotency and RetriesIdempotency keys and safe retry semantics for at-least-once delivery. Wikipedia
API Versioning and EvolutionrecBackward-compatible changes, deprecation, and version negotiation. Postman
Rate Limiting and ThrottlingProtecting APIs with quotas and graceful degradation. Cloudflare Learning
API GatewayCentralized auth, routing, aggregation, and cross-cutting concerns. Azure Architecture Center
Webhooks and CallbacksoptionalServer-to-server event notifications with signing and retries. Wikipedia
04
Stage 4 / 18 · 13 topics · 0 lessons

Databases and Storage

Where state lives. Choosing and modeling the right store is the heart of most designs.

SQL vs NoSQLRelational guarantees versus flexible schemas and horizontal scale. PostgreSQL docs
Relational Modeling and NormalizationSchema design, normal forms, and deliberate denormalization. Wikipedia
ACID TransactionsAtomicity, consistency, isolation, durability and what each protects. Wikipedia
Transaction Isolation LevelsrecRead committed, repeatable read, serializable, and the anomalies each allows. PostgreSQL docs
Indexing and B-TreesHow indexes accelerate reads and the write cost they impose. Use The Index, Luke
LSM Trees and Write-Optimized StoresrecLog-structured merge trees behind Cassandra, RocksDB, and friends. Wikipedia
NoSQL Data ModelsKey-value, document, wide-column, and graph stores and their fits. MongoDB
Key-Value StoresRedis and DynamoDB-style stores for fast lookups and caching. Redis docs
Wide-Column and Columnar StoresrecCassandra for writes; columnar formats for analytics. Apache Cassandra docs
Time-Series DatabasesoptionalSpecialized stores for metrics and high-ingest temporal data. Wikipedia
Graph DatabasesoptionalModeling and traversing highly connected relationship data. Neo4j docs
Blob and Object StorageS3-style storage for large immutable files and media. AWS docs
Connection PoolingrecReusing database connections to bound resource usage. Wikipedia
05
Stage 5 / 18 · 8 topics · 0 lessons

Caching

Trading freshness for speed. Caches appear in nearly every scalable design.

Why and Where to CacheClient, CDN, application, and database layer caching opportunities. AWS
Cache-Aside, Read-Through, Write-ThroughPopulation patterns and their consistency and latency trade-offs. AWS docs
Write-Back and Write-AroundrecDeferred and bypass write patterns for hot and cold data. AWS docs
Eviction PoliciesLRU, LFU, FIFO, and TTL-based expiration trade-offs. Redis docs
Cache InvalidationKeeping cached data correct, one of the hard problems. Martin Fowler
Distributed CachingSharded Redis/Memcached clusters and consistent hashing of keys. Redis docs
Thundering Herd and StampederecRequest coalescing, locks, and early expiration to protect origins. Wikipedia
Hot Keys and Cache SkewrecDetecting and mitigating disproportionately popular keys. AWS docs
06
Stage 6 / 18 · 5 topics · 0 lessons

CDNs and Edge Delivery

Pushing content and compute close to users for global low latency.

How CDNs WorkGeographically distributed edge caches for static and dynamic content. Cloudflare Learning
Push vs Pull CDNsrecPre-loading origin content versus lazy on-demand caching. Cloudflare Learning
Cache-Control and Edge TTLsrecHTTP headers governing freshness and revalidation at the edge. MDN
Edge ComputeoptionalRunning logic at edge POPs for personalization and latency. Cloudflare docs
Anycast RoutingoptionalRouting users to the nearest POP via shared IP advertisement. Wikipedia
07
Stage 7 / 18 · 7 topics · 0 lessons

Load Balancing and Traffic Management

Distributing requests across servers while keeping traffic healthy and balanced.

Load Balancer FundamentalsSpreading traffic to improve throughput and fault tolerance. Cloudflare Learning
Layer 4 vs Layer 7 Load BalancingTransport-level versus application-aware routing decisions. Cloudflare Learning
Load Balancing AlgorithmsRound-robin, least-connections, weighted, and consistent hashing. Cloudflare Learning
Health Checks and FailoverDetecting unhealthy nodes and removing them from rotation. AWS docs
Session AffinityrecSticky sessions versus stateless servers for session handling. AWS docs
Global Server Load BalancingrecDNS and geo-routing to balance across regions. Cloudflare Learning
AutoscalingReactive and predictive scaling of compute to match demand. AWS docs
08
Stage 8 / 18 · 12 topics · 0 lessons

Distributed Systems Fundamentals

The theory that explains why distributed systems behave the way they do. Staff interviews probe this deeply.

CAP TheoremConsistency, availability, partition tolerance, pick two under partition. Wikipedia
PACELC TheoremrecExtends CAP with latency-versus-consistency trade-offs absent partitions. Wikipedia
Consistency ModelsStrong, eventual, causal, read-your-writes, and monotonic guarantees. Jepsen
Eventual ConsistencyConvergence over time and the application implications it carries. Wikipedia
Consensus: Paxos and RaftAgreeing on a value across nodes despite failures. Raft
Quorums and N/R/WTuning read/write quorums for consistency-availability balance. Wikipedia
Leader ElectionrecChoosing a coordinator and handling leader failure. AWS Builders Library
Logical and Vector ClocksrecOrdering events without synchronized physical clocks. Wikipedia
Gossip ProtocolsrecEpidemic dissemination of state for membership and failure detection. Wikipedia
CRDTsoptionalConflict-free replicated data types for mergeable distributed state. crdt.tech
Two Generals and FLP ImpossibilityoptionalFundamental limits on agreement over unreliable networks. Wikipedia
Exactly-Once vs At-Least-OnceDelivery semantics and why exactly-once is really effectively-once. AWS Builders Library
09
Stage 9 / 18 · 9 topics · 1 lessons

Partitioning and Replication

Splitting and copying data to scale beyond one machine while surviving failures.

Sharding FundamentalsHorizontal partitioning of data across nodes. MongoDB docs
Range vs Hash PartitioningTrade-offs in range scans, hotspots, and rebalancing. Azure Architecture Center
Consistent HashingStart hereMinimizing key movement when nodes join or leave.
Virtual NodesrecSmoothing load distribution within consistent hashing rings. Apache Cassandra docs
Resharding and RebalancingrecMoving partitions as the cluster grows without downtime. Azure Architecture Center
Leader-Follower and Multi-Leader ReplicationSingle-writer, multi-writer, and leaderless replication models. PostgreSQL docs
Synchronous vs Asynchronous ReplicationDurability versus latency in replication lag trade-offs. PostgreSQL docs
Read Replicas and Replica LagScaling reads while managing staleness. AWS docs
Hotspots and SkewrecDetecting and mitigating uneven partition load. Azure Architecture Center
10
Stage 10 / 18 · 9 topics · 0 lessons

Asynchronous Messaging and Streaming

Decoupling producers from consumers for resilience, scale, and event-driven design.

Message QueuesDecoupling work with queues like SQS and RabbitMQ. AWS
Publish-SubscribeFan-out delivery to multiple independent consumers. AWS docs
Log-Based Streaming (Kafka)Durable partitioned logs, offsets, and consumer groups. Apache Kafka docs
Delivery GuaranteesAt-most, at-least, and effectively-once in messaging systems. Apache Kafka docs
Dead-Letter Queues and RetriesrecHandling poison messages and backoff strategies. AWS docs
Backpressure and Flow ControlrecProtecting consumers from overload and unbounded queues. Reactive Manifesto
Message OrderingrecPartition-level ordering and the cost of global ordering. AWS docs
Stream ProcessingrecWindowing, watermarks, and stateful processing with Flink/streams. Apache Kafka docs
Change Data CaptureoptionalStreaming database changes to downstream systems. Debezium docs
11
Stage 11 / 18 · 11 topics · 2 lessons

Architecture Patterns

Proven structural approaches for organizing services and data flows.

Monolith vs MicroservicesTrade-offs in coupling, deployment, and operational complexity.
Service Decomposition and BoundariesDrawing boundaries by domain to minimize coupling. microservices.io
Event-Driven ArchitectureReacting to events for loose coupling and scalability. Martin Fowler
Event SourcingrecPersisting state as an immutable sequence of events. Martin Fowler
CQRSrecSeparating read and write models for independent scaling. Martin Fowler
Saga PatternManaging distributed transactions via choreography or orchestration. microservices.io
Two-Phase CommitrecCoordinated atomic commit and why it is often avoided at scale. Wikipedia
Transactional OutboxrecReliably publishing events alongside database writes. microservices.io
Backend-for-FrontendoptionalTailored API layers per client type. Azure Architecture Center
Service MeshoptionalSidecar-managed service-to-service networking and observability.
Serverless and FaaSrecEvent-triggered compute with cold starts and statelessness. AWS docs
12
Stage 12 / 18 · 11 topics · 2 lessons

Reliability, Resilience, and Fault Tolerance

Designing systems that degrade gracefully and recover from inevitable failures.

Redundancy and Replication for HAEliminating single points of failure through duplication. AWS Well-Architected
Failover and FailbackSwitching to standby resources and recovering afterward. AWS Builders Library
Circuit BreakersStopping cascading failures by failing fast on unhealthy dependencies. Martin Fowler
Bulkheads and IsolationrecContaining failures to a subset of resources. Azure Architecture Center
Retries, Backoff, and JitterSafe retry policies that avoid retry storms. AWS Builders Library
Timeouts and DeadlinesBounding waits and propagating deadlines across calls. AWS Builders Library
Graceful DegradationShedding load and serving reduced functionality under stress. Google SRE Book
Load Shedding and Rate LimitingrecProtecting systems by rejecting excess work early. AWS Builders Library
Idempotent RecoveryrecDesigning operations safe to retry after partial failure. AWS Builders Library
Chaos EngineeringoptionalProactively injecting failures to validate resilience.
Disaster Recovery and RPO/RTOrecBackup strategies and recovery objectives across regions. Lab
13
Stage 13 / 18 · 9 topics · 0 lessons

Security and Privacy

Protecting data and access. Increasingly expected in senior design discussions.

Authentication vs AuthorizationVerifying identity versus granting permissions. Auth0 docs
OAuth 2.0 and OpenID ConnectDelegated authorization and federated identity flows. OAuth.net
JWTs and Session ManagementToken-based versus server-side sessions and their trade-offs. jwt.io
Encryption in Transit and at RestTLS, disk encryption, and key management basics. Cloudflare Learning
Secrets ManagementrecStoring and rotating credentials and keys securely. HashiCorp Vault docs
DDoS Protection and WAFrecDefending against volumetric and application-layer attacks. Cloudflare Learning
Common VulnerabilitiesrecInjection, XSS, CSRF, and SSRF and their mitigations. OWASP
Zero-Trust and mTLSoptionalNever-trust-always-verify service-to-service security. Cloudflare Learning
Privacy, PII, and ComplianceoptionalGDPR, data residency, and handling sensitive data. GDPR.eu
14
Stage 14 / 18 · 8 topics · 2 lessons

Observability and Operations

You cannot operate what you cannot see. Strong candidates design for visibility from day one.

Structured LoggingSearchable, correlated logs across distributed services. OpenTelemetry docs
Metrics and the Four Golden SignalsLatency, traffic, errors, and saturation monitoring. Google SRE Book
Distributed TracingFollowing a request across services to find bottlenecks. OpenTelemetry docs
Alerting and On-CallrecActionable alerts, thresholds, and reducing fatigue. Prometheus docs
SLIs, SLOs, and Error BudgetsQuantifying reliability targets and spending failure budgets.
Health Checks and HeartbeatsrecLiveness and readiness probes for orchestration. Azure Architecture Center
Deployment StrategiesrecBlue-green, canary, and rolling deployments. Lab
Feature FlagsoptionalDecoupling deploy from release and enabling safe rollout. Martin Fowler
15
Stage 15 / 18 · 7 topics · 0 lessons

Search, Analytics, and Big Data

Serving queries and crunching data at scale, common in design prompts.

Search and Inverted IndexesFull-text search internals behind Elasticsearch and Lucene. Wikipedia
Relevance and RankingrecScoring and ordering search results. Elastic docs
OLTP vs OLAPTransactional versus analytical workload characteristics. AWS
Data Warehouses and LakesrecCentralized analytical storage and schema-on-read lakes. AWS
Batch Processing and MapReducerecLarge-scale offline computation patterns. Wikipedia
Lambda and Kappa ArchitecturesoptionalCombining or unifying batch and streaming pipelines. Azure Architecture Center
ETL and ELT PipelinesoptionalMoving and transforming data between systems. AWS
16
Stage 16 / 18 · 8 topics · 0 lessons

Algorithms and Data Structures for Scale

Specialized structures that power large systems efficiently.

Bloom FiltersProbabilistic membership tests with no false negatives. Wikipedia
HyperLogLogrecApproximate cardinality counting in tiny memory. Wikipedia
Count-Min SketchoptionalApproximate frequency counting for heavy hitters. Wikipedia
Merkle TreesrecEfficient verification and anti-entropy of replicated data. Wikipedia
Geohashing and QuadtreesrecSpatial indexing for location-based queries. Wikipedia
Rate Limiter AlgorithmsToken bucket, leaky bucket, and sliding window counters. Wikipedia
Unique ID GenerationSnowflake IDs, UUIDs, and distributed sequence generators. Wikipedia
Consistent Hash Ring InternalsrecImplementing the ring with virtual nodes and lookups. Wikipedia
17
Stage 17 / 18 · 9 topics · 0 lessons

The Interview Framework and Method

A repeatable structure to drive any design interview with confidence.

Clarify Requirements and ScopeAsk questions, define functional and non-functional needs, set scope. System Design Primer
Estimate Scale and ConstraintsCompute QPS, storage, and bandwidth to drive decisions. System Design Primer
Draw the High-Level DesignSketch core components and data flow end to end. System Design Primer
Define APIs and Data ModelSpecify interfaces and schema before deep dives. System Design Primer
Deep Dive on BottlenecksDrill into the hardest component and justify choices. System Design Primer
Articulating Trade-offsName alternatives and defend decisions explicitly. System Design Primer
Identify and Resolve BottlenecksIteratively scale the design as load grows. System Design Primer
Communication and WhiteboardingThinking aloud, structuring, and collaborating with the interviewer. Google SRE Book
Senior vs Staff SignalsrecDepth, ambiguity handling, and org-level impact expectations. StaffEng
18
Stage 18 / 18 · 12 topics · 8 lessons

Canonical Case Studies

Practice on the classic prompts. Each rehearses patterns from earlier sections end to end.

Design a URL ShortenerID generation, redirects, and read-heavy caching.
Design a Rate LimiterDistributed token buckets and counter storage.
Design a News FeedFan-out on write versus read and feed ranking.
Design a Chat / Messaging SystemWebSockets, presence, delivery guarantees, and ordering.
Design Search AutocompleterecTrie-based suggestions with ranking and caching.
Design a Ride-Sharing / Geo ServicerecGeospatial indexing and real-time matching. System Design Primer
Design a Video Streaming PlatformrecTranscoding pipelines, CDNs, and adaptive bitrate.
Design a Notification SystemMulti-channel fan-out with retries and rate limits.
Design a Distributed CacherecSharding, eviction, and consistency at scale. System Design Primer
Design a Cloud Object StoreoptionalDurability, metadata service, and replication. AWS docs
Design a Payment SystemrecIdempotency, ledgers, consistency, and reconciliation. Stripe Guides
Design a File Storage / Sync ServiceoptionalChunking, dedup, sync, and conflict resolution.

You're job-ready.

Clear every stage, earn the certificate, and walk into interviews prepared. The complete path, nothing hidden, no gaps.

Destination reached