System Design
Core concepts behind building scalable, reliable distributed systems. Covers the patterns and trade-offs every backend engineer needs to know.
39 conceptsInteractive diagrams
01
Horizontal vs Vertical Scaling
Trade-offs between scaling up a single machine versus spreading load across many.
02
Load Balancing
Distributing incoming requests across servers to maximise throughput and availability.
03
Auto-scaling
Dynamically adding or removing compute capacity in response to real-time demand.
04
Rate Limiting
Controlling request rates to protect services from overload and abuse.
05
SQL vs NoSQL
Choosing between relational and non-relational databases based on data shape and access patterns.
06
Database Sharding
Partitioning a dataset across multiple nodes to scale writes and storage horizontally.
07
Replication (Leader–Follower, Multi-Leader)
Keeping copies of data in sync across nodes for durability and read scalability.
08
CAP Theorem
Why a distributed system can only guarantee two of consistency, availability, and partition tolerance.
09
ACID vs BASE
Strong transactional guarantees versus eventual-consistency models and when each applies.
10
Caching Strategies
Cache-aside, write-through, and write-behind patterns for reducing latency and database load.
11
CDN (Content Delivery Network)
Serving static and dynamic content from edge locations close to users.
12
Cache Eviction Policies
LRU, LFU, and TTL strategies for deciding what to remove when a cache is full.
13
Redis Architecture
How Redis stores data in memory, handles persistence, and supports clustering.
14
DNS Resolution Flow
The recursive lookup chain from a browser query to a resolved IP address.
15
HTTP vs HTTPS
How TLS adds encryption, authentication, and integrity on top of HTTP.
16
WebSockets vs HTTP Polling
Full-duplex persistent connections versus repeated polling for real-time data.
17
REST vs GraphQL vs gRPC
Comparing API paradigms across flexibility, performance, and contract design.
18
Message Queues vs Event Streams
Point-to-point queues versus persistent, replayable event logs like Kafka.
19
Pub/Sub Pattern
Decoupling producers and consumers through a topic-based broadcast model.
20
Kafka Architecture
Topics, partitions, consumer groups, and how Kafka achieves high-throughput durability.
21
Dead Letter Queues
Capturing messages that fail repeated processing for later inspection and replay.
22
API Gateway Pattern
A single entry point that handles routing, auth, rate-limiting, and protocol translation.
23
Service Mesh
Handles service-to-service communication, observability, and security via a dedicated infrastructure layer.
24
Circuit Breaker Pattern
Stops calling a failing service to give it time to recover and prevent cascade failures.
25
Saga Pattern
Manages distributed transactions across services using a sequence of compensating actions.
26
Fault Tolerance & Redundancy
Designing systems that continue operating correctly when components fail.
27
Failover Strategies
Automatically switching to a standby system when the primary becomes unavailable.
28
Chaos Engineering
Deliberately injecting failures to find weaknesses before they cause production incidents.
29
SLA / SLO / SLI
Defining and measuring reliability commitments: service level agreements, objectives, and indicators.
30
Consistent Hashing
Distributing keys across nodes so that only a fraction of keys move when the cluster changes.
31
Consensus (Raft Algorithm)
How distributed nodes agree on a single value despite failures, as implemented in Raft.
32
Distributed Transactions (2PC)
Coordinating an atomic commit across multiple databases using two-phase commit.
33
Vector Clocks
Tracking causality in distributed systems to detect concurrent updates.
34
Logging vs Metrics vs Tracing
The three telemetry types and when each gives you the clearest view of system behaviour.
35
The Three Pillars
How logs, metrics, and traces work together to form a complete observability picture.
36
Alerting Pipelines
Routing, de-duplicating, and escalating alerts to reach the right on-call engineer fast.
37
OAuth 2.0 / JWT Flow
Delegated authorization and stateless identity tokens for securing APIs.
38
Rate Limiting Patterns
Token bucket, leaky bucket, and sliding window algorithms for throttling requests.
39
Zero Trust Architecture
Never trust, always verify: securing systems by treating every request as untrusted.