System Design Questions

System Design Academy

All at one place, free guide to ace your next distributed system design interview & become a better engineer.

Start learning →

coming soonpretty much everything about system design.

table of contents

master making better architecture and design decisions for scalable, fault-tolerant, and highly available systems.

I'm aiming to have it finished by the end of Dec 2025. Meanwhile, some of the content is already published, check it out. Travis, Avinash & 1340+ others on the waitlist. Stay tuned @systemdesignHQ for early access and updates. Any suggestions? I'm sitting behind systemdesignacademy@gmail.com

Fundamentals of System Design

This section is a quick intro to the basic fundamental concepts of designing distributed systems. These tiny essays will help you better understand the critical concepts of system design.

What is a system design?

Introduction to system design

Scalability

What is scalability?Scalability vs Performance

Availability

What is availability?How is availability measured?What causes low availability?How to achieve high availability?Types of failures in distributed systems?What are availability patterns?

Reliability

What is reliability?SLAs, SLOs, and SLIs explained

Fault tolerance

What is Fault tolerance?Fault tolerance vs availability Graceful degradation strategies

Consistency

What is Consistency?A word on Consistency patterns.Eventual consistency in distributed systems

CAP theorem

A word on CAP theorem.PACELC theorem explained

Concurrency

What is Concurrency?Introduction to threads, deadlock & starvation.Race conditions and synchronization

Idempotency

What is idempotency and why it matters?Implementing idempotent operations

Clock and time in distributed systems

Why time is hard in distributed systems Introduction to logical clocks and NTP Vector clocks and causality

Retry, timeout and backoff strategies

Introduction to timeouts and retries What is exponential backoff?

Networking

Latency vs. through-put vs. bandwidth.Introduction to DNS (domain name system)TCP vs UDP in system design HTTP/HTTPS and REST principles

A basic intro to core components

Introduction to CDN Introduction to Load balancer Introduction to Caching Introduction to API Gateway

Service Discovery & Heartbeats

What is service discovery?How do heartbeats help detect failures?Service registry patterns

Estimation & Back-of-envelope calculations

System design estimation fundamentals Capacity planning basics QPS, storage, and bandwidth calculations

Architectural Patterns

Essential architectural patterns and design principles that form the backbone of scalable distributed systems.

Monolithic vs Microservices

Monolithic architecture pros and cons Introduction to microservices When to choose microservices vs monolith Service decomposition strategies

Event-Driven Architecture

What is event-driven architecture?Event sourcing patterns CQRS (Command Query Responsibility Segregation)Pub/Sub messaging patterns

Resilience Patterns

Circuit breaker pattern Bulkhead pattern Retry and timeout patterns Saga pattern for distributed transactions

Migration Patterns

Strangler fig pattern Blue-green deployment Canary deployment

API Design Patterns

RESTful API design principles GraphQL vs REST API versioning strategies API rate limiting and throttling

Fundamentals of Databases

This section discusses the fundamental concepts of database engineering that every software engineer must be aware of.

ACID

Atomicity.Consistency.Isolation.Durability.Understanding ACID properties with a live example.

Database Transactions

What are database transactions?Transaction isolation levels Phantom Reads.Dirty reads and non-repeatable reads Serialization vs. Repeatable Read

Database Fundamentals

OLTP vs OLAP systems Database normalization Primary keys, foreign keys, and constraints

Scaling Databases

Database is a hypercritical component of any application to scale. In this section, we will be leveling up our knowledge by understanding various database scaling concepts.

Database Indexing

Indexing - data structure that powers your database.How database indexing actually works internally?B-tree and B+ tree indexes Hash indexes and bitmap indexes Composite indexes and index optimization

Database Locking

Introduction to database locking.

Database Locking

Introduction to database locking.Row-level vs table-level locking Deadlock detection and prevention

Database Tuning & Optimizations

What is database performance tuning?Query optimization techniques Database connection pooling Analyzing query execution plans

Database Replication

What is database replication?Master-slave replication Master-master replication Replication lag and consistency

Database Partitioning

What is database partitioning?Horizontal partitioning (sharding)Vertical partitioning Sharding strategies and challenges Consistent hashing for sharding

Designing Database Schema

Database schema design principles Choosing the right data types Database migration strategies

Internals of Databases

In this advanced section, we will talk about the interesting internals of databases to deeply understand the inner beauty of various databases.

Storage Engine Internals

How tables and indexes are stored on disk?B-tree and LSM-tree storage structures Page layouts and buffer pool management Write-ahead logging (WAL) mechanisms

Query Processing

Query parsing and optimization Execution plan generation Join algorithms and optimization Cost-based optimization

MySQL Internals

InnoDB storage engine architecture Sorting algorithm behind ORDER BY query in MySQL?MySQL replication internals Transaction isolation in InnoDB

NoSQL Database Internals

MongoDB document storage and indexing Cassandra ring architecture and partitioning Redis data structures and persistence Elasticsearch inverted index structure

Data Storages

In this section, we will deep dive & discuss various data storages (databases), their internals and which one to choose, as per the use case.

SQL Databases

Introduction to SQL databases Popular SQL databases (MySQL, PostgreSQL, SQL Server)SQL transactions and ACID compliance When to choose SQL databases

NoSQL Databases

Introduction to NoSQL databases Document databases (MongoDB, CouchDB)Key-value stores (Redis, DynamoDB)Wide-column stores (Cassandra, HBase)Graph databases (Neo4j, Amazon Neptune)

bonusSQL vs NoSQL - which, when, where & why?

Specialized Databases

Time Series Database (InfluxDB, TimescaleDB)What is time-series data?Why store time-series data?When to choose a time-series database?Search engines (Elasticsearch, Solr)In-memory databases (Redis, Memcached)

Data Warehouses & Analytics

What is a data warehouse?Columnar databases (Redshift, BigQuery)Data lakes vs data warehouses ETL vs ELT pipelines

Storage Systems

Introduction to blob storage (S3, Azure Blob)File storage systems Object storage vs block storage Distributed file systems (HDFS, GFS)

Message Queues & Communication

Understanding asynchronous communication patterns and message-driven architectures essential for building scalable distributed systems.

Message Queue Fundamentals

What are message queues?Synchronous vs asynchronous communication Point-to-point vs publish-subscribe Message ordering and delivery guarantees

Popular Message Queue Systems

Apache Kafka architecture and use cases RabbitMQ and AMQP protocol Amazon SQS and cloud message queues Redis pub/sub capabilities

Message Processing Patterns

Dead letter queues Message deduplication strategies Batch processing vs stream processing Consumer groups and load balancing

Stream Processing

Introduction to stream processing Apache Kafka Streams Apache Flink and real-time processing Windowing and aggregations

Caching Strategies

Deep dive into caching patterns, strategies, and technologies that are crucial for building high-performance systems.

Caching Fundamentals

What is caching and why it matters?Cache hit ratio and performance metrics Cache invalidation strategies Cache coherence and consistency

Caching Patterns

Cache-aside (lazy loading)Write-through caching Write-behind (write-back) caching Refresh-ahead caching

Cache Technologies

Redis deep dive Memcached vs Redis Application-level caching Database query result caching

Distributed Caching

Distributed cache architecture Cache sharding and partitioning Cache replication strategies Handling cache failures

Load Balancing & Traffic Management

Comprehensive coverage of load balancing strategies, algorithms, and traffic management techniques for distributed systems.

Load Balancing Fundamentals

What is load balancing?Layer 4 vs Layer 7 load balancing Hardware vs software load balancers Load balancer placement strategies

Load Balancing Algorithms

Round robin and weighted round robin Least connections algorithm IP hash and consistent hashing Least response time algorithm

Health Checks & Failover

Health check strategies Active vs passive health checks Failover and failback strategies Circuit breaker integration

Advanced Traffic Management

Sticky sessions and session affinity Rate limiting and throttling Traffic shaping and QoS Global load balancing

Distributed Systems Advanced

Advanced distributed systems concepts including consensus algorithms, distributed transactions, and coordination patterns.

Consensus Algorithms

What is consensus in distributed systems?Raft consensus algorithm Paxos algorithm explained Byzantine fault tolerance

Distributed Transactions

Two-phase commit (2PC) protocol Three-phase commit (3PC) protocol Saga pattern for long-running transactions Eventual consistency patterns

Coordination & Synchronization

Distributed locks and leader election Apache Zookeeper coordination service etcd for distributed coordination Gossip protocols for information dissemination

Partitioning & Replication

Data partitioning strategies Consistent hashing deep dive Replication strategies (master-slave, master-master)Quorum-based systems

Performance Engineering

Performance optimization techniques, profiling, and scaling strategies for high-performance distributed systems.

Performance Fundamentals

Performance metrics and KPIs Latency vs throughput trade-offs Performance testing strategies Capacity planning and forecasting

Application Performance

Code-level optimization techniques Memory management and garbage collection Asynchronous programming patterns Connection pooling and resource management

Database Performance

Query optimization and indexing strategies Database connection pooling Read replicas and write optimization Database partitioning for performance

System Performance

CPU, memory, and I/O optimization Network performance optimization Container and orchestration performance CDN and edge computing optimization

Modern Infrastructure & DevOps

Modern infrastructure patterns, containerization, orchestration, and DevOps practices for scalable systems.

Containerization

Docker fundamentals for system design Container orchestration with Kubernetes Microservices deployment patterns Service mesh architecture (Istio, Linkerd)

Cloud Architecture

Cloud-native application design Serverless architecture patterns Multi-cloud and hybrid cloud strategies Edge computing and CDN integration

Deployment Strategies

CI/CD pipeline design Blue-green deployment Canary deployment strategies Rolling deployment and rollback

Infrastructure as Code

Infrastructure automation principles Configuration management Auto-scaling and resource management Disaster recovery and backup strategies

Security & Authentication

Essential security concepts and authentication mechanisms for building secure distributed systems.

Authentication & Authorization

Authentication vs authorization OAuth 2.0 and OpenID Connect JWT tokens and session management Single Sign-On (SSO) systems

API Security

API authentication strategies API keys vs tokens Rate limiting for security Input validation and sanitization

Security Patterns

Defense in depth strategy Zero trust architecture Principle of least privilege Security by design

Common Security Threats

DDoS attacks and mitigation SQL injection prevention Cross-site scripting (XSS) prevention Data encryption at rest and in transit

Monitoring & Observability

Comprehensive monitoring, logging, and observability strategies for maintaining healthy distributed systems.

Monitoring Fundamentals

What is observability?Metrics, logs, and traces (three pillars)Monitoring vs observability SLIs, SLOs, and error budgets

Metrics & Alerting

Application metrics and KPIs Infrastructure monitoring Alerting strategies and alert fatigue Dashboards and visualization

Logging Strategies

Structured logging best practices Centralized logging architecture Log aggregation and analysis Log retention and storage