#System Design — ByteDepth

High Level Design

Handling Numbers in System Design

The essential reference for system design interviews — powers of two, latency numbers every engineer should know, and availability nines decoded.

System Design Estimation Back-of-Envelope

High Level Design

Choosing the Right Database

A practical decision framework for picking the right database in a system design interview — relational, key-value, wide-column, document, graph, time-series, search, and blob storage compared.

System Design Database Architecture

High Level Design

Design a Chat System

End-to-end design of a real-time chat system for 50M DAU — covering WebSocket protocol choice, message fanout, multi-device sync, presence management, and media storage.

System Design Chat WebSocket

High Level Design

Design a Video Streaming Service

End-to-end design of a YouTube-like video platform — uploading flow, adaptive streaming, DAG-based transcoding pipeline, CDN cost optimizations, pre-signed URLs, DRM, and fault-tolerant error handling.

System Design Video Streaming CDN

High Level Design

Designing an Email Service

End-to-end design of a scalable email service — service registration, 2FA authentication, global cache with sidecar pattern, API contracts, tagging, spam detection, full-text search with inverted index, and contacts/groups management.

System Design Email Notifications

High Level Design

API Design

What makes a good API — goals of scalability, extensibility, and ease of use, plus REST best practices and common design patterns.

System Design API Design REST

High Level Design

Caching

How caching works, the five write strategies (read-through, cache-aside, write-through, write-around, write-back), eviction policies, and common pitfalls.

System Design Caching Redis

High Level Design

Content Delivery Networks (CDN)

What CDNs are, how they work with edge servers and origin servers, their benefits and challenges, and how to choose the right provider.

System Design CDN Networking

High Level Design

Consistency & Isolation in Distributed Systems

Consistency models (linearizable, eventual, causal, quorum), database transactions, and the four isolation levels — from read uncommitted to serializable.

System Design Distributed Systems CAP Theorem

High Level Design

Data Replication & Migration

Primary-replica replication, WAL and CDC, async vs sync vs semi-sync trade-offs, split-brain problem, write amplification, and zero-downtime migration strategies.

System Design Database Replication

High Level Design

Database Selection Guide

A structured decision framework for choosing the right database — SQL vs NoSQL, CAP thinking, NoSQL types, and interview-ready justification templates.

System Design Database SQL

High Level Design

Databases

What databases are, how data is stored and retrieved, in-memory vs disk trade-offs, and a tour of relational vs NoSQL data models.

System Design Database SQL

High Level Design

Distributed Consensus with Paxos

Two-Phase Commit, how Paxos achieves consensus through majority agreement, and the multi-server write coordination protocol with log-line locking.

System Design Distributed Systems Consensus

High Level Design

Idempotency in Distributed Systems

Why idempotency matters, how to implement idempotency keys in APIs and message queues, and the trade-offs of tracking duplicate requests.

System Design API Design Idempotency

High Level Design

Kafka

Kafka's architecture, core components, partitions, ISR-based durability, trade-offs, and when to use it over RabbitMQ or SQS.

System Design Kafka Message Queue

High Level Design

Load Balancing

Load balancers, routing algorithms, Layer 4 vs Layer 7 balancing, health checks, and how traffic flows through a real system.

System Design Load Balancing Scalability

High Level Design

Message Queues

How message queues decouple producers and consumers, core components, edge cases like poison messages and duplicates, and popular implementations.

System Design Message Queue Async

High Level Design

Microservices vs Monolithic Architecture

A side-by-side comparison of monolithic and microservices architectures across scalability, deployment, fault isolation, team structure, and when to choose each.

System Design Microservices Architecture

High Level Design

Networks

Network fundamentals for system design — OSI model, DNS, HTTP, TCP vs UDP, REST vs GraphQL, WebSockets, WebRTC, and video streaming protocols.

System Design Networking HTTP

High Level Design

Observability in Distributed Systems

Logging, monitoring, anomaly detection algorithms, and root cause analysis techniques for distributed systems.

System Design Observability Monitoring

High Level Design

Rate Limiting: System Architecture

Why rate limiting matters, the Timer Wheel and Hierarchical Timer Wheel approach, and a full distributed rate-limiting architecture with request sharding.

System Design Rate Limiting API Design

High Level Design

Redis & Memcached

Redis architecture, use cases, failure modes and mitigations, design FAQs, and a Memcached comparison — everything needed for a caching deep-dive.

System Design Redis Caching

High Level Design

Scalability: The Basics

Core concepts of scalability — vertical vs horizontal scaling, components that improve it, and trade-offs every system designer must reason about.

System Design Scalability Architecture

High Level Design

Security in Distributed Systems

Authentication mechanisms (token-based, SSO, OAuth), authorization patterns (ACLs, rule engines), attack vectors, and how to secure CDN-delivered content.

System Design Security Authentication

High Level Design

System Design Trade-offs

Pull vs Push, Memory vs Latency, Throughput vs Latency, Consistency vs Availability, Latency vs Accuracy — every key trade-off with decision frameworks.

System Design Architecture Trade-offs

High Level Design

Consistent Hashing

How consistent hashing solves the massive-rehashing problem in distributed systems — hash rings, virtual nodes, load imbalance, and real-world use cases.

System Design Distributed Systems Consistent Hashing

High Level Design

Designing a Key-Value Store

End-to-end design of a distributed key-value store — CAP theorem, consistent hashing, replication, conflict resolution with vector clocks, failure handling, and the detailed read/write path.

System Design Database Key-Value Store

High Level Design

Designing a Load Balancer

End-to-end design of a production-grade load balancer — control and data planes, health checking, session persistence, SSL termination, and high-availability with active-active failover.

System Design Load Balancing Scalability

High Level Design

Design a Notification System

End-to-end design of a scalable notification system — iOS/Android push, SMS, email, message queues for async delivery, reliability, deduplication, and the improved multi-server architecture.

System Design Notifications Push

High Level Design

Designing a Unique ID Generator

Designing a distributed unique ID generator — comparing multi-master replication, UUID, ticket servers, and Twitter Snowflake, with a deep dive into the 64-bit Snowflake layout and follow-up considerations.

System Design Distributed Systems ID Generation

High Level Design

Designing a URL Shortener

End-to-end design of a URL shortening service — estimations, API design, 301 vs 302 redirects, hash functions with collision resolution, base62 encoding, and the deep-dive read/write paths.

System Design URL Shortener Hashing

High Level Design

Design a Rate Limiter

A comprehensive study guide to designing a production-grade rate limiter. Covers placement strategies, five core algorithms with trade-offs, high-level and detailed design, and distributed system challenges like race conditions and synchronization.

System Design Rate Limiting API Design

High Level Design

Design a News Feed System

Designing a scalable news feed system requires balancing: Write efficiency vs read latency Cache size vs data freshness Push vs pull models Throughput vs storage cost

System Design News Feed Social Media