System Design
The Ultimate System Design Roadmap: 120 Topics to Master Every Interview
Master system design interviews with this comprehensive roadmap covering 120 essential topics across 14 categories.
Why Most Engineers Fail System Design Interviews
You've read "Designing Data-Intensive Applications." You've watched hours of YouTube tutorials. You've even designed a few systems at work.
But when the interviewer asks you to "design Twitter" or "design a URL shortener," you freeze.
Here's the brutal truth: System design interviews aren't about memorizing specific architectures. They're about mastering fundamental building blocks and knowing when to apply them.
What if you had a complete roadmap of every concept that actually matters — organized, structured, and ready to learn?
That's exactly what this guide delivers.
What You'll Learn
This comprehensive roadmap breaks down 120 essential system design topics organized into 14 fundamental categories that form the backbone of every scalable system at companies like Google, Meta, Amazon, and Netflix.
By the end, you'll not only understand these concepts but also know how to practice them interactively with AI coaching — where you can draw architecture diagrams, get real-time feedback, and simulate actual system design interviews.
What Is a System Design Roadmap?
Think of this roadmap as your complete knowledge graph for system design mastery.
Instead of randomly jumping between load balancers, databases, and caching, you follow a structured path that builds knowledge progressively - from foundational service architectures to advanced distributed consensus algorithms.
Example Flow:
- Start with Client-Server Architecture → Learn API Gateways → Master Load Balancing → Understand Database Replication → Apply to Real-World Case Studies
This systematic approach is exactly how senior engineers at top tech companies prepare. They don't cram - they build mental models through structured learning.
The 14 Core Categories: Your Learning Path
Each category represents a critical pillar of modern system design. Below, we break down all 14 categories with their essential topics.
1. Client-Server & Service Architectures (6 Topics)
Foundation: Understanding how services are structured and communicate
Essential Topics:
- Single-tier vs multi-tier (2-tier, 3-tier, n-tier): Evolution of application layers and separation of concerns
- Stateless vs stateful services (implications on scaling): Why stateless services scale horizontally; when state is necessary
- Synchronous vs asynchronous communication patterns: Blocking vs non-blocking calls, event-driven architectures
- Thin client vs thick client trade-offs: Where to put business logic and computation
- Monolithic service vs microservices vs modular monolith: Architecture evolution, when to split services
- Service discovery mechanisms: How services find each other dynamically (Consul, Eureka, etcd)
Why This Matters: Every system starts here. Understanding service architecture determines your scalability ceiling.
Real Interview Question: "Design a multi-tenant SaaS application. How would you architect the services?"
Practice with AI: Use Thita.ai's interactive canvas to draw service boundaries and get instant feedback on your architectural decisions.
Explore Service Architectures →
2. API Gateway & Communication Patterns (6 Topics)
Foundation: How services communicate efficiently and reliably
Essential Topics:
- REST vs GraphQL vs gRPC trade-offs: When to use each protocol; performance implications
- API gateway responsibilities (routing, rate limiting, authentication): Centralized control plane for APIs
- Request aggregation and backend-for-frontend (BFF): Optimizing API calls for different clients
- Circuit breaker & retry patterns: Preventing cascading failures and handling transient errors
- Handling API versioning: Backward compatibility strategies
- Real-world gateway choices (Kong, Ambassador, AWS API Gateway): Comparing popular solutions
Pro Tip: In interviews, always discuss trade-offs. REST for simplicity, GraphQL for flexible queries, gRPC for performance.
Common Mistake: Not implementing circuit breakers in distributed systems leads to cascading failures.
Practice with AI: Design an API gateway on Thita.ai's canvas and discuss trade-offs with the AI coach.
Master Communication Patterns →
3. Load Balancing & Traffic Routing (6 Topics)
Foundation: Distributing traffic efficiently across servers
Essential Topics:
- L4 vs L7 load balancing: Transport layer vs application layer routing
- Load distribution strategies (round robin, least connections, weighted, consistent hashing): Choosing the right algorithm
- Session persistence (sticky sessions) and its drawbacks: When stateful routing is necessary
- Global load balancing & anycast routing: Geographic traffic distribution
- Failover & health check strategies: Detecting and removing unhealthy servers
- Comparison of popular load balancers (NGINX, HAProxy, Envoy, AWS ALB/ELB): Real-world implementations
Why This Matters: Every high-traffic system needs intelligent traffic distribution. Load balancing is asked in 80% of system design interviews.
Pro Tip: Consistent hashing is crucial for distributed caches and databases. Master this concept.
Practice on Thita.ai: Start with Load Balancing →
4. Database Replication, Partitioning & Distributed Consensus (12 Topics)
Foundation: The heart of distributed data systems
Essential Topics:
- Leader-follower replication: Primary-replica patterns for read scaling
- Leaderless replication (Dynamo-style): High availability through quorum-based writes
- Multi-leader replication and conflict resolution: Handling concurrent writes across regions
- Quorum-based replication (read/write quorum): R + W > N for consistency
- Synchronous vs asynchronous replication trade-offs: Consistency vs performance
- Sharding (range, hash, directory-based): Horizontal partitioning strategies
- Distributed consensus algorithms (Raft, Paxos, ZAB): How systems agree on state
- Service registry & discovery: Dynamic service location in microservices
- Distributed locking (Zookeeper, etcd, Redis Redlock): Coordinating distributed operations
- Time synchronization in distributed systems (NTP, logical clocks): Ordering events across servers
- Consensus vs quorum-based coordination: When to use each approach
- Handling race conditions & read/write conflicts (last-write-wins, vector clocks, CRDTs): Conflict resolution strategies
Why This Is Critical: Distributed systems are the core of modern architecture. This category alone can make or break your interview.
Pro Tip: Understand CAP theorem deeply, but know that real systems choose different trade-offs for different operations.
Common Interview Pattern: "Design Instagram — how do you handle 500M users uploading photos?" → Sharding strategy question.
Practice on Thita.ai: Deep Dive into Distributed Systems →
5. Real-World Databases & Architectures (9 Topics)
Foundation: Understanding actual database systems and when to use them
Essential Topics:
- PostgreSQL (ACID compliance, extensions, replication): Industry-standard relational database
- MySQL (storage engines, replication, clustering): Web-scale relational database
- Google Spanner (TrueTime, global transactions): Globally distributed ACID database
- Amazon DynamoDB (partitioning, eventual consistency): Managed NoSQL at scale
- Cassandra (wide-column, eventual consistency, gossip protocol): Peer-to-peer distributed database
- MongoDB (document store, replica sets, sharding): Flexible schema NoSQL
- CockroachDB (Spanner-like design for open source): Distributed SQL with strong consistency
- TiDB (MySQL-compatible distributed SQL): Hybrid transactional/analytical processing
- FoundationDB (layered design, transactional key-value store): Building block for databases
Real Interview Application: "Design Uber's trip database. Which database would you choose and why?"
Pro Tip: Don't just say "I'll use Cassandra." Explain the trade-offs: high write throughput but eventual consistency.
Practice on Thita.ai: Explore Database Architectures →
6. Consistency, Availability & Partition Tolerance (6 Topics)
Foundation: The CAP theorem in practice
Essential Topics:
- CAP theorem in practice: Understanding real-world trade-offs, not just theory
- Strong consistency models: Linearizability, sequential consistency guarantees
- Eventual consistency models: How systems converge over time
- Causal consistency & read-your-own-writes: Consistency guarantees for better UX
- Techniques for read/write conflict resolution: Last-write-wins, vector clocks, CRDTs
- Designing for high availability with acceptable consistency compromises: Real-world pragmatism
Why This Matters: Every distributed system makes CAP trade-offs. Interviewers want to see you reason about these choices.
Pro Tip: Most systems are CP or AP for different operations. Banking transactions are CP, social media feeds are AP.
Practice on Thita.ai: Master CAP Trade-offs →
7. Caching Strategies (7 Topics)
Foundation: Speed up systems by storing frequently accessed data
Essential Topics:
- Client-side vs edge vs server-side caching: Where to cache data
- CDN caching internals (cache keys, TTL, invalidation): Content delivery at the edge
- Write-through caching (how it works, benefits, drawbacks): Synchronous cache updates
- Write-back (write-behind) caching and consistency concerns: Asynchronous cache updates
- Write-around caching and read miss behavior: Bypassing cache on writes
- Cache invalidation strategies (LRU, LFU, FIFO): Eviction policies
- Real-world usage by databases and systems (Redis, Memcached, Cloudflare CDN): Practical implementations
Famous Quote: "There are only two hard things in Computer Science: cache invalidation and naming things." — Phil Karlton
Pro Tip: In interviews, always mention cache invalidation strategy. It's a common follow-up question.
Common Interview Question: "Design a system to serve 10M daily active users. Where would you add caching?"
Practice on Thita.ai: Explore Caching Patterns →
8. Messaging & Event-Driven Architecture (6 Topics)
Foundation: Asynchronous communication between services
Essential Topics:
- Message queue vs stream processing systems: Pull-based vs push-based messaging
- Point-to-point vs pub-sub: One-to-one vs one-to-many communication
- Ordering guarantees (exactly-once, at-least-once, at-most-once delivery): Message delivery semantics
- Dead-letter queues and retry strategies: Handling failed messages
- Comparison of Kafka, RabbitMQ, AWS SQS, NATS: Choosing the right messaging system
- Event sourcing & CQRS basics: Event-driven architecture patterns
Why This Matters: Modern microservices rely heavily on async communication. Event-driven systems power Netflix, Uber, and Airbnb.
Pro Tip: Kafka is great for event streaming; RabbitMQ excels at task queues. Know when to use each.
Practice on Thita.ai: Master Messaging Systems →
9. Storage & File Systems (6 Topics)
Foundation: How systems store and retrieve large-scale data
Essential Topics:
- Object storage internals (S3, GCS): Scalable blob storage architecture
- Distributed file systems (HDFS, Ceph, GlusterFS): File storage across multiple machines
- Block storage vs file storage trade-offs: Low-level vs high-level abstractions
- Hot vs cold storage tiering: Cost optimization strategies
- Deduplication & compression strategies: Reducing storage footprint
- Backup & disaster recovery design: Ensuring data durability
Real Interview Application: "Design Dropbox. How do you store billions of files efficiently?"
Pro Tip: Object storage (S3) is best for unstructured data at scale. Block storage (EBS) for databases.
Practice on Thita.ai: Explore Storage Systems →
10. Observability & Reliability (6 Topics)
Foundation: Monitoring and maintaining healthy systems
Essential Topics:
- Metrics collection & aggregation (Prometheus, Datadog): System health monitoring
- Distributed tracing internals (Jaeger, Zipkin): Request flow across microservices
- Log aggregation and indexing (ELK stack, OpenSearch): Centralized logging
- Alerting design & avoiding alert fatigue: Actionable notifications
- SLOs, SLIs, SLAs and their design implications: Reliability targets
- Chaos engineering for reliability: Testing failure scenarios (Netflix Chaos Monkey)
Why This Matters: "Design a monitoring system" is a common interview question. Plus, production systems need observability.
Pro Tip: Design for failure. Chaos engineering is now standard at top companies.
Practice on Thita.ai: Learn Observability Patterns →
11. Security & Compliance (6 Topics)
Foundation: Building secure and compliant systems
Essential Topics:
- Zero trust networking: Never trust, always verify
- TLS termination & end-to-end encryption: Securing data in transit
- API authentication patterns (OAuth2, JWT, HMAC): Verifying user identity
- Data encryption at rest & in transit: Protecting sensitive data
- Secrets management (Vault, AWS KMS): Storing credentials securely
- Compliance considerations (GDPR, HIPAA): Regulatory requirements
Real Interview Application: "Design a payment system. How do you ensure PCI compliance?"
Pro Tip: Security is often an afterthought in interviews, but discussing it shows senior-level thinking.
Practice on Thita.ai: Master Security Patterns →
12. Scalability Playbook (6 Topics)
Foundation: Growing systems from 1K to 100M users
Essential Topics:
- Horizontal vs vertical scaling trade-offs: Scale out vs scale up
- Auto-scaling triggers & thresholds: Dynamic capacity management
- Geo-distributed architectures & latency optimization: Serving users globally
- Scaling databases (read replicas, sharding, federation): Database growth strategies
- Scaling message queues & streaming platforms: Handling high-throughput events
- Real-world scaling case studies: Learning from production systems
Why This Matters: Every system design interview includes "How would you scale this to handle 100x traffic?"
Pro Tip: Start simple, then explain your scaling path. Don't over-engineer for Day 1.
Common Interview Pattern: "You have 1K users today. Design for 100M users in 3 years."
Practice on Thita.ai: Learn Scalability Strategies →
13. Real-World Case Studies (18 Examples)
Foundation: Learning from actual production systems at top companies
Case Studies Covered:
- Twitter/X Timeline Service (Fan-out-on-write vs Fan-out-on-read): Timeline generation at scale
- WhatsApp Messaging Architecture (multi-device sync, encryption): Billions of messages daily
- Uber Dispatch System (geospatial indexing, matching): Real-time driver-rider matching
- Netflix Content Delivery (CDN, regional caches, ABR streaming): Video streaming at scale
- Instagram Feed Ranking & Delivery (ML integration at scale): Personalized content delivery
- YouTube Video Streaming (chunked delivery, adaptive bitrate): Serving billions of videos
- Slack Real-time Messaging (WebSockets at scale, event delivery): Enterprise chat infrastructure
- Airbnb Search & Booking Flow (search ranking, transactional guarantees): Complex booking system
- Google Docs Collaboration (OT & CRDTs): Real-time collaborative editing
- Stripe Payments Infrastructure (idempotency, eventual consistency): Financial transactions at scale
- Shopify Flash Sale Handling (queueing, throttling): Handling traffic spikes
- Zoom/Google Meet Real-time Video Delivery (SFU vs MCU trade-offs): Video conferencing architecture
- Google Search Ranking & Indexing (web crawling, inverted indexes, ranking algorithms): Search at internet scale
- Facebook Ads Delivery System (real-time targeting, bidding, delivery): Ad serving infrastructure
- GitHub Pull Request System (diff computation, merge strategies, conflict resolution): Code collaboration platform
- Cloudflare DDoS Protection (edge filtering, rate limiting, traffic scrubbing): Security at the edge
- OpenAI Chat Completion API (high-availability LLM serving, batching, token streaming): AI inference at scale
- Figma Multiplayer Editing (OT + CRDT hybrid for graphics editing): Real-time design collaboration
Why This Is Gold: Real case studies show you how theory applies in production. Interviewers love when you reference actual systems.
Pro Tip: Study 2-3 case studies deeply. Reference them in interviews: "Similar to how Netflix handles video streaming..."
Practice on Thita.ai: Explore Case Studies →
14. Commonly Asked Design Problems (20 Questions)
Foundation: Practice problems that appear in actual interviews
Design Problems:
- Design a URL Shortener (bit.ly, TinyURL)
- Design a Video Streaming Service (YouTube, Netflix)
- Design a File Storage & Sharing Service (Dropbox, Google Drive)
- Design an Image Hosting & Sharing Platform (Instagram, Imgur)
- Design a News Feed (Facebook, Twitter)
- Design a Chat Application (WhatsApp, Telegram)
- Design a Real-time Collaboration Tool (Google Docs, Figma)
- Design an Online Multiplayer Game Architecture
- Design a Search Autocomplete System (Google Search)
- Design a Recommendation Engine (Amazon, Netflix)
- Design a Ride-Hailing Service (Uber, Lyft)
- Design an E-commerce System (Amazon, Shopify)
- Design a Payment Gateway (Stripe, PayPal)
- Design a Food Delivery Platform (DoorDash, UberEats)
- Design a Rate Limiter (API throttling)
- Design a Distributed Cache (Memcached, Redis)
- Design a Logging & Monitoring System (Datadog, Splunk)
- Design a Notification System (push, email, SMS)
- Design a Ticket Booking System (MovieTickets, Eventbrite)
- Design an IoT Device Management Platform
Interview Strategy: For each problem, apply the building blocks you learned in categories 1-12.
Pro Tip: Use a framework: Requirements → Capacity Estimation → API Design → Database Schema → Core Components → Scalability → Trade-offs.
Practice on Thita.ai: Get AI feedback on your designs and practice with mock interviews.
How to Learn System Design Effectively with Thita.ai
Knowing the roadmap is just the start. Deliberate practice with real-time feedback is what converts knowledge into interview success.
Here's how Thita.ai's AI-powered platform accelerates your system design mastery:
1. Follow the Structured Learning Path
Visit Thita.ai's HLD Learning Path to see all 14 categories with 120 topics, organized exactly as outlined in this roadmap.
2. Interactive Visual Design Canvas
- Draw architecture diagrams directly in your browser
- Drag and drop components (load balancers, databases, caches)
- Get instant AI feedback on your design decisions
- Learn by doing, not just reading
3. AI Coach for System Design
- Ask questions and get detailed explanations
- The AI draws diagrams to visualize complex concepts
- Understand trade-offs through interactive discussion
- Learn at your own pace with personalized guidance
Pro Tip: Use the AI Coach to explore "what-if" scenarios: "What happens if we use Cassandra instead of PostgreSQL?"
4. Mock System Design Interviews
- Practice with an AI interviewer that asks follow-up questions
- Get evaluated on communication, technical depth, and trade-off analysis
- Receive detailed feedback on your performance
- Build confidence before real interviews
5. Track Your Progress
- See which topics you've mastered across all 14 categories
- Identify knowledge gaps and focus your study time
- Build momentum with consistent learning
- Monitor improvement over time
Your Action Plan: From Zero to System Design Hero
Don't just read — take action today with this structured approach:
Week 1-2: Foundations
Focus: Categories 1-3 (Service Architectures, API Gateways, Load Balancing)
Start with the fundamentals. These are the building blocks for every system.
Practice:
- Draw a basic 3-tier web application architecture
- Design an API gateway with rate limiting
- Compare L4 vs L7 load balancing for a specific use case
Week 3-5: Data Layer Mastery
Focus: Categories 4-5 (Database Replication, Real-World Databases)
Deep dive into distributed data systems — this is where most interviews focus.
Practice:
- Design a sharding strategy for a user database with 100M users
- Compare Cassandra vs PostgreSQL for different use cases
- Understand leader-follower replication patterns
Week 6-7: Performance & Reliability
Focus: Categories 6-7 (CAP Theorem, Caching)
Learn how to make systems fast and reliable.
Practice:
- Design a multi-layer caching strategy
- Analyze CAP trade-offs for different scenarios
- Implement cache invalidation strategies
Week 8-9: Modern Architecture Patterns
Focus: Categories 8-11 (Messaging, Storage, Observability, Security)
Master event-driven systems and operational concerns.
Practice:
- Design an event-driven microservices architecture
- Build a monitoring system with metrics, logs, and traces
- Implement OAuth2 authentication flow
Week 10-11: Scalability & Real-World Systems
Focus: Categories 12-13 (Scalability, Case Studies)
Learn how top companies scale their systems.
Practice:
- Study 5 case studies in depth (Twitter, Netflix, Uber, Stripe, Google Search)
- Design a system that scales from 1K to 100M users
- Apply learnings from real-world architectures
Week 12: Interview Practice
Focus: Category 14 (Commonly Asked Problems)
Simulate real interviews and get AI feedback.
Practice:
- Do 10+ mock interviews on Thita.ai
- Practice explaining your designs clearly
- Get comfortable with follow-up questions and trade-off discussions
Pro Tips from Engineers at Top Companies
From a Meta E6 Engineer:
"Don't memorize architectures. Learn the building blocks and how they compose. In my interview, they asked me to design Instagram. I applied caching, sharding, CDN, and load balancing — all concepts from this roadmap."
From a Google L5 Engineer:
"The visual canvas on Thita.ai helped me practice drawing clean architecture diagrams. In my onsite, I was comfortable at the whiteboard because I'd practiced digitally dozens of times."
From an Amazon SDE2:
"Real-world case studies were game-changers. When I referenced how Netflix handles video streaming in my interview, the interviewer was impressed. Study actual systems."
Common Mistakes to Avoid
1. Starting with Scalability Don't design for 100M users on Day 1. Start simple, then explain how you'd scale.
2. Ignoring Trade-offs Every design decision has pros and cons. Always discuss them: "I'd use PostgreSQL for ACID guarantees, but it's harder to shard than Cassandra."
3. Skipping Numbers Do back-of-the-envelope calculations. "With 10M DAU and 20 actions per day, that's 200M requests. At peak 3x average, we need to handle 7,000 QPS."
4. Over-Engineering Don't add Kafka, Redis, Elasticsearch, and microservices to every problem. Use what's necessary.
5. Poor Communication Think out loud. Interviewers want to understand your reasoning, not just see a diagram.
Conclusion & Next Steps
Stop the random learning — start with structure.
These 120 system design topics (organized into 14 core categories, plus 18 case studies and 20 practice problems) are your complete roadmap to mastering technical interviews at FAANG and beyond.
The reality: Most candidates waste months watching scattered YouTube videos and reading random blog posts. The top 1% follow a structured roadmap and practice with feedback.
Which group will you join?
Start your journey today:
- Open Thita.ai's HLD Learning Path → — Follow the structured curriculum
- Try AI Coach → — Get personalized explanations and draw architecture diagrams
- Practice Mock Interviews → — Simulate real system design interviews with AI feedback
Your next interview question will feel like a roadmap you've already traveled.
Ready to Master System Design?
Join thousands of engineers who've landed offers at Google, Meta, Amazon, and more using Thita.ai's structured, AI-powered approach.
Last Updated: September 4, 2026
Related Articles
- AI Interview Practice: Free Mock Interview Simulator
- The 90 DSA Patterns That Cover 99% of Coding Interviews
- Free ATS Resume Checker: AI-Powered Resume Analyzer
- Scalability Patterns for Modern Systems (Coming Soon)
- Distributed Systems Design Guide (Coming Soon)
External Resources
Questions? Join our Discord community and connect with thousands of engineers preparing for system design interviews.