Glossary

System Design Glossary

Plain-English definitions of 97 system design terms — databases, caches, queues, algorithms and more — each with how it works and where it's used.

Algorithms

B-TreeA read-optimized, in-place-update index structure used by most SQL databases.Bloom FilterA tiny probabilistic structure answering "definitely not in the set" or "probably in".BM25The standard relevance-ranking function for full-text search.Consistent HashingMaps keys and nodes onto a ring so adding/removing a node moves only a few keys.CRDTConflict-free Replicated Data Type: data designed so concurrent merges always converge.Fan-outPushing one event to many recipients (e.g. a tweet into every follower's feed).GeohashEncodes a lat/long into a short string so nearby points share a prefix.Gossip / SWIMNodes periodically exchange state with random peers so info spreads epidemically.HyperLogLogEstimates the count of distinct items in ~KB, regardless of cardinality.IdempotencyDesigning an operation so applying it twice has the same effect as once.LSM-TreeA write-optimized storage structure: buffer in memory, flush sorted files, compact.LSM-TreeA write-optimized storage structure: buffer in memory, flush sorted files, compact.Merkle TreeA tree of hashes that lets you compare large datasets by exchanging few hashes.MVCCMulti-Version Concurrency Control: keep multiple versions so readers never block writers.Operational TransformMerges concurrent edits by transforming each op against the others so all clients converge.PaxosThe classic consensus algorithm for agreeing on a value despite failures.QuadtreeA spatial tree that recursively splits a region into four quadrants.Quorum (R+W>N)Require overlapping majorities for reads and writes so reads see the latest write.RaftA consensus algorithm: elect a leader, replicate a log to a majority.ShardingSplitting data across many databases by a shard key so it scales past one node.SimHashA hashing technique where similar documents get similar hashes.Sliding WindowA rate-limiting method that counts requests over a moving time window.Token BucketA rate-limiting algorithm: requests consume tokens that refill at a fixed rate.Two-Phase CommitAtomically commit across machines: prepare, then commit only if all agree.Vector ClockTracks causal ordering of events across replicas to detect concurrent updates.

Components

API GatewayA single entry point in front of many services handling routing, auth, rate limiting and aggregation.CassandraA masterless, write-optimized wide-column NoSQL store.CDNA network of edge servers that cache content near users worldwide.ClickHouseA columnar OLAP database for fast analytics over billions of rows.DynamoDBA managed, partitioned, highly-available key-value/document store.ElasticsearchA distributed full-text search and analytics engine.EnvoyA modern service proxy, the data plane of service meshes.etcdA strongly-consistent key-value store for coordination (built on Raft).FlinkA stream-processing engine for real-time windowed computation.gRPCA high-performance RPC framework using Protocol Buffers over HTTP/2 with streaming and codegen.KafkaA distributed, append-only commit log for high-throughput event streams.KubernetesA container orchestrator that schedules and scales services.Load BalancerDistributes incoming requests across many servers.MemcachedA simple, fast in-memory cache for key-value blobs.MongoDBA document (JSON-like) NoSQL database.MQTTA lightweight pub/sub protocol for IoT devices.MySQLA widely-used relational (SQL) database.NginxA high-performance web server / reverse proxy / load balancer.PostgresA powerful open-source relational (SQL) database with strong ACID guarantees.PrometheusA time-series database + monitoring system for metrics.RabbitMQA message broker for queues and pub/sub.RedisAn in-memory key-value store used as a cache, counter, queue and more.S3Amazon's object storage for files/blobs at exabyte scale.Server-Sent EventsA simple one-way stream where the server pushes events to the browser over a long-lived HTTP connection.Snowflake (warehouse)A cloud data warehouse that separates storage from compute.SpannerGoogle's globally-distributed, strongly-consistent SQL database.SparkA distributed engine for big-data batch (and stream) processing.SQSAmazon's managed message queue.VitessA system for sharding MySQL horizontally.WebRTCA browser protocol for peer-to-peer real-time audio/video/data.WebSocketA protocol for a persistent, two-way connection between client and server over a single TCP socket.ZooKeeperA coordination service for locks, leader election and config.

Concepts

ACIDThe four guarantees a transactional database makes: Atomicity, Consistency, Isolation, Durability.BackpressureLetting a slow consumer signal upstream to slow down, instead of being overwhelmed and dropping data.BASEThe relaxed alternative to ACID for high-availability distributed stores: Basically Available, Soft state, Eventually consistent.Cache StampedeWhen a popular cached key expires and thousands of requests miss at once, all hammering the database together.Cache-AsideThe app checks the cache first; on a miss it reads the DB and populates the cache (lazy loading).CachingKeeping a copy of expensive-to-fetch data somewhere faster (memory, CDN) to cut latency and load.CAP TheoremIn a network partition, a distributed store can keep either Consistency or Availability — not both.Change Data CaptureStreaming a database's row-level changes out to other systems as an ordered event feed.Circuit BreakerStop calling a failing dependency for a while so it can recover and you fail fast instead of piling up.CompactionBackground merging of an LSM-tree's sorted files to reclaim space and keep reads fast.CQRSCommand Query Responsibility Segregation: separate the write model from the read model.Dead Letter QueueA side queue where messages land after repeatedly failing to process, so they don't block or get lost.DenormalizationDeliberately duplicating data across rows/tables so reads avoid expensive joins.Event SourcingStore the full sequence of state-changing events as the source of truth, deriving current state by replaying them.Eventual ConsistencyReplicas may briefly disagree after a write, but with no new writes they all converge to the same value.Exactly-Once DeliveryEach message takes effect once and only once — no loss, no duplicates — despite retries and crashes.Horizontal ScalingAdding more machines and spreading load across them (scale out), rather than buying a bigger machine.Hot KeyA single cache or partition key getting a huge share of requests (e.g. a viral item).Hot ShardOne partition receiving far more traffic than the others, becoming a bottleneck while the rest sit idle.LatencyThe time a single operation takes end to end — how long one request waits for its response.Leader ElectionPicking a single coordinator among nodes, and agreeing on a new one when it dies.Long PollingThe client makes a request that the server holds open until it has data, then immediately re-requests.Message QueueA buffer that decouples producers from consumers so work can be processed asynchronously and absorb bursts.PACELCAn extension of CAP: if Partitioned, choose Availability or Consistency; Else, choose Latency or Consistency.Rate LimitingCapping how many requests a client can make in a window to protect a service from overload or abuse.Read ReplicaA copy of the database that serves reads, taking load off the primary which handles writes.ReplicationKeeping copies of the same data on multiple nodes for availability and read scaling.Saga PatternCoordinate a transaction across microservices as a chain of local steps, each with a compensating undo.Secondary IndexAn extra index on a non-primary-key field so you can query by it without scanning everything.Service MeshA dedicated networking layer (sidecar proxies) that handles service-to-service traffic transparently.SidecarA helper process deployed alongside a service to add capabilities without changing the service itself.Split BrainWhen a network partition leaves two sides each thinking they're the leader, accepting conflicting writes.Stateless ServiceA service that keeps no client/session state between requests, so any instance can handle any request.Strong ConsistencyEvery read returns the most recent committed write, as if there were a single copy of the data.Tail LatencyThe slowest requests (p99, p99.9), which matter far more than the average for user experience.ThroughputHow much work a system completes per unit time — requests/sec, messages/sec, bytes/sec.Vertical ScalingGiving one machine more CPU, RAM or disk (scale up), rather than adding more machines.Write AmplificationWhen one logical write causes several physical writes under the hood.Write-Ahead LogAppend every change to a durable log before applying it, so the database can recover after a crash.Write-Through CacheEvery write goes to the cache and the database together, so the cache is always warm and consistent.

Part of SystemLore — browse the Academy, Library, Agentic AI systems, Glossary, and "X vs Y" comparisons. Open the interactive Glossary.