All Concepts

A complete encyclopedia of system design patterns, distributed systems concepts, and real-world architectures.

Computing & Low Level

Concurrency Patterns

Essential patterns for managing concurrent execution. Mutex, Semaphores, Monitors, and modern approaches like the Actor Model and CSP.

Explore Concept

Intermediate

Process vs Thread

Understanding the fundamental units of execution in operating systems. A deep dive into memory models, context switching costs, and concurrency implementation details.

Explore Concept

Databases & Storage

Intermediate

ACID vs BASE: Consistency Models

The two philosophies of database transaction handling: Strict guarantees (ACID) versus flexible availability (BASE). Deep dive into isolation levels, transaction anomalies, and hybrid approaches.

Explore Concept

Advanced

Consistent Hashing

How to add/remove servers without moving every single key. The Ring, Virtual Nodes, and real-world usage in Cassandra, DynamoDB, and Discord.

Explore Concept

Expert

CRDTs (Real-time Collaboration)

Conflict-free Replicated Data Types enable distributed systems to achieve eventual consistency without coordination, powering Google Docs, Figma, and collaborative editing through mathematically proven merge algorithms.

Explore Concept

Advanced

Database Indexing

Deep dive into database indexing internals. How B-Trees work, Clustered vs Non-Clustered indexes, Composite Index best practices, and covering indexes.

Explore Concept

Intermediate

Database Replication

The process of copying and maintaining database objects in multiple databases to improve reliability, fault-tolerance, and accessibility.

Explore Concept

Advanced

Database Sharding

How to split a massive database across multiple servers. Horizontal scaling strategies, challenges (Joins, ACID), and real-world algorithms used by Instagram, Vitess, and CockroachDB.

Explore Concept

Advanced

Distributed File Systems

Complete guide to storing petabytes across thousands of machines using distributed file systems like HDFS and GFS, covering chunking, replication, master-slave architecture, and implementation patterns powering Google, Facebook, and Hadoop ecosystems.

Explore Concept

Advanced

Distributed Transactions

Managing data consistency across multiple services where a single operation must either fully succeed or fully fail. Deep dive into SAGA, 2PC, and modern patterns.

Explore Concept

Advanced

Object Storage (S3 Design)

How systems like Amazon S3 store petabytes of data. Design internals, Erasure Coding vs Replication, Multipart Uploads, and Consistency Models.

Explore Concept

Beginner

SQL vs NoSQL: The Database Guide

Complete database selection guide covering relational vs non-relational systems, ACID vs BASE, when to use PostgreSQL vs MongoDB vs Redis vs Neo4j, and production decision frameworks from Netflix, Uber, and Instagram choosing databases for specific use cases.

Explore Concept

Advanced

Vector Databases (AI/Embeddings)

Complete guide to vector databases optimized for AI embeddings and semantic search, covering vector similarity, approximate nearest neighbor algorithms (HNSW, IVF), and production implementations in Pinecone, Milvus, Weaviate, and pgvector powering LLM applications.

Explore Concept

Advanced

Write-Ahead Logging (WAL)

The backbone of database durability (ACID). How WAL ensures data isn't lost during crashes, implementation details (LSN, Checkpointing), and its role in replication.

Explore Concept

DevOps & Observability

Intermediate

Blue-Green Deployment

Zero-downtime deployment strategy using two identical production environments (Blue and Green) to enable instant rollbacks, reduce risk, and allow thorough testing before directing traffic.

Explore Concept

Intermediate

CI/CD Pipeline Architecture

Designing robust Continuous Integration and Continuous Deployment pipelines. Strategies for artifact promotion, testing pyramids, canary deployments, and rollback mechanisms.

Explore Concept

Intermediate

Distributed Tracing

Complete guide to tracking requests across microservices using distributed tracing, covering trace context propagation, span instrumentation, OpenTelemetry implementation, and production debugging with Jaeger, Zipkin, and Datadog APM.

Explore Concept

Advanced

Docker Internals

What actually is a container? Just a Linux process with a mask on. Deep dive into Namespaces, Cgroups, and Union Filesystems (OverlayFS).

Explore Concept

Pro

Kubernetes Architecture Explained

Under the hood of K8s: The Control Plane (API Server, Scheduler, Etcd, Controllers) and Data Plane (Kubelet, Kube-proxy, Container Runtime).

Explore Concept

Intermediate

The Observability Stack

Moving beyond simple monitoring. How to build a full observability stack using the Three Pillars: Logs, Metrics, and Distributed Tracing.

Explore Concept

Networking & Protocols

Advanced

BitTorrent Protocol (P2P File Sharing)

Complete guide to peer-to-peer file sharing using BitTorrent protocol, covering torrent structure, piece exchange, tit-for-tat algorithm, DHT for decentralization, and real-world implementations powering massive file distribution networks.

Explore Concept

Beginner

DNS Architecture

The phonebook of the internet. How Domain Name System works, the hierarchy of Route 53, and recursive vs iterative resolution strategies.

Explore Concept

Advanced

Gossip Protocol

A peer-to-peer communication protocol where information spreads like a virus (or rumor) through the cluster.

Explore Concept

Intermediate

GraphQL vs REST vs gRPC

Comprehensive comparison of three major API paradigms: REST (resource-based), GraphQL (query-based), and gRPC (RPC-based), covering performance, use cases, and implementation trade-offs for modern distributed systems.

Explore Concept

Intermediate

HTTP Evolution (H1 to H3)

From text-based HTTP/1.1 to binary HTTP/2 and UDP-based HTTP/3 (QUIC). Why we needed upgrades and how they solve Head-of-Line Blocking.

Explore Concept

Pro

Apache Kafka Architecture

Understanding the internals of the world's most popular event streaming platform. Topics, Partitions, Offsets, Consumer Groups, and the transition from ZooKeeper to KRaft.

Explore Concept

Intermediate

Load Balancing

Layer 4 vs Layer 7 Load Balancing. Algorithms (Round Robin, Least Connections, Consistent Hashing). Health checks and real-world implementation with Nginx.

Explore Concept

Intermediate

Message Queues

An asynchronous communication mechanism that enables different parts of a system to communicate by sending messages without requiring immediate responses.

Explore Concept

Advanced

OAuth 2.0 & OpenID Connect

Industry-standard protocols for authorization (delegated access) and authentication (identity verification), enabling secure "Sign in with Google/Facebook" and API access without sharing passwords.

Explore Concept

Beginner

Proxies: Forward vs Reverse

Understanding proxy servers that act as intermediaries between clients and servers, including forward proxies for client anonymity and reverse proxies for load balancing, security, and caching.

Explore Concept

Intermediate

Service Discovery

Complete guide to microservice discovery in dynamic cloud environments, covering client-side vs server-side patterns, health checks, DNS-based discovery, and production implementations using Consul, etcd, Eureka, and Kubernetes services.

Explore Concept

Advanced

TCP Handshake & Congestion

The 3-way handshake that powers the internet. SYN, SYN-ACK, ACK. Flow control vs Congestion control, and modern algorithms like BBR.

Explore Concept

Expert

Tor Network (Onion Routing)

Comprehensive guide to anonymous communication using onion routing, covering multi-layer encryption, circuit construction, hidden services, and real-world privacy protection mechanisms used by journalists, activists, and privacy-conscious users worldwide.

Explore Concept

Expert

WebRTC (Peer-to-Peer Communication)

Web Real-Time Communication protocol enabling direct peer-to-peer audio, video, and data transfer between browsers without intermediary servers, powering low-latency applications like Zoom and Google Meet.

Explore Concept

Intermediate

WebSockets vs Polling

Comprehensive comparison of real-time communication techniques including short polling, long polling, Server-Sent Events (SSE), and WebSockets for building responsive web applications.

Explore Concept

ML/AI System Design

Advanced

ML Model Serving

Taking models from Jupyter Notebooks to Production. Inference patterns (Real-time vs Batch), Batching strategies, and optimization techniques (Quantization, KV Caching).

Explore Concept

Intermediate

RAG Architecture (LLMs)

Retrieval-Augmented Generation. How to stop Large Language Models (LLMs) from hallucinating by grounding them in your private data.

Explore Concept

Cloud Computing

Intermediate

Serverless Architecture (FaaS)

Functions as a Service (AWS Lambda). The Event-Driven paradigm shift. Benefits (Scaling to Zero) vs Drawbacks (Cold Starts, Vendor Lock-in).

Explore Concept

System Design Patterns

Beginner

API Gateway Pattern

The single entry point for microservices. Implementing rate limiting, authentication, and protocol translation/aggregation.

Explore Concept

Intermediate

Backpressure

Flow control mechanism that prevents fast producers from overwhelming slow consumers by signaling when to slow down, pause, or drop data in streaming systems.

Explore Concept

Advanced

Bloom Filters

Space-efficient probabilistic data structure for membership testing that allows false positives but guarantees no false negatives, using minimal memory compared to hash sets.

Explore Concept

Intermediate

Caching Strategies

A breakdown of where to place your cache and how to keep it in sync with your database.

Explore Concept

Beginner

Caching Overview

High-speed data storage to reduce latency. The single most effective way to scale read-heavy systems.

Explore Concept

Beginner

CAP Theorem

Consistency, Availability, Partition Tolerance. Why you can only pick two in distributed systems, and how real databases like MongoDB, Cassandra, and DynamoDB make the trade-off.

Explore Concept

Intermediate

Circuit Breaker Pattern

A mechanism to prevent an application from repeatedly trying to execute an operation that's likely to fail.

Explore Concept

Advanced

System Design: Dropbox (Google Drive)

Designing a file synchronization service like Dropbox or Google Drive. Key concepts: Block-level Deduplication, Delta Sync, and Strong Consistency.

Explore Concept

Advanced

Event Sourcing & CQRS

Comprehensive guide to Event Sourcing and Command Query Responsibility Segregation (CQRS) patterns, covering immutable event logs, state reconstruction, read/write separation, and real-world implementations in banking, e-commerce, and audit systems.

Explore Concept

Advanced

Cache Eviction Policies

When the cache is full, something has to go. A comprehensive guide to LRU, LFU, ARC, and other replacement algorithms with implementation details.

Explore Concept

Intermediate

Geohashing (Location Encoding)

A geocoding system that encodes latitude/longitude coordinates into short alphanumeric strings for efficient proximity searches and spatial indexing.

Explore Concept

Intermediate

Horizontal Scaling (Scaling Out)

The definitive guide to adding more servers to your infrastructure pool to handle infinite growth.

Explore Concept

Expert

HyperLogLog (Cardinality Estimation)

A probabilistic algorithm for counting unique items in massive datasets using minimal memory, with less than 1% error using just kilobytes of space.

Explore Concept

Expert

System Design: Instagram News Feed

Designing a scalable social feed. Fan-out on Write vs Fan-out on Read, and solving the Justin Bieber problem.

Explore Concept

Advanced

Leader Election

Comprehensive guide to distributed leader election algorithms including Raft, Paxos, and Bully algorithm, covering consensus, split-brain prevention, and real-world implementations in Kubernetes, ZooKeeper, and etcd.

Explore Concept

Advanced

MapReduce

A programming model for processing massive datasets in parallel across distributed clusters. Understanding Map, Shuffle, Reduce with real-world use cases from Google, Hadoop, and Spark.

Explore Concept

Advanced

Merkle Trees (Data Synchronization)

Hash tree data structure enabling efficient verification of data integrity and synchronization across distributed systems, used in Git, Bitcoin, Cassandra, and IPFS for tamper detection and incremental sync.

Explore Concept

Intermediate

Microservices Architecture

An architectural style that structures an application as a collection of loosely coupled, independently deployable services.

Explore Concept

Advanced

System Design: Netflix (Video Streaming)

Delivering high-quality video to millions of users globally using CDNs, Adaptive Bitrate Streaming, and Microservices.

Explore Concept

Intermediate

System Design: Notification System

How to send millions of SMS, Email, and Push notifications reliably. Message Queues, Rate Limiting, and Retry policies.

Explore Concept

Expert

System Design: Payment System (Stripe/PayPal)

How to design a financial system that never loses money. Topics include Idempotency, Double-Entry Ledgers, and Reconciliation.

Explore Concept

Expert

Phi Accrual Failure Detector

An advanced algorithm that uses historical heartbeat data to calculate the probability of a node failure, adapting to network conditions dynamically.

Explore Concept

Advanced

Quadtrees (Location Based Services)

Spatial data structure recursively subdividing 2D space into four quadrants, enabling efficient proximity searches for location-based services like Uber driver matching, Yelp restaurant discovery, and Pokemon Go gameplay.

Explore Concept

Pro

Raft Consensus Algorithm

A comprehensive guide to Raft, the consensus algorithm powering Etcd, Consul, and Kubernetes. Leader election, log replication, safety guarantees, and production deployment patterns.

Explore Concept

Intermediate

Rate Limiting

Traffic control mechanism that limits the number of requests a user can make to prevent abuse, ensure fairness, and protect system resources from overload.

Explore Concept

Beginner

Scaling: Overview

Comprehensive guide to scaling systems from 100 to 100 million users, covering vertical scaling (scale up), horizontal scaling (scale out), database sharding, caching strategies, and real-world architecture patterns from Netflix, Instagram, and Twitter.

Explore Concept

Pro

System Design: Ticketmaster (Booking System)

How to handle massive concurrency (e.g., Taylor Swift Eras Tour) without double-booking seats. Optimistic Locking, Redis TTL, and Active Queues.

Explore Concept

Intermediate

Token Bucket vs Leaky Bucket

A comprehensive comparison of two fundamental rate limiting algorithms: Token Bucket allows controlled bursts while Leaky Bucket enforces constant output rates.

Explore Concept

Pro

Top-K Heavy Hitters (Streaming)

How to find 'Trending Topics' in massive real-time streams. MapReduce, Count-Min Sketches, and Sliding Windows.

Explore Concept

Intermediate

Trie (Prefix Tree & Autocomplete)

A tree data structure optimized for storing and searching strings by prefix, enabling efficient autocomplete, spell checking, and dictionary operations in O(L) time.

Explore Concept

Pro

System Design: Uber (Ride Sharing)

A breakdown of the geospatial architecture behind Uber. Validating QuadTrees, Google S2/H3, and handling millions of location updates per second.

Explore Concept

Intermediate

System Design: URL Shortener (Bit.ly)

Designing a high-read, heavy-scale service like Bit.ly. Deep dive into ID generation (Base62 vs UUID) and Redirection mechanics.

Explore Concept

Beginner

Vertical Scaling (Scaling Up)

A deep dive into upgrading server hardware to handle increased load, including its limits and best use cases.

Explore Concept

Advanced

System Design: Web Crawler (Google)

A deep dive into designing a scalable, distributed web crawler capable of indexing the entire internet. Covers URL Frontiers, Politeness policies, and robust deduplication.

Explore Concept

Pro

System Design: WhatsApp (Chat App)

How to design a massive scale chat application with focus on WebSocket architecture, End-to-End Encryption, and offline message delivery.

Explore Concept

Pro

System Design: YouTube (Video Transcoding)

Designing a massive-scale video processing platform. DAG pipelines, Adaptive Bitrate Streaming (HLS/DASH), and CDN optimization.

Explore Concept

Other Concepts

Beginner

Content Delivery Network (CDN)

Geographically distributed network of edge servers that cache and deliver content from locations closest to users, dramatically reducing latency and improving performance, availability, and security.

Explore Concept

Beginner

Document Databases

The most popular type of NoSQL database. Storing data in flexible, JSON-like documents with embedded structures and dynamic schemas.

Explore Concept

Intermediate

Graph Databases

Complete guide to graph databases treating relationships as first-class citizens, covering property graphs, Cypher query language, graph algorithms, and production implementations in Neo4j, Amazon Neptune powering social networks, fraud detection, and recommendation systems.

Explore Concept

Beginner

Heartbeat Protocol

A mechanism for failure detection in distributed systems where nodes send periodic signals to indicate they are still alive. Implementation strategies, timeout tuning, and production patterns.

Explore Concept

Pro

LSM Trees (Database Internals)

Log-Structured Merge Trees: The data structure powering write-heavy databases like Cassandra, RocksDB, and DynamoDB.

Explore Concept

Pro

Redis Internals: Why is it Fast?

Single-threaded Event Loop, RDB vs AOF Persistence, and Pipelining.

Explore Concept

Pro

Redis Internals: Why is it Fast?

Deep dive into Redis architecture: single-threaded event loop, data structures, persistence strategies (RDB/AOF), replication, and cluster mode.

Explore Concept

Intermediate

Distributed Unique ID Generation

How to generate unique IDs in a distributed system without coordination. Twitter Snowflake, UUID v4 vs v7, Clock skew issues, and production implementations.

Explore Concept