Alphabetical System Design Encyclopedia
The comprehensive index of core terminology, distributed algorithms, data structures, and architectural patterns. Click any term to open its instant slide-over preview or jump directly into the full curriculum topic.
Letter A (5 Terms)
ACID Properties
A set of four essential guarantees that ensure reliable processing of database transactions.
Atomicity ensures all-or-nothing execution; Consistency ensures database transitions between valid states; Isolation controls concurrency visibility; Durability guarantees committed transactions survive power outages via Write-Ahead Logging (WAL).
Active-Active Multi-Region
A deployment topology where multiple geographically distributed data centers concurrently serve read and write traffic.
Provides ultra-low client latency and continuous availability during regional cloud outages. Requires multi-region conflict resolution strategies such as Conflict-Free Replicated Data Types (CRDTs), Last-Write-Wins (LWW), or globally synchronized atomic clocks.
Anycast Routing
A network addressing technique where multiple physical servers across the globe share the exact same IP address.
BGP (Border Gateway Protocol) automatically routes client packets to the topologically closest data center on the internet backbone, minimizing round-trip latency and mitigating DDoS attack floods across global PoPs.
Apache Kafka
A distributed event streaming platform built around partitioned, append-only immutable commit logs on disk.
Producers append records to topic partitions. Consumers in consumer groups read sequential offsets independently at their own pace. Kafka achieves millions of msgs/sec throughput using sequential disk I/O, OS Page Cache, and zero-copy `sendfile` syscalls.
API Gateway
A single ingress entry point that sits between external client applications and internal microservices.
Handles cross-cutting concerns including SSL termination, authentication/authorization, rate limiting, request routing, protocol translation (HTTP to gRPC), response caching, and telemetry collection.
Letter B (4 Terms)
B-Tree / B+ Tree Indexing
A self-balancing, N-ary search tree data structure optimized for systems reading and writing large blocks of memory.
B+ Trees store all actual record pointers in leaf nodes linked sequentially for fast range scans, while internal nodes act as high-fanout index navigation keys, reducing disk I/O depth to O(log N).
Backpressure
A resistance mechanism that signals an upstream publisher to slow down data emission when downstream consumers are overloaded.
Prevents consumer memory exhaustion (OOM crashes) during traffic bursts by pausing pull ingestion, dropping non-critical packets, or buffer leasing across reactive streaming pipelines.
Bloom Filter
A space-efficient probabilistic data structure used to test whether an element is definitely NOT in a set or possibly in a set.
Employs multiple hash functions mapping to a bit array. Guarantees zero false negatives (if it says absent, it is absent), enabling LSM-Tree databases (Cassandra, RocksDB) to bypass expensive disk reads for non-existent keys.
Bulkhead Pattern
An isolation pattern that partitions critical computing resources (thread pools, memory, sockets) to prevent one failing service from crashing the whole system.
Named after compartmentalized ship bulkheads. If a payment service dependency hangs, its dedicated thread pool exhausts without starving thread pools allocated for user browsing or search.
Letter C (7 Terms)
Cache Stampede (Thundering Herd)
A failure cascade occurring when a heavily requested hot cache key expires, causing thousands of concurrent requests to hit the database simultaneously.
Mitigated by Mutex Locking (Single-Flight), Probabilistic Early Expiration (XFetch algorithm), or Stale-While-Revalidate background asynchronous recomputation.
Cache-Aside Pattern
A caching pattern where the application code directly orchestrates reading from cache, querying database on cache misses, and updating the cache.
App queries cache first. If a cache miss occurs, app queries database, stores result in cache with an explicit Time-To-Live (TTL), and returns data to client. Also known as Lazy Loading.
CAP Theorem
In any asynchronous distributed data store, it is impossible to simultaneously guarantee more than two out of Consistency, Availability, and Partition Tolerance.
Because physical network partitions (P) are unavoidable in distributed systems, architects must choose between strong Consistency (CP: rejecting or pausing stale reads/writes) or continuous Availability (AP: returning potentially stale reads) when partitions occur.
Change Data Capture (CDC)
A software pattern that monitors and captures row-level changes (INSERT, UPDATE, DELETE) directly from database transaction logs.
Tools like Debezium tail PostgreSQL/MySQL Write-Ahead Logs (WAL) and stream events into Kafka, keeping downstream search indexes (Elasticsearch), caches (Redis), and data warehouses (Snowflake) in near-real-time synchronization without dual-write race conditions.
Circuit Breaker Pattern
A design pattern that monitors remote service calls and immediately fails fast when the failure rate crosses a configured threshold.
Transitions across three states: Closed (normal execution), Open (fail-fast without calling upstream), and Half-Open (sending trial probe requests after a cooldown timeout to test service recovery).
Consistent Hashing
A distributed hashing scheme that maps both nodes and data keys onto a circular 360° hash ring.
When a node is added or removed, only K/N keys need to be remapped on average (where K is keys, N is nodes), unlike traditional modulo hashing which remaps almost all keys. Virtual nodes ensure uniform statistical key distribution across physical servers.
CQRS (Command Query Responsibility Segregation)
An architectural pattern that strictly separates read operations (Queries) from write/mutation operations (Commands).
Enables optimizing the write model for high-speed ACID integrity (e.g. normalized PostgreSQL or event store) while projecting read models into denormalized, read-optimized data stores (e.g. Elasticsearch or Redis) via asynchronous event streams.
Letter D (4 Terms)
Database Sharding
The horizontal partitioning of a large database across multiple independent physical server nodes.
Divides table rows according to a Shard Key (e.g. user_id). Strategies include Hash Sharding, Range Sharding, and Directory-Based Sharding. Eliminates monolithic hardware limits at the cost of cross-shard join complexity.
Distributed Lock
A mutual exclusion mechanism that coordinates access to shared resources across independent machines in a cluster.
Implemented using consensus-backed coordination stores (ZooKeeper ephemeral znodes, etcd leases) or Redis (Redlock). Requires monotonic fencing tokens to prevent split-brain write corruption during JVM GC pauses or network delays.
Distributed Tracing
A diagnostic method that profiles and tracks the execution path of a request across dozens of microservices.
Propagates unique Trace IDs and Span IDs across HTTP/gRPC headers using OpenTelemetry standards, visualizing request bottlenecks, error propagation, and latency breakdowns in tools like Jaeger or Zipkin.
DNS (Domain Name System)
The hierarchical and decentralized naming system that translates human-readable domain names into numerical IP addresses.
Executes resolution across 4 tiers: Local Cache -> Recursive Resolver -> Root Nameserver (.) -> Top-Level Domain Nameserver (.com) -> Authoritative Nameserver (holds A/AAAA records).
Letter E (2 Terms)
Event Sourcing
An architectural pattern where every change in state is captured as an immutable, append-only chronological sequence of events.
Instead of storing only the current state of a database entity, the event store persists all atomic events (e.g. OrderCreated, PaymentApproved, OrderShipped). Current state is reconstructed by replaying events from genesis.
Exponential Backoff with Jitter
An algorithm that exponentially increases the wait time between consecutive retry attempts while adding random noise (jitter).
Prevents retry storms and thundering herd synchronized waves hitting recovering downstream services. Formula: sleep = min(cap, rand(0, base * 2^attempt)).
Letter G (1 Term)
gRPC (Remote Procedure Call)
A high-performance, open-source universal RPC framework developed by Google.
Runs over HTTP/2 transport with Protocol Buffers binary serialization. Supports multiplexed streams, bi-directional streaming, automatic client SDK code generation, and 5x-10x higher payload efficiency than JSON over REST.
Letter H (2 Terms)
H3 Spatial Indexing
An open-source geospatial indexing system developed by Uber that partitions the globe into hexagonal grid cells.
Unlike square grids or geohashes, hexagons have equidistant neighboring centroids, eliminating distortion and enabling $O(1)$ spatial proximity search, surge pricing calculations, and driver matching.
HTTP/3 (QUIC)
The third major version of the Hypertext Transfer Protocol, running over the QUIC transport protocol on top of UDP.
Eliminates TCP head-of-line blocking on packet drops by handling streams independently in user space. Built-in TLS 1.3 encryption, connection migration across Wi-Fi/cellular IP changes, and 0-RTT connection resumption.
Letter I (1 Term)
Idempotency Key
A unique client-generated token attached to mutating API requests to ensure an operation executes at most once.
If network drops occur during a payment POST request, the client can safely retry with the same Idempotency-Key. The server detects the processed key in Redis or database unique constraint and returns the cached result without double billing.
Letter J (1 Term)
JWT (JSON Web Token)
A compact, URL-safe standard for securely transmitting claims between parties as a JSON object.
Structured into Header.Payload.Signature. Authenticated statelessly using asymmetric public/private key cryptography (RS256) so microservices can verify tokens locally without checking central databases on every request.
Letter L (2 Terms)
Load Balancer (L4 vs L7)
A device or software reverse proxy that distributes incoming network traffic efficiently across a pool of backend servers.
Layer 4 (L4) balances raw TCP/UDP packets by IP and port without inspecting application payloads. Layer 7 (L7) inspects HTTP headers, cookies, and URLs, enabling intelligent content routing, SSL termination, and path-based microservice dispatch.
LSM-Tree (Log-Structured Merge-Tree)
A storage engine optimized for high-throughput write workloads by converting random disk writes into sequential append-only writes.
Writes append to an in-memory MemTable and Write-Ahead Log (WAL). When full, MemTable flushes to immutable SSTables (Sorted String Tables) on disk. Background compaction merges duplicate keys. Powering Cassandra, ScyllaDB, RocksDB, and CockroachDB.
Letter M (1 Term)
Monolith vs Microservices
The foundational architectural trade-off between unified single-process codebases and decoupled independent distributed services.
Monoliths offer rapid development velocity and zero network latency overhead for small teams. Microservices enable large organizations (50+ engineers) to scale independently at the cost of network latency taxes and distributed data consistency complexity.
Letter O (2 Terms)
OAuth 2.0 with PKCE
An industry-standard delegated authorization framework enhanced with Proof Key for Code Exchange (PKCE).
Allows third-party applications to obtain limited access to user accounts without sharing passwords. PKCE dynamically generates a cryptographic code verifier and challenge, preventing authorization code interception attacks on mobile and Single Page Apps (SPAs).
OLTP vs OLAP
The fundamental dichotomy between Online Transaction Processing (row-oriented) and Online Analytical Processing (column-oriented).
OLTP databases (Postgres, MySQL) optimize for high-frequency concurrent row reads/writes with ACID transactions. OLAP stores (ClickHouse, Snowflake, BigQuery) store data in contiguous columns with SIMD compression, accelerating aggregations across billions of rows.
Letter P (1 Term)
PACELC Theorem
An extension of the CAP theorem stating: If there is a Partition (P), choose Availability (A) or Consistency (C); Else (E), choose Latency (L) or Consistency (C).
Accounts for normal (non-partitioned) distributed operating conditions. E.g., DynamoDB and Cassandra are PA/EL systems (prioritizing low latency when healthy), while Spanner and CockroachDB are PC/EC systems (strictly consistent at all times).
Letter R (2 Terms)
Raft Consensus Algorithm
A leader-based consensus algorithm designed to be more understandable than Paxos while offering equivalent fault tolerance.
Elects a leader via randomized election timers and heartbeats. The leader accepts client log entries, replicates them to follower nodes, and commits entries once a majority quorum (e.g. 3 of 5 nodes) successfully appends them.
Rate Limiter
A traffic control primitive that restricts the number of requests a client can make to an API within a specified time window.
Common algorithms include Token Bucket, Leaky Bucket, Fixed Window Counter, and Sliding Window Counter. Redis Lua scripts ensure atomic increments without race conditions across distributed gateway clusters.
Letter S (3 Terms)
Saga Pattern
A distributed transaction pattern that coordinates long-lived transactions across microservices through a sequence of local transactions.
If any local transaction step fails, the Saga executes compensating transactions in reverse order to rollback state. Implemented via Choreography (event-driven pub/sub) or Orchestration (centralized workflow orchestrator state machine).
Snowflake ID Generator
A distributed 64-bit unique ID generation system created by Twitter that generates roughly time-ordered IDs without database coordination.
Bit layout: 1 sign bit + 41 timestamp bits (~69 years) + 10 machine/datacenter ID bits (1024 nodes) + 12 sequence bits (4096 IDs per ms per node). Generates over 4M IDs/sec per node with zero locks.
SQL Isolation Levels
The degree to which transaction modifications are isolated from concurrent transactions in relational databases.
Defined by ANSI SQL: Read Uncommitted (dirty reads allowed), Read Committed (default in Postgres/Oracle via MVCC), Repeatable Read (default in MySQL InnoDB via gap locks), and Serializable (strict 2PL or SSI preventing all anomalies including write skew).
Letter T (2 Terms)
TLS 1.3 Handshake
The cryptographic protocol that authenticates servers and establishes encrypted communication channels over TCP.
TLS 1.3 reduces handshake latency to a single round trip (1-RTT) by combining key exchange (ECDHE) with cipher negotiation in the initial ClientHello. Supports 0-RTT session resumption for repeat clients.
Two-Phase Commit (2PC)
A blocking atomic commitment protocol that ensures all distributed nodes either commit or abort a transaction together.
Operates in two phases: Prepare (coordinator asks participants if they can commit) and Commit (coordinator broadcasts final commit/abort). Vulnerable to blocking stalls if the coordinator crashes mid-protocol.
Letter W (2 Terms)
WebSockets
A computer communications protocol providing full-duplex, persistent bidirectional communication over a single TCP connection.
Initiated via an HTTP Upgrade handshake (Port 80/443), after which client and server exchange minimal-overhead binary or text frames in real time without HTTP header overhead. Ideal for chat, gaming, and collaborative editing.
Write-Ahead Log (WAL)
An append-only log file on disk where database operations are recorded before applying changes to main database pages.
Guarantees the Durability and Atomicity of ACID transactions. If a server crashes mid-update, the database recovers by replaying uncommitted transactions from the sequential WAL during reboot.
Letter Z (1 Term)
Zero Trust Architecture
A cybersecurity model based on the principle of "never trust, always verify" across both perimeter and internal networks.
Eliminates implicit trust for internal network traffic. Enforces mutual TLS (mTLS) authentication between all microservices via SPIFFE/SPIRE identity attestation, least-privilege RBAC/ABAC authorization, and continuous inspection.