The System Design Roadmap
In short
A system design roadmap is the order in which to learn how large software systems are built. Start with the basics: latency, throughput, load balancing, caching and databases. Then learn how real services connect, through replication, APIs, messaging, microservices and the cloud. Finish with distributed systems, consistency models, stream processing and reliability, then practise by designing complete systems.
Most people learning system design get stuck on the same problem: they do not know what to learn, or in what order. This roadmap fixes that. It lays out the entire field as a single ordered path, from your first request and response all the way to distributed consensus and keeping a system alive under failure. Every topic links to real lessons, so you can start anywhere and always know what comes next.
23Topics
770Lessons
4Levels
stop 1
Foundation
The building blocks every system rests on. Master these before anything else.
Core Fundamentals
26 lessonsLatency vs ThroughputVertical vs Horizontal ScalingStateless vs StatefulCaching & Load BalancingIdempotency & Timeouts
Explore Core Fundamentals Load Balancing and Proxies
26 lessonsDNS and routing basicsLoad balancer algorithmsForward vs reverse proxyRouting strategiesSessions and affinity
Explore Load Balancing and Proxies Caching Strategies
36 lessonsCache layers and placementRead patterns (cache-aside, read-through)Write patterns (write-through, write-back)TTL, eviction, and invalidationStampede prevention
Explore Caching Strategies Database Fundamentals
31 lessonsIndexing & B-TreesNormalization vs DenormalizationQuery OptimizationViews & Materialized ViewsReplication & Read Replicas
Explore Database Fundamentals stop 2
Intermediate
How real services are built, connected, deployed, and secured.
Database Types and Storage
39 lessonsStorage layers: file, block, object, blobRow vs columnar storageNoSQL families: key-value, document, graphSearch and inverted indexesVector databases and ANN
Explore Database Types and Storage Data Replication and Distribution
31 lessonsSync vs Async ReplicationReplication LagReplication TopologiesActive-Active vs Active-PassiveConsistent Hashing
Explore Data Replication and Distribution API Design and Protocols
28 lessonsREST vs GraphQL vs gRPCBinary encodings (Protobuf, Avro)Rate limiting algorithmsIdempotency and safe retriesAPI versioning
Explore API Design and Protocols Messaging and Event Systems
41 lessonsMessage Queues and Pub/SubDelivery GuaranteesIdempotency and DeduplicationDead Letter and Poison MessagesWebSockets and SSE
Explore Messaging and Event Systems Microservices Architecture
36 lessonsMonolith vs MicroservicesDomain-Driven Design & Bounded ContextsDatabase per ServiceResilience PatternsService Discovery & Mesh
Explore Microservices Architecture Cloud Infrastructure
45 lessonsVPC and SubnetsCIDR and IP AddressingNAT and GatewaysIaaS / PaaS / SaaSServerless and Cold Start
Explore Cloud Infrastructure Kubernetes and Containers
22 lessonsContainers and imagesRegistries and versioningDeclarative orchestrationControllers and reconciliationWorkload types
Explore Kubernetes and Containers Web Content Delivery
31 lessonsRendering: CSR, SSR, SSG, ISRCompression (Gzip, Brotli)Image optimization & formatsLazy & responsive loadingBrowser storage & service workers
Explore Web Content Delivery DevOps and CI/CD
36 lessonsContinuous IntegrationContinuous Delivery vs DeploymentBranch Strategies and Version ControlBuild and Test AutomationBlue-Green, Canary, Rolling
Explore DevOps and CI/CD Security Architecture
57 lessonsAuthenticationAuthorization and access controlEncryption at rest and in transitTLS, certificates and PKIOAuth, SSO and federation
Explore Security Architecture Observability and Monitoring
60 lessonsLogs, Metrics, TracesGolden Signals (RED & USE)SLI / SLO / SLAError BudgetsMTTD / MTTA / MTTR
Explore Observability and Monitoring Data Governance and Compliance
23 lessonsValidation and Schema ChecksData Quality and ProfilingCleansing and TransformationPII HandlingMasking vs Anonymization vs Pseudonymization
Explore Data Governance and Compliance stop 3
Advanced
The hard parts: distributed coordination, consistency, scale, and staying up.
Distributed Systems Core
24 lessonsCAP theorem and partitionsConsensus and quorumLeader election and locksLogical clocks and orderingReplica repair (gossip, read repair)
Explore Distributed Systems Core Consistency Models
21 lessonsLinearizabilitySequential & Causal ConsistencySession Guarantees (read-your-writes)SerializabilitySnapshot Isolation
Explore Consistency Models Stream and Batch Processing
36 lessonsBatch vs StreamingETL and ELTWindowingWatermarks and Late DataStateful Processing
Explore Stream and Batch Processing Data Engineering
4 lessonsWarehouse vs lake vs lakehouseTransaction log and commitsDelta Lake, Iceberg and HudiTime travel and cleanupSmall files and compaction
Explore Data Engineering Reliability and Resilience
85 lessonsAvailability and SLOsBackups and Disaster RecoveryFailover StrategiesResilience PatternsIncident Response
Explore Reliability and Resilience Security Testing and Operations
12 lessonsCode ReviewsSAST and Static AnalysisSCA and Dependency RiskDAST and Vulnerability ScanningPenetration Testing
Explore Security Testing and Operations stop 4
Capstone
Put it all together by designing complete systems end to end.
Where to go next
- System design notes for every topic on this roadmap
Revise the key points of all the stages on one page.
- Design a URL shortener, the classic first interview problem
Short IDs, a read-heavy database, caching and redirects.
- Design a distributed job scheduler
Firing timed and cron jobs on time without running them twice.
- Cache-aside, the most common caching pattern
Check the cache first, read the database on a miss.
- Write-ahead log, how databases survive a crash
Changes go to a log before they reach the data.
- Design a rate limiter, the API gateway classic
Token bucket vs sliding window, counted correctly across many servers.
- Design a notification system
Push, SMS and email through queues, with retries that never send twice.
- Design Ticketmaster
Selling scarce seats in a rush without selling one twice.
New explainers on AI tools and models
all explainersFrequently asked questions
- What is the best roadmap for system design?
- A good roadmap teaches each idea before the ideas that depend on it, and ends with practice on full designs. Caching is hard to follow before you know what latency is, and consensus is hard to follow before replication. This roadmap follows that rule across 23 topics in 4 stages, and the last stage is capstone projects where you design complete systems end to end.
- Where should a beginner start learning system design?
- Begin with the Core Fundamentals topic. Latency is how long one request takes, and throughput is how many requests a system handles per second, and many later topics are about improving one or both. After that, move on to load balancing, caching and database basics. The first 18 Foundation lessons are free with no signup.
- What is a good first system design interview problem?
- Designing a URL shortener, like TinyURL or bit.ly, is the usual warm-up. It is small enough to finish in one sitting, yet it covers how to generate short IDs without collisions, which database suits a read-heavy workload, caching, and click analytics. Try it once you have finished the Foundation stage.
- What order should I learn system design in?
- Start with the foundations: core metrics like latency and throughput, load balancing, caching, and databases. Then move to how real services are built and connected: storage types, replication, APIs, messaging, microservices, and cloud infrastructure. Finish with the advanced material: distributed systems, consistency models, stream processing, and reliability. This roadmap orders all 23 topics that way so you never wonder what comes next.
- How long does it take to learn system design?
- With steady effort, the foundations take one to two weeks, the intermediate topics take three to four weeks, and the advanced material takes another two to three weeks. If you want a fixed schedule, the 30-day plan maps this roadmap to a day-by-day study guide.
- Is this system design roadmap free?
- The roadmap and the first 18 foundation lessons are free with no signup. Full access to all 770 lessons is a one-time payment of 499 rupees in India or $49 worldwide, with no subscription.
- Do I need a computer science degree to follow this?
- No. The roadmap starts from absolute fundamentals and explains every term in plain language before using it. Career switchers and self-taught developers follow the same path as CS graduates.
Start at the beginning, for free
18 Foundation lessons are free with no signup. Full lifetime access to all 770 lessons is 499 rupees in India or $49 worldwide, one payment, no subscription.