High Level System Design (HLD)

You can frame system design interview requirements, calculate scale metrics, and choose between vertical and horizontal scaling models.

1. What system design is and the interview framework90 min
   • interviewer expectations
   • clarifying questions framework
   • back-of-the-envelope estimations
   • incremental design structuring
2. Functional versus non-functional requirements90 min
   • user stories vs system constraints
   • latency vs throughput targets
   • fault tolerance guarantees
   • auditing requirements
3. Scalability: vertical versus horizontal scaling2 hrs
   • scale-up limits
   • stateless application servers
   • shared-nothing architecture
   • hardware bottlenecks
4. Latency, throughput, availability and reliability2 hrs
   • p99 vs average latency
   • four nines availability math
   • Mean Time Between Failures
   • error budget calculations
5. The building blocks of a large-scale system3 hrs
   • client tier
   • DNS routing
   • load balancing layers
   • persistent storage nodes

Hands-on project: Produce a high-level system requirements document for an enterprise e-commerce platform defining QPS, peak traffic multipliers, and availability SLAs.

You can configure load balancing algorithms, API gateways, and reverse proxies to handle traffic distribution and secure edge routing.

1. How the web works: DNS, HTTP and TCP/IP90 min
   • DNS root name servers
   • TCP handshake overhead
   • HTTP/1.1 vs HTTP/2 multiplexing
   • TLS termination
2. Load balancing algorithms90 min
   • Round Robin
   • Least Connections
   • IP Hash routing
   • weighted distribution
3. Forward and reverse proxies2 hrs
   • outbound proxy security
   • inbound load distribution
   • SSL offloading
   • compression proxies
4. API gateways2 hrs
   • routing rules
   • JWT authentication filters
   • request transformation
   • service aggregation
5. Rate limiting1 hr 30 min
   • Token Bucket algorithm
   • Leaky Bucket
   • Fixed Window counters
   • Distributed Sliding Window with Redis

Hands-on project: Configure Nginx as a reverse proxy with least-connections load balancing and an algorithmic rate limiter in front of a mock backend service.

You can implement multi-tier caching strategies, eviction algorithms, and CDN edge rules to protect downstream databases.

1. Why and where to cache2 hrs
   • database read pressure reduction
   • edge caching vs application caching
   • cache stampede prevention
   • dog-piling mitigation
2. Cache strategies: write-through, write-back and write-around3 hrs
   • write-through consistency
   • write-back asynchronous flush
   • write-around bulk ingestion
   • cache invalidation patterns
3. Eviction policies: LRU and LFU3 hrs
   • Least Recently Used linked structures
   • Least Frequently Used frequency counters
   • Time To Live (TTL) expiration
   • memory limit triggers
4. Redis and Memcached4 hrs
   • Redis single-threaded event loop
   • persistence snapshots (RDB/AOF)
   • Memcached multi-threaded slabs
   • data structures in Redis
5. Content Delivery Networks (CDNs)4 hrs
   • edge server geography
   • origin shield architecture
   • cache control headers
   • dynamic content acceleration

Hands-on project: Build a caching layer using Redis supporting write-through and write-around patterns with LRU eviction policies configured for under 5ms p99 latency.

You can choose between SQL and NoSQL engines, design indexes, and scale storage through replication, sharding, and object stores.

1. SQL versus NoSQL: choosing the right store3 hrs
   • relational integrity in PostgreSQL
   • document stores in MongoDB
   • wide-column stores in Cassandra
   • graph databases in Neo4j
2. Indexing and query performance3 hrs
   • B-Tree internals
   • LSM-Tree write optimization
   • composite index selectivity
   • execution plan analysis
3. Replication: master-slave and master-master3 hrs
   • synchronous replication lag
   • asynchronous data loss risks
   • automatic failover with Raft
   • read scaling pools
4. Sharding and data partitioning4 hrs
   • horizontal range partitioning
   • directory-based routing
   • cross-shard join penalties
   • hotspot mitigation
5. Blob and object storage3 hrs
   • hierarchical file systems vs flat object stores
   • multipart uploads
   • presigned URLs
   • lifecycle transition policies

Hands-on project: Design a horizontal database sharding scheme using consistent hashing keys and write a replication failover runbook for a PostgreSQL cluster.

You can evaluate distributed consistency models, implement quorums, and apply consistent hashing to distributed nodes.

1. The CAP theorem3 hrs
   • Brewer's theorem proof limits
   • PACELC extension
   • choosing availability over consistency
   • network partition real-world behavior
2. ACID versus BASE3 hrs
   • ACID isolation levels
   • Basically Available state
   • Soft state transitions
   • Eventually Consistent verification
3. Consistency models: strong and eventual3 hrs
   • linearizability guarantees
   • causal consistency
   • read-your-writes consistency
   • vector clocks for conflict detection
4. Quorum, replication and conflict resolution4 hrs
   • W + R > N quorum math
   • sloppy quorums and hinted handoff
   • last-write-wins timestamp drift
   • Merkle trees for anti-entropy
5. Consistent hashing3 hrs
   • hash ring distribution
   • virtual nodes for load balance
   • minimal key migration on node failure
   • hotspot prevention strategies

Hands-on project: Simulate a partition scenario on a multi-node distributed cluster demonstrating CP versus AP trade-offs under network splits.

You can design event-driven architectures and message queues to decouple services and absorb traffic spikes.

1. Synchronous versus asynchronous processing90 min
   • blocking thread pools
   • request-response timeout cascading
   • fire-and-forget patterns
   • polling vs webhooks
2. Message queues: Kafka, RabbitMQ and SQS2 hrs
   • log-based persistence in Kafka
   • AMQP exchange routing in RabbitMQ
   • managed queues in AWS SQS
   • delivery guarantees (at-least-once, exactly-once)
3. Publish and subscribe systems1 hr 30 min
   • fan-out exchanges
   • topic subscription filters
   • subscriber scaling
   • message retention policies
4. Event-driven architecture2 hrs
   • event notification vs event sourcing
   • CQRS pattern implementation
   • saga pattern for distributed transactions
   • idempotency keys in consumers
5. Handling spikes and back-pressure1 hr 30 min
   • buffer overflow protection
   • reactive streams back-pressure
   • circuit breaker integration
   • graceful degradation of features

Hands-on project: Implement an asynchronous event pipeline using Apache Kafka with producer acks, consumer groups, and dead-letter queue error handling.

You can decompose monolithic applications into microservices, select appropriate communication protocols, and design API contracts.

1. Monolith versus microservices3 hrs
   • modular monolith advantages
   • organizational scaling (Conway's Law)
   • operational complexity cost
   • distributed deployment overhead
2. Service communication: REST, gRPC and GraphQL4 hrs
   • RESTful resource modeling
   • Protocol Buffers and HTTP/2 streaming in gRPC
   • GraphQL query batching
   • schema evolution management
3. Service discovery and the API gateway3 hrs
   • client-side vs server-side discovery
   • Consul and Etcd registries
   • gateway aggregation patterns
   • edge rate limiting and auth
4. Decomposition and bounded contexts3 hrs
   • Domain-Driven Design (DDD) subdomains
   • database-per-service isolation
   • shared library antipatterns
   • anti-corruption layers
5. Observability: logging, metrics and tracing3 hrs
   • structured JSON logging
   • Prometheus metrics collection
   • OpenTelemetry distributed tracing headers
   • SLO-based alerting rules

Hands-on project: Design a domain-driven microservices architecture breakdown for a legacy monolith with service boundaries, gRPC internal contracts, and distributed tracing.

You can perform back-of-the-envelope capacity estimations and apply distributed coordination primitives to systems.

1. Back-of-the-envelope capacity estimation2 hrs
   • read vs write ratio modeling
   • daily active users to QPS formulas
   • storage sizing per year calculations
   • peak traffic multipliers
2. Numbers every engineer should know90 min
   • L1 cache reference vs RAM lookup
   • SSD random read vs disk seek latency
   • cross-datacenter round-trip times
   • network bandwidth limits
3. Leader election and consensus (Raft overview)2 hrs
   • Raft consensus protocol stages
   • heartbeat timeouts
   • split-vote prevention
   • log replication invariants
4. Distributed locks and coordination1 hr 30 min
   • Redlock algorithm limitations
   • ZooKeeper ephemeral nodes
   • fencing tokens
   • split-brain mitigation
5. Bloom filters and probabilistic structures1 hr
   • bit array memory savings
   • false positive rate tuning
   • HyperLogLog cardinality estimation
   • Count-Min Sketch frequency tracking

Hands-on project: Calculate infrastructure storage, QPS, and bandwidth requirements for a streaming media platform handling 100k concurrent streams.

You can design large-scale read/write intensive social and storage systems including URL shorteners, news feeds, and chat apps.

1. Designing a URL shortener (TinyURL)3 hrs
   • Base62 encoding generation
   • database collision handling
   • redirect caching strategies
   • analytics aggregation pipeline
2. Designing Twitter and a news feed4 hrs
   • fan-out-on-write vs fan-out-on-read
   • hybrid feed generation for celebrities
   • timeline ranking cache
   • tweet ingestion storage partitioning
3. Designing Instagram3 hrs
   • image upload pipelines
   • CDN edge distribution
   • photo metadata sharding
   • follower graph storage
4. Designing WhatsApp (chat system)3 hrs
   • WebSocket persistent connections
   • offline message delivery queues
   • group chat message fan-out
   • end-to-end encryption key exchange
5. Designing Dropbox and Google Drive3 hrs
   • file chunking and deduplication
   • block-level synchronization sync engine
   • metadata change log streaming
   • conflict resolution on concurrent edits

Hands-on project: Create a complete high-level design specification and architecture diagram for a real-time messaging application supporting 10 million active users.

You can architect high-throughput video streaming, ride-hailing geolocation services, and low-latency search typeaheads.

1. Designing YouTube and Netflix (video streaming)4 hrs
   • adaptive bitrate streaming (DASH/HLS)
   • video chunk transcoding pipelines
   • edge caching of popular media segments
   • storage tiering for cold video assets
2. Designing Uber and Ola (ride-hailing)4 hrs
   • geohash spatial indexing
   • quadtree location partitioning
   • high-frequency driver GPS stream ingestion
   • matching engine algorithms
3. Designing a typeahead and autocomplete3 hrs
   • Trie data structure caching
   • prefix search query optimization
   • MapReduce frequency batch updates
   • fuzzy matching latency reduction
4. Designing a notification system2 hrs
   • multi-channel dispatch (SMS, push, email)
   • priority queuing for urgent alerts
   • rate limiting per user device
   • deduplication of alert floods
5. Designing a rate limiter and a distributed cache3 hrs
   • centralized vs distributed token bucket
   • consistent hashing ring for cache shards
   • eviction synchronization across nodes
   • hot key mitigation

Hands-on project: Produce an architectural design document for a ride-hailing dispatch service handling real-time spatial queries and driver matching.

You can define SLOs for a service and run the incident that breaches them.

1. SLI, SLO and the error budget90 min
   • Choosing a good SLI
   • Budget burn rate
   • Freezing releases on burn
2. What to alert on90 min
   • Symptom vs cause alerts
   • Multi-window burn alerts
   • Alert fatigue
3. Running an incident90 min
   • Incident commander role
   • Mitigate before diagnose
   • Comms to stakeholders
4. Learning from failure90 min
   • Blameless postmortem
   • Contributing factors
   • Action item follow-through

Hands-on project: Write SLIs and SLOs with an error budget for one of the case-study systems, design its dashboard and alert rules, then run a tabletop incident for a regional outage and produce the post-incident review.

You can design tenant isolation and abuse protection into a system rather than bolting it on.

1. Authentication and authorisation at scale90 min
   • Token issuance and rotation
   • Service-to-service identity
   • Permission checks at the edge
2. Tenant isolation models90 min
   • Shared vs siloed data
   • Noisy-neighbour control
   • Per-tenant encryption keys
3. Rate limiting and abuse90 min
   • Token bucket vs sliding window
   • Distributed counters
   • Bot and scraping defence
4. Privacy by design90 min
   • Data classification
   • Retention and deletion
   • Audit trails

Hands-on project: Extend one case-study design with tenant isolation, an authentication and authorisation model, per-tenant rate limits and quotas, and a data-retention and deletion path that satisfies a right-to-erasure request.

You can design web crawlers, payment ledgers, and flash-sale ticketing engines, culminating in an integrated capstone architecture.

1. Designing a web crawler90 min
   • URL frontier priority queues
   • politeness rules and domain throttling
   • duplicate detection with Bloom filters
   • distributed worker coordination
2. Designing a payment system2 hrs
   • double-entry ledger immutability
   • idempotency keys in payment gateways
   • distributed transactions with sagas
   • reconciliation batch pipelines
3. Designing a ticketing system at scale90 min
   • flash sale inventory locking
   • Redis atomic seat reservation
   • queue-based virtual waiting rooms
   • preventing overselling under load
4. Structuring your answer in a real interview1 hr
   • 45-minute interview time management
   • driving the conversation proactively
   • addressing trade-offs explicitly
   • handling interviewer curveballs
5. Mock interviews, portfolio and career prep2 hrs
   • system design rubric evaluation
   • architecture diagram presentation
   • portfolio write-up structure
   • SDE-2 and senior interview prep

Hands-on project: Design, document, and defend a complete end-to-end architecture for a global ticketing platform handling flash sales, inventory locks, payment processing, and high-concurrency traffic spikes.