Core Concepts
Essential building blocks for system design interviews. Understand these thoroughly.
Load Balancing
Distributes incoming traffic across multiple servers to ensure no single server is overwhelmed.
Caching
Stores frequently accessed data in a fast-access layer to reduce latency and database load.
Database Sharding
Horizontally partitions data across multiple database instances to handle large datasets and high throughput.
Message Queues
Enables asynchronous communication between services by buffering messages for later processing.
Consistent Hashing
A hashing technique that minimizes key redistribution when the number of nodes changes in a distributed system.
CAP Theorem
States that a distributed system can only guarantee two of three properties: Consistency, Availability, and Partition Tolerance.
Database Replication
Maintains copies of data on multiple servers for high availability, fault tolerance, and read scalability.
Content Delivery Network (CDN)
A globally distributed network of servers that caches and serves content from locations close to users.
API Gateway
A single entry point for all client requests that handles cross-cutting concerns like auth, rate limiting, and routing.
SQL vs NoSQL Databases
Understanding when to choose relational (SQL) vs non-relational (NoSQL) databases based on data model and access patterns.
Microservices Architecture
An architectural pattern where an application is composed of small, independent services that communicate over well-defined APIs.
Back-of-the-Envelope Estimation
Quick calculations to estimate system capacity, helping you make informed design decisions during interviews.
Rate Limiting
Controlling the number of requests a client can make to an API within a given time window to prevent abuse and protect resources.
WebSocket & Real-Time Communication
Persistent bidirectional communication channels between client and server for real-time features.
Distributed Transactions
Patterns for maintaining data consistency across multiple services or databases in a distributed system.
Bloom Filter
A space-efficient probabilistic data structure that tests whether an element is a member of a set with possible false positives but no false negatives.
Event-Driven Architecture
An architectural pattern where services communicate by producing and consuming events, enabling loose coupling and async processing.
Gossip Protocol
A peer-to-peer communication mechanism where nodes periodically exchange state with random peers, spreading information like an epidemic.
Vector Clocks
A mechanism for tracking causality in distributed systems. Each node maintains a vector of logical timestamps to determine the ordering of events.
Raft Consensus Algorithm
A consensus algorithm that enables a cluster of nodes to agree on a sequence of values, even if some nodes fail. Designed to be more understandable than Paxos.
Merkle Trees
A tree structure where every leaf is a hash of data and every non-leaf is a hash of its children. Enables efficient data integrity verification and synchronization.
Two-Phase Commit (2PC)
A distributed protocol that ensures all participants in a transaction either commit or abort together. Provides atomicity across multiple nodes.
Data Partitioning (Sharding)
Splitting a large dataset across multiple machines. Each partition (shard) holds a subset of the data, enabling horizontal scaling beyond a single machine's capacity.
Leader Election
A process by which distributed nodes choose one node to act as coordinator. Ensures exactly one leader at any time for tasks like write coordination or job scheduling.
Circuit Breaker Pattern
Prevents a service from repeatedly calling a failing downstream dependency. Fails fast instead of waiting for timeouts, protecting the system from cascading failures.