45-day interview roadmap

System Design · 45 Days System Design Mastery

45 Days System Design Mastery

Learn in place: pick a topic on the left, read the lesson on the right, and mark it complete when you are done.

Start learning Jump to phases

8 min read August 27, 2026

45-day plan — System Design

0%0 / 0

Day 1–5 Interview foundation
Day 6–14 Networking, APIs & data
Day 15–25 Databases & caching
Day 26–37 Async, distributed systems
Day 38–45 Scale, resilience & MAANG designs

Curriculum

Phase 1: SYSTEM DESIGN INTERVIEW FOUNDATION

Day 1 – Introduction to System Design

Topics

What is System Design?
Why System Design matters
What product-based and MAANG companies evaluate
Functional requirements
Non-functional requirements
Constraints
Scale requirements
Identifying bottlenecks
Understanding trade-offs
High-Level Design (HLD)
Low-Level Design (LLD)
Difference between HLD and LLD

Day 2 – System Design Interview Framework

Topics

Requirement clarification
Capacity estimation
API design
Data modeling
High-level architecture
Component deep dive
Bottleneck analysis
Scalability discussion
Reliability discussion
Consistency discussion
Trade-off discussion
Asking the right questions
Stating assumptions
Prioritizing requirements
Explaining design decisions
Avoiding unnecessary complexity

Day 3 – Functional & Non-Functional Requirements

Topics

Core user features
Inputs and outputs
User workflows
Edge cases
Scalability
Availability
Reliability
Durability
Latency
Throughput
Consistency
Security
Read-heavy systems
Write-heavy systems
Balanced workloads
Burst traffic
Peak traffic

Day 4 – Back-of-the-Envelope Estimation

Topics

Daily Active Users
Monthly Active Users
Concurrent users
Requests per second
Queries per second
Read/write ratio
Peak traffic
Data size
Daily storage growth
Yearly storage growth
Bandwidth estimation
Memory estimation
CPU considerations
Powers of two
Storage units
Common latency numbers
Network bandwidth estimates

Day 5 – Architecture & Performance Fundamentals

Topics

Client-server architecture
Monolith
Modular monolith
Microservices
Stateless services
Stateful services
Latency
Throughput
Response time
Concurrency
Parallelism
Tail latency
P95 latency
P99 latency
Vertical scaling
Horizontal scaling
Single point of failure
Bottleneck identification
Resource saturation
Backpressure

Phase 2: NETWORKING & COMMUNICATION

Day 6 – Networking Fundamentals

Topics

IP addresses
Ports
DNS
Domain resolution
TCP
UDP
Connection establishment
TCP handshake
Connection lifecycle
Reliability
Ordering
Network latency
Packet loss
Network failures

Day 7 – HTTP & Application Communication

Topics

HTTP request-response model
HTTP methods
HTTP headers
HTTP status codes
HTTP/1.1
HTTP/2
HTTP/3 overview
REST
RPC
gRPC concepts
Keep-alive
Connection reuse

Day 8 – Real-Time Communication

Topics

WebSocket
Persistent connections
Bi-directional communication
Connection lifecycle
Server-Sent Events (SSE)
Server-to-client streaming
Webhooks
Event notifications
Callback architecture
REST vs WebSocket
Polling vs long polling
WebSocket vs SSE
Synchronous vs asynchronous communication

Phase 3: TRAFFIC MANAGEMENT & EDGE

Day 9 – Load Balancing

Topics

Why load balancing
Distributing traffic
Horizontal scaling
High availability
Layer 4 load balancing
Layer 7 load balancing
Round Robin
Weighted Round Robin
Least Connections
IP Hash
Consistent Hashing
Health checks
Unhealthy instance removal

Day 10 – Reverse Proxy & API Gateway

Topics

Reverse proxy
Request forwarding
TLS termination
Load distribution
Caching
API Gateway
Routing
Authentication
Authorization
Rate limiting
Request aggregation
API versioning
Load balancer vs reverse proxy
Reverse proxy vs API Gateway

Day 11 – CDN & Edge Architecture

Topics

Why CDN
Edge locations
Origin servers
Static content delivery
Pull CDN
Push CDN
Cache-Control
TTL
Edge caching
Cache invalidation
Geo-routing
Latency-based routing
Global load balancing
Regional failover
Multi-region traffic
Data locality

Phase 4: API DESIGN & DATA MODELING

Day 12 – API Design

Topics

REST API design
Resource design
URI design
HTTP methods
Request structure
Response structure
Pagination
Filtering
Sorting
Offset pagination
Cursor pagination
Pagination trade-offs
API versioning
Backward compatibility

Day 13 – API Reliability

Topics

Idempotency
Idempotent APIs
Idempotency keys
Timeouts
Retries
Duplicate requests
Request deduplication
Retry safety
Replay prevention

Day 14 – Data Modeling

Topics

Entities
Relationships
Primary keys
One-to-one
One-to-many
Many-to-many
Read patterns
Write patterns
Query patterns
Access-pattern-first design
Hot paths
Data locality

Phase 5: RELATIONAL DATABASES

Day 15 – SQL Database Fundamentals

Topics

Tables
Rows
Columns
Primary keys
Foreign keys
Normalization
Denormalization
Constraints
Referential integrity

Day 16 – Transactions & Concurrency

Topics

ACID
Atomicity
Consistency
Isolation
Durability
Isolation levels
Dirty reads
Non-repeatable reads
Phantom reads
Locks
Optimistic locking
Pessimistic locking
Deadlocks
Lock contention
Transaction boundaries

Day 17 – Database Performance & Indexing

Topics

Primary indexes
Secondary indexes
Composite indexes
Query plans
Index usage
Full table scans
Read optimization
Write optimization
Index benefits
Index write overhead

Phase 6: NOSQL & DATABASE SELECTION

Day 18 – NoSQL Fundamentals

Topics

Key-value databases
Document databases
Wide-column databases
Graph databases
Time-series databases
Search indexes
Flexible schema
Horizontal scaling
High write throughput

Day 19 – Database Selection

Topics

SQL vs NoSQL
Schema requirements
Query patterns
Consistency requirements
Scalability requirements
Read patterns
Write patterns
Data relationships
Latency requirements
Polyglot persistence
Choosing the right storage for each problem

Phase 7: DATABASE SCALING

Day 20 – Database Replication

Topics

Primary-replica replication
Read replicas
Multi-primary concepts
Replication lag
Read-after-write consistency
Failover
Replica promotion
Quorum concepts
Read quorum
Write quorum

Day 21 – Partitioning & Sharding

Topics

Vertical partitioning
Horizontal partitioning
Range-based sharding
Hash-based sharding
Directory-based sharding
Shard key selection
Data distribution

Day 22 – Advanced Sharding Problems

Topics

Hot partitions
Hot keys
Uneven data distribution
Consistent hashing
Cross-shard queries
Rebalancing
Resharding
Data migration

Phase 8: CACHING

Day 23 – Caching Fundamentals

Topics

Why cache
Reduce latency
Reduce database load
Increase throughput
Client-side cache
CDN cache
Reverse proxy cache
Application cache
Distributed cache
TTL
Expiration
Eviction

Day 24 – Cache Strategies & Problems

Topics

Cache Strategies
Cache-aside
Read-through
Write-through
Write-behind
Write-back
Refresh-ahead
Cache Consistency
Cache invalidation
Stale data
Write ordering
Cache Problems
Cache stampede
Cache penetration
Cache avalanche
Hot keys

Day 25 – Redis & Distributed Caching

Topics

Redis
Strings
Hashes
Lists
Sets
Sorted Sets
Distributed caching
Sessions
Counters
Leaderboards
Rate limiting
Replication
Persistence overview
High availability
Eviction policies
Hot key mitigation

Phase 9: ASYNCHRONOUS SYSTEMS & KAFKA

Day 26 – Message Queues

Topics

Why messaging
Asynchronous processing
Decoupling
Traffic smoothing
Background processing
Producer
Consumer
Broker
Queue
Point-to-point messaging
Publish-subscribe

Day 27 – Asynchronous Reliability & Backpressure

Topics

Retry
Retry policies
Dead-letter queues
Dead-letter topics
Poison messages
Consumer lag
Slow consumers
Backpressure
Bounded queues
Load leveling
Idempotent consumers
Duplicate message handling

Day 28 – Kafka Fundamentals

Topics

Kafka architecture
Broker
Cluster
Topic
Partition
Producer
Consumer
Consumer group
Offset
Message publishing

Day 29 – Kafka Scaling & Reliability

Topics

Partitioning strategy
Key-based partitioning
Ordering guarantees
Consumer scaling
Consumer groups
Rebalancing
Replication
Failure handling

Day 30 – Kafka Delivery Semantics & Event Patterns

Topics

At-most-once
At-least-once
Exactly-once concepts
Idempotent producers
Idempotent consumers
Event-driven architecture
Event sourcing overview
Outbox pattern
Transactional messaging concepts

Phase 10: DISTRIBUTED SYSTEMS

Day 31 – Distributed Systems Fundamentals

Topics

What is a distributed system?
Network failures
Partial failures
Node failures
Network partitions
Distributed state
State synchronization
Replication
Clock differences
Delayed messages
Duplicate messages
Out-of-order messages

Day 32 – CAP Theorem & Consistency

Topics

CAP theorem
Consistency
Availability
Partition tolerance
CP systems
AP systems
Why network partitions matter
Real-world CAP trade-offs

Day 33 – Consistency Models

Topics

Strong consistency
Eventual consistency
Read-your-writes
Monotonic reads
Causal consistency overview
When strong consistency is required
When eventual consistency is acceptable

Day 34 – Distributed Coordination

Topics

Distributed locks
Leader election
Service coordination
Configuration coordination
Heartbeats
Leases
Timeout-based failure detection
ZooKeeper overview
etcd overview

Day 35 – Consensus & Quorum

Topics

Why consensus is needed
Consensus basics
Raft overview
Leader-based coordination
Quorum reads
Quorum writes
Distributed configuration
Leader election
Cluster coordination

Phase 11: DISTRIBUTED DATA & TRANSACTIONS

Day 36 – Distributed Transactions

Topics

Database per service
Cross-service transactions
Partial success
Partial failure
Eventual consistency
Data duplication
Why distributed transactions are difficult

Day 37 – Saga & Distributed Transaction Patterns

Topics

Saga pattern
Choreography
Orchestration
Compensating transactions
Idempotency
Deduplication
Retry safety
Eventual consistency

Phase 12: SCALABILITY, RESILIENCE & SECURITY

Day 38 – Application Scalability Patterns

Topics

Stateless application servers
Stateful services
Session externalization
Horizontal scaling
Auto-scaling
Read/write separation
Queue-based load leveling
Scatter-gather overview

Day 39 – Unique ID Generation

Topics

Database-generated IDs
UUID
Time-based IDs
Snowflake-style IDs
ID ordering
Collision considerations
Distributed ID generation trade-offs

Day 40 – Resilience & Failure Handling

Topics

Timeout
Retry
Exponential backoff
Jitter
Circuit breaker
Bulkhead
Fallback
Downstream failure handling
Cascading failure prevention

Day 41 – Overload Protection & Security

Topics

Overload Protection
Rate limiting
Load shedding
Backpressure
Bounded queues
Graceful degradation
Priority-based processing
Security
Authentication
Authorization
OAuth/JWT concepts
TLS
Encryption at rest
Secrets management
Abuse Prevention & Privacy
API abuse
Bot protection concepts
Spam prevention
Replay prevention
PII minimization
Data retention
Access auditing

Phase 13: AVAILABILITY & OBSERVABILITY

Day 42 – High Availability & Disaster Recovery

Topics

Redundancy
Active-active
Active-passive
Multi-AZ architecture
Single-region architecture
Multi-region architecture
Geo-replication
Data locality
Regional failover
Backups
Replication
Failover
RPO
RTO

Day 43 – Observability & Production Systems

Topics

Logging
Structured logging
Centralized logging
Correlation IDs
Metrics & Monitoring
System metrics
Application metrics
Business metrics
Dashboards
Alerting
Golden signals overview
SLI
SLO
SLA
Distributed Tracing
Trace ID
Span
End-to-end request tracing

Phase 14: CORE SYSTEM DESIGN PROBLEMS

Day 44 – Common Product Company System Designs

Topics

URL Shortener
Requirements
URL generation
Base62 encoding
Hashing
Collision handling
Database design
Caching
Analytics
Rate Limiter
Fixed Window
Sliding Window
Sliding Log
Token Bucket
Leaky Bucket
Distributed rate limiting
Atomic operations
Notification System
Email
SMS
Push notifications
Queue
Worker services
Provider integration
Retry
Idempotency
Delivery tracking
Background Job System
Task queues
Scheduling
Delayed jobs
Retry
Dead-letter handling

Phase 15: MAANG-STYLE DESIGN PROBLEMS & INTERVIEW

Day 45 – Advanced System Designs & Complete Interview Practice

Topics

Chat System
WebSocket
Connection management
Presence
Message ordering
Message persistence
Delivery status
Read receipts
Group chat
News Feed
Fan-out on write
Fan-out on read
Hybrid fan-out
Celebrity problem
Ranking
Pagination
Search & Autocomplete
Inverted index concepts
Indexing pipeline
Prefix search
Ranking
Freshness
File Storage
File upload
Object storage
Metadata storage
Chunking
Multipart upload
Replication
CDN
Video Streaming
Video upload
Transcoding
Multiple resolutions
Adaptive bitrate streaming
CDN
E-Commerce & Payments
Product catalog
Inventory
Shopping cart
Order creation
Payment workflow
Idempotency
Ledger concepts
Saga
Audit trail
Ride Booking
Location updates
Geospatial queries
Driver matching
Real-time updates
Ride lifecycle
Web Crawler
URL frontier
Scheduling
Politeness
Deduplication
Distributed crawling
Storage and indexing
Complete Interview Practice
Clarify requirements
Estimate scale
Design APIs
Design data model
Draw HLD
Deep dive into bottlenecks
Discuss caching
Discuss database scaling
Discuss asynchronous processing
Discuss consistency
Discuss availability
Discuss failure scenarios
Explain trade-offs

Select a lesson

Open any topic, practice, or interview question from the curriculum to learn here — no new tab.

Keep momentum

Ready to practise what you just planned?

Jump into hands-on problems or read real interview experiences from engineers at your level.

Coding practice Interview experiences

45 Days System Design Mastery

Select a lesson

Lesson

Ready to practise what you just planned?

Create your account

Reset password

Choose a new password