Learn System DesignVisually

What is system design and how it is used in interviews.

Understanding functional requirements in system design.

Non-functional requirements: scalability, reliability, and performance.

Learn what capacity estimation is and the different types.

Key thumb rules for back-of-envelope estimations.

Worked examples of capacity calculations for real systems.

Infrastructure planning based on capacity estimates.

Combined walkthrough of calculations and infrastructure.

Introduction to scaling concepts in distributed systems.

Vertical scaling: scaling up a single machine.

Horizontal scaling: distributing load across multiple machines.

Load balancers explained — L4 vs L7, OSI layers, pass-through vs proxy mode, algorithms (Round Robin, Weighted, Least Connection, Consistent Hashing), and TCP/TLS termination.

Stateless vs stateful services and their scaling implications.

Auto scaling policies and strategies for dynamic workloads.

Forward vs reverse proxies — what they are, why they exist, and common examples like Nginx, HAProxy, and Cloudflare.

Load balancers explained — L4 vs L7, OSI layers, pass-through vs proxy mode, algorithms, and TCP/TLS termination.

How CDNs work — edge caching, static asset delivery, cache invalidation, and when to use a CDN vs origin storage.

API Gateway responsibilities — TLS termination, routing, auth, rate limiting, and centralized API management.

CDN vs Load Balancer vs API Gateway vs Proxy — when you need each, with real architecture scenarios from static sites to microservices.

Overview of common system architecture patterns.

Monolithic architecture: benefits, drawbacks, and use cases.

Microservices architecture and decomposition strategies.

Event-driven architecture with asynchronous communication.

Decision framework for choosing the right architecture pattern.

Time in distributed systems: challenges and concepts.

Physical clocks, clock skew, and synchronization protocols.

Logical clocks: Lamport timestamps and vector clocks.

Summary and comparison of time synchronization approaches.

CAP theorem: Consistency, Availability, Partition tolerance.

PACELC theorem extending CAP with latency trade-offs.

Consensus algorithms and Byzantine fault tolerance.

Consistency models in distributed databases.

ACID properties: Atomicity, Consistency, Isolation, Durability.

BASE properties: Basically Available, Soft state, Eventual consistency.

Comparing ACID and BASE consistency models.

Distributed transactions: challenges and solutions.

Two-phase commit protocol for distributed consistency.

Three-phase commit protocol to avoid blocking in 2PC.

Saga pattern for managing long-running distributed transactions.

TCC pattern for flexible distributed transaction management.

Relational databases: structure, use cases, and trade-offs.

Visual taxonomy of database types and their relationships.

Deep dive into database internals, storage engines, and indexing strategies.

Why databases replicate data, and the reliability and latency trade-offs of copying writes across nodes.

Single-leader replication: how followers catch up, failover, and read-after-write issues.

Multi-leader setups for multi-datacenter writes, and the conflict patterns they introduce.

Leaderless replication with quorums, hinted handoff, and read repair.

Synchronous, asynchronous, and semi-synchronous commit — durability versus write latency.

How replica sets elect a new leader after failure, and what happens to in-flight writes.

Detecting and resolving write conflicts in multi-leader replication, including last-write-wins and merge strategies.