System Design Concepts
110 concepts across 8 categories. Master the fundamentals before tackling interview problems.
Core Concepts
View allScalability
Every production system eventually faces growth. If your architecture cannot scale, you will hit a wall — either the system crashes under load, or you.
Availability
Users and businesses depend on systems being available. A payment system that goes down for 1 hour can cost millions of dollars.
Reliability
A system can be available (running) but unreliable (returning wrong results). A payment system that double-charges customers is available but unreliable.
Single Point of Failure (SPOF)
Identifying and eliminating SPOFs is one of the first things an interviewer expects in a system design discussion.
Latency vs Throughput vs Bandwidth
Confusing latency and throughput is a common interview mistake. A system can have high throughput but high latency (batch processing), or low latency but.
Consistent Hashing
Consistent hashing is the backbone of distributed caching (Memcached), distributed databases (DynamoDB, Cassandra), load balancing, and CDNs.
CAP Theorem
CAP theorem is the most asked theoretical concept in system design interviews. It defines the fundamental constraint of distributed systems.
Failover Explained: Active-Passive, Active-Active and Recovery
Learn failover design for high availability: active-passive, active-active, health checks, recovery time, data consistency, and interview tradeoffs.
Fault Tolerance
In large-scale systems, component failures are not exceptions — they are the norm.
System Design Fundamentals
A comprehensive overview of what system design is, why it matters for every software engineer, and the foundational building blocks that every production.
Capacity Planning
Capacity planning estimates future resource needs (CPU, memory, storage, bandwidth) based on traffic projections, ensuring the system can handle growth.
Autoscaling: Metrics, Policies, Kubernetes HPA and Cloud Scaling
Learn autoscaling for system design: CPU and queue metrics, target tracking, Kubernetes HPA, warm pools, cooldowns, and cost-performance tradeoffs.
Networking
View allOSI Model
The OSI model helps you understand where different technologies operate (TCP at Layer 4, HTTP at Layer 7, load balancers at Layer 4 or 7).
IP Addresses
Understanding IP addressing is essential for designing networked systems — configuring load balancers, VPCs, subnets, and security groups all require IP.
Domain Name System (DNS)
DNS is the first step of every web request. It affects latency, reliability, and can be used for load balancing (DNS-based routing).
Proxy vs Reverse Proxy
Reverse proxies are used in virtually every production system. They handle TLS termination, load balancing, caching, rate limiting, and DDoS protection.
HTTP vs HTTPS: Methods, TLS, Status Codes and API Design
Understand HTTP and HTTPS for system design: methods, headers, status codes, TLS termination, connection reuse, API contracts, and security tradeoffs.
TCP vs UDP
Choosing between TCP and UDP affects your system's performance and reliability. Real-time systems (video calls, gaming) cannot afford TCP's overhead.
Load Balancing
Load balancing is used in virtually every production system. It is one of the first things you add when scaling beyond a single server.
Checksums
Checksums protect data integrity in distributed systems. When transferring files across networks, replicating databases, or storing data on disk, you need.
Data Compression
Data compression reduces payload sizes for faster network transfer and lower storage costs.
Serialization Formats: JSON, Protobuf, Avro and MessagePack
Compare serialization formats for system design: JSON, Protobuf, Avro, MessagePack, schemas, compatibility, payload size, and latency tradeoffs.
Encryption: TLS, AES, Key Management and Data Protection
Learn encryption for system design: TLS in transit, AES at rest, end-to-end encryption, key rotation, KMS, certificate management, and tradeoffs.
APIs
View allWhat is an API
API design is a core skill for backend engineers and a key topic in system design interviews.
API Gateway
In a microservices architecture, clients should not need to know about individual service addresses.
REST vs GraphQL
Choosing between REST and GraphQL is a common API design decision and interview question.
WebSockets
WebSockets power real-time features: chat applications, live notifications, stock tickers, collaborative editing, and online gaming.
Webhooks
Webhooks enable event-driven integrations without continuous polling. They are used by virtually every SaaS platform (Stripe, GitHub, Slack, Twilio) to.
Idempotency
Network failures are inevitable. Clients will retry requests. Without idempotency, retries can cause catastrophic bugs — a payment system that charges.
Rate Limiting
Without rate limiting, a single client can overwhelm your service (intentionally via DDoS or unintentionally via a bug).
API Design Best Practices
APIs are contracts — once published, they are hard to change without breaking clients. Good design from the start saves years of technical debt.
gRPC Explained: Protobuf, HTTP/2, Streaming and Microservices
Understand gRPC for system design: Protocol Buffers, HTTP/2, unary calls, streaming, deadlines, load balancing, and REST vs gRPC tradeoffs.
Authentication: JWT, OAuth 2.0, Sessions and Login Design
Design authentication for distributed systems: passwords, sessions, JWT, OAuth 2.0, refresh tokens, SSO, MFA, security risks, and scaling tradeoffs.
Authorization: RBAC, ABAC, Permissions and Policy Engines
Design authorization for distributed systems: RBAC, ABAC, scopes, policy engines, permission checks, multi-tenancy, and security tradeoffs.
WebRTC: Real-Time Video, Audio, NAT Traversal and SFU Design
Understand WebRTC system design: peer connections, ICE, STUN, TURN, SFU architecture, media routing, latency, and scaling real-time video.
RBAC
Role-Based Access Control assigns permissions to roles, not individual users. Users inherit permissions through role membership, simplifying access.
Single Sign-On: SAML, OpenID Connect and Enterprise Login
Design Single Sign-On for enterprise systems: SAML, OpenID Connect, identity providers, sessions, tenant mapping, security, and scaling tradeoffs.
Databases
View allACID Transactions
Understanding ACID is essential for choosing between SQL and NoSQL databases. Financial systems require ACID. Social media feeds may not.
SQL vs NoSQL
Choosing the right database is one of the most impactful decisions in system design. The wrong choice leads to painful migrations.
Database Indexes
Indexes are the single most impactful performance optimization for databases. A query that takes 30 seconds without an index can take 1 millisecond with.
Database Sharding
When a single database server cannot handle the data volume or query load, sharding is the solution.
Data Replication
Every production database uses replication. Without it, a single server failure means data loss and downtime.
Database Scaling
The database is almost always the first bottleneck in a growing system. Knowing the scaling playbook — and the order in which to apply techniques — is.
Database Types
Choosing the right database for each component of your system is a core design skill.
Bloom Filters
Bloom filters save expensive disk/network lookups. Before querying a database or cache, check the Bloom filter.
Database Architectures: OLTP, OLAP, Replication and Scaling
Compare database architectures for system design: OLTP, OLAP, replication, partitioning, storage engines, consistency models, and scaling tradeoffs.
NoSQL Data Modeling
How to model data in NoSQL databases using denormalization, access-pattern-driven design, and practical patterns for document, wide-column, and key-value.
BASE Properties
BASE (Basically Available, Soft state, Eventually consistent) is an alternative to ACID that relaxes consistency guarantees in favor of availability and.
Full-Text Search
Full-text search enables fast, relevance-ranked querying of unstructured text data using inverted indexes, tokenization, and scoring algorithms like.
Materialized Views
Materialized views are precomputed query results stored as physical tables, trading storage space and write overhead for dramatically faster read.
Query Optimization
Query optimization is the process of analyzing and restructuring database queries, indexes, and execution plans to minimize response time and resource.
Connection Pooling
Connection pooling reuses a pool of pre-established database connections instead of creating new ones per request, dramatically reducing latency and.
LSM Trees: Write-Optimized Storage for Cassandra and RocksDB
Learn LSM Trees for system design: memtables, SSTables, compaction, bloom filters, write amplification, read paths, and database tradeoffs.
B-Trees
B-Trees are self-balancing tree data structures that maintain sorted data in pages optimized for disk I/O, forming the backbone of indexes in PostgreSQL,.
HyperLogLog: Approximate Distinct Counts at Massive Scale
Understand HyperLogLog for system design: cardinality estimation, fixed memory, error rates, analytics use cases, Redis PFCOUNT, and tradeoffs.
Time Series Databases: Metrics, Retention and High-Write Storage
Learn time series database design: timestamped writes, retention policies, downsampling, compression, Prometheus, InfluxDB, and query tradeoffs.
Vector Databases
Vector databases store and query high-dimensional vector embeddings using approximate nearest neighbor (ANN) search, enabling semantic similarity search.
ETL Pipelines: Batch Processing, Transformation and Data Loading
Learn ETL pipeline design: extraction, transformation, loading, batch jobs, orchestration, retries, data quality, lineage, and warehouse tradeoffs.
Data Pipelines: Batch, Streaming, Reliability and Backpressure
Design data pipelines for system design: batch vs streaming, queues, checkpoints, retries, backpressure, data quality, and operational tradeoffs.
Data Lakes: Raw Storage, Governance and Analytics Architecture
Learn data lake architecture: raw object storage, zones, catalogs, governance, file formats, query engines, lakehouse patterns, and tradeoffs.
Data Warehouses
Data warehouses are centralized, schema-on-write analytical databases optimized for complex queries across large volumes of structured, historical data,.
Caching
View allCaching 101: Cache-Aside, TTL, Invalidation and Redis Basics
Learn caching fundamentals for system design: cache-aside, TTLs, invalidation, Redis, hit rate, stampedes, consistency, and interview examples.
Caching Strategies
Choosing the wrong caching strategy leads to stale data, cache misses, or unnecessary database load.
Cache Eviction Policies: LRU, LFU, FIFO and TTL Tradeoffs
Compare cache eviction policies including LRU, LFU, FIFO, random eviction and TTL-based expiry with hit-rate, memory, and Redis interview tradeoffs.
Distributed Caching
A single Redis server can only hold as much data as its RAM allows. Distributed caching (Redis Cluster, Memcached with consistent hashing) scales.
Content Delivery Network (CDN)
CDNs are essential for any user-facing application. They reduce latency, reduce origin server load, protect against DDoS attacks, and handle traffic.
Cache Warming: Prevent Cold Starts and Latency Spikes
Learn cache warming strategies for production systems: preloading hot keys, deployment warming, CDN warming, invalidation risks, and interview tradeoffs.
Cache Stampede
A cache stampede (thundering herd) occurs when many requests simultaneously miss the cache and hit the database, causing a load spike that can bring down.
Async Communication
View allPublish-Subscribe Pattern
Pub/Sub is the foundation of event-driven architectures. It enables microservices to communicate asynchronously, decouples producers from consumers, and.
Message Queues: RabbitMQ, SQS, Kafka and Async Processing
Master message queues for system design: producers, consumers, retries, dead-letter queues, ordering, backpressure, Kafka vs RabbitMQ, and tradeoffs.
Change Data Capture: CDC Patterns for Real-Time Data Sync
Learn Change Data Capture for system design: transaction logs, Debezium, event streams, cache sync, search indexing, analytics, and consistency tradeoffs.
Backpressure
Backpressure is a flow control mechanism where a slow consumer signals upstream producers to slow down, preventing memory exhaustion and cascading.
Distributed Systems
View allHeartbeats in Distributed Systems
Failure detection is the foundation of fault tolerance. Without heartbeats, you cannot know when a server has crashed, and failover cannot begin.
Service Discovery
In microservices architectures with dynamic scaling (containers, Kubernetes), services come and go constantly.
Consensus Algorithms: Raft, Paxos and ZAB
Understand consensus algorithms: Raft leader election, Paxos, ZAB, quorum rules, replication safety, tradeoffs, and interview questions.
Distributed Locking
Without distributed locks, concurrent processes can cause data corruption, double-spending, overselling inventory, or duplicate processing.
Gossip Protocol
Gossip protocols enable decentralized failure detection, membership management, and data dissemination without a central coordinator.
Circuit Breaker Pattern
Without circuit breakers, a failing downstream service can cascade failures throughout your system.
Disaster Recovery
Disasters happen: AWS us-east-1 has had multi-hour outages, entire data centers have lost power, and ransomware attacks have encrypted production.
Bulkhead Pattern: Isolate Failures in Distributed Systems
Learn the Bulkhead Pattern for distributed systems: resource isolation, thread pools, connection pools, blast-radius control, and resilience tradeoffs.
Distributed Tracing: Spans, Trace IDs, OpenTelemetry and Debugging
Learn distributed tracing for microservices: trace IDs, spans, context propagation, OpenTelemetry, latency diagnosis, sampling, and observability tradeoffs.
Leader Election
How distributed systems elect a single leader to coordinate work, covering Raft, Bully, and Ring algorithms, along with real-world implementations in.
Retry Patterns
Learn Retry Patterns including exponential backoff with jitter — handle transient failures gracefully in distributed systems without overwhelming.
Timeout Patterns
Learn Timeout Patterns for distributed systems — configure connect, read, and write timeouts to prevent hung requests from consuming resources and.
Load Shedding
Learn Load Shedding in distributed systems — intentionally dropping excess requests to protect system stability and maintain quality of service for.
Observability: Logs, Metrics, Traces and Production Debugging
Learn observability for distributed systems: logs, metrics, traces, SLOs, dashboards, alerting, OpenTelemetry, and debugging tradeoffs.
Logging
Learn structured logging and log levels for distributed systems — capture meaningful context, correlate events across services, and build queryable.
Metrics: Counters, Gauges, Histograms and SLO Monitoring
Learn metrics for distributed systems: counters, gauges, histograms, RED/USE methods, cardinality, dashboards, alerting, and capacity planning.
Correlation IDs
Learn Correlation IDs for request tracing across distributed services — attach unique identifiers to requests so logs, metrics, and traces can be linked.
Monitoring
Learn Monitoring for distributed systems — build dashboards, set SLOs, configure alerts, and establish processes to detect, diagnose, and respond to.
Alerting: SLOs, On-Call, Escalation and Noise Reduction
Design effective alerting for distributed systems: SLO-based alerts, thresholds, escalation policies, alert fatigue, runbooks, and incident response.
Service Mesh
Learn Service Mesh architecture with Istio, Linkerd, and sidecar proxies — handle service-to-service communication, security, observability, and traffic.
Sidecar Pattern
Learn the Sidecar Pattern for distributed systems — deploy companion containers alongside application services to handle cross-cutting concerns like.
Merkle Trees
Learn Merkle Trees — hash-based tree structures that enable efficient data verification, tamper detection, and synchronization in distributed systems and.
MapReduce Explained: Distributed Batch Processing at Scale
Understand MapReduce for system design: map phase, shuffle, reduce phase, fault tolerance, data locality, Hadoop, and batch processing tradeoffs.
Secrets Management
Learn Secrets Management for distributed systems — securely store, distribute, and rotate credentials, API keys, and certificates using tools like.
Erasure Coding
Learn Erasure Coding for distributed storage — achieve fault tolerance with less storage overhead than replication by encoding data into fragments that.
Architecture Patterns
View allCQRS
CQRS separates read and write models so each can be optimized independently — write to a normalized database, read from a denormalized projection.
Client-Server Architecture
Client-server is the most fundamental architectural pattern. Understanding it is the starting point for all system design discussions.
Event Sourcing
Event Sourcing stores every state change as an immutable event. The current state is derived by replaying events, providing a complete audit trail and.
BFF Pattern
Backend for Frontend (BFF) creates dedicated backend services for each frontend type (web, mobile, TV), tailoring API responses to each client's specific.
Microservices Architecture
Microservices enable large engineering teams to work independently, deploy frequently, scale individual components, and use the best technology for each.
Serverless Architecture: Functions, Cold Starts and Scaling Tradeoffs
Learn serverless architecture for system design: FaaS, cold starts, event triggers, scaling limits, state management, observability, and cost tradeoffs.
Strangler Fig Pattern
The Strangler Fig Pattern incrementally migrates a legacy monolith to microservices by routing traffic to new services one feature at a time, avoiding.
Blue-Green Deployment: Zero-Downtime Releases and Rollbacks
Learn blue-green deployment for system design: parallel environments, traffic switching, database migration risks, rollback strategy, and release tradeoffs.
Event-Driven Architecture: Events, Brokers and Loose Coupling
Master event-driven architecture: producers, consumers, brokers, event schemas, ordering, idempotency, outbox pattern, and microservice tradeoffs.
Canary Release
Canary release gradually rolls out a new version to a small percentage of users first, monitoring for issues before expanding to 100%, reducing the blast.
Peer-to-Peer Architecture
P2P eliminates the need for central servers, making systems more resilient and cost-effective for certain use cases.
Feature Flags: Progressive Delivery, Experiments and Safe Rollouts
Learn feature flags for system design: kill switches, percentage rollout, A/B tests, config stores, flag debt, consistency, and release tradeoffs.
Monolith vs Microservices
When to use a monolithic architecture versus microservices, the real tradeoffs involved, and practical migration strategies used by companies like.