Reference // 138 terms
Glossary
Every term used in the lessons, in plain English. Each one links to the lesson that explains it best.
4
- 429 Too Many Requests
- The HTTP status code a server returns when a client is over its rate limit.
- Lesson 16: Rate limiting
A
- ACID
- Atomic, Consistent, Isolated, Durable. The guarantees that make database transactions all-or-nothing and safe.
- Lesson 9: SQL vs NoSQL
- Adaptive bitrate streaming
- Video split into small segments at several qualities; the player switches quality as the network changes.
- Lesson 29: Video streaming
- API
- A defined way for one program to ask another for data or actions.
- Lesson 4: APIs: REST, GraphQL, gRPC, WebSockets
- API gateway
- The single front door for clients that routes requests to services and handles auth, limits and logging.
- Lesson 19: Microservices vs monolith
- At-least-once delivery
- Every message is delivered, but sometimes more than once, so consumers must handle duplicates.
- Lesson 17: Message queues and pub/sub
- Authentication (authN)
- Proving who you are, for example with a password or a passkey.
- Lesson 25: Security basics
- Auto-scaling
- Adding or removing servers automatically based on load, so you pay for what you need.
- Lesson 8: Auto-scaling
- Availability
- The share of time a system is up and answering correctly, often written as "nines" (99.9%).
- Lesson 22: Availability
B
- B-tree
- The balanced tree structure most database indexes use, so any value is found in a few disk reads.
- Lesson 10: Indexing
- Base62
- Writing numbers with 0–9, a–z and A–Z, so short strings cover huge ranges (7 characters ≈ 3.5 trillion values).
- Lesson 26: URL shortener
- Block storage
- A virtual hard disk attached to one server, used for databases and operating systems.
- Lesson 13: Object and blob storage
C
- Cache
- A small, fast store that keeps copies of data that is expensive to fetch, so repeat requests are quicker.
- Lesson 14: Caching
- Cache invalidation
- Removing or updating cached data when the source changes, so users don't see stale values.
- Lesson 14: Caching
- Cache miss
- The requested data was not in the cache, so it had to be fetched from the slower source.
- Lesson 14: Caching
- Cache-aside
- The application checks the cache first, and on a miss reads the database and stores the result in the cache. Also called lazy loading.
- Lesson 14: Caching
- CAP theorem
- During a network partition, a distributed system must choose between consistency and availability.
- Lesson 20: CAP theorem and PACELC
- CDN
- Content delivery network. Servers around the world that keep copies of files close to users.
- Lesson 15: CDNs
- Circuit breaker
- A switch that stops calling a failing service for a while, failing fast instead of waiting.
- Lesson 23: Failure handling
- Client
- The program that sends a request, such as a browser or a mobile app.
- Lesson 2: How a request travels
- Composite index
- An index on several columns in a set order, such as (user_id, created_at).
- Lesson 10: Indexing
- Consistent hashing
- A way to map keys to servers on a ring so that adding or removing a server only moves a small share of keys.
- Lesson 6: Load balancers
- Consumer
- The part of a system that receives and processes messages or events.
- Lesson 17: Message queues and pub/sub
- Consumer group
- A set of consumers that share the work of reading a stream; each partition goes to one member.
- Lesson 18: Event-driven architecture and streams
- Cooldown
- A waiting period after a scaling action so new servers can warm up before the system scales again.
- Lesson 8: Auto-scaling
D
- Database
- Software that stores data on disk in an organized way so it can be queried and survives restarts.
- Lesson 9: SQL vs NoSQL
- Dead-letter queue
- A side queue for messages that keep failing, so they can be inspected instead of retried forever.
- Lesson 17: Message queues and pub/sub
- Distributed tracing
- Following one request across every service it touches, with timing for each step.
- Lesson 24: Monitoring
- DNS
- The Domain Name System. It translates a name like example.com into the IP address of a machine.
- Lesson 2: How a request travels
- Document database
- A database that stores JSON-like documents, each of which can have its own nested structure.
- Lesson 9: SQL vs NoSQL
E
- Encryption at rest
- Encrypting stored data so a stolen disk or backup is unreadable without the key.
- Lesson 25: Security basics
- Error budget
- How much failure the SLO allows. 99.9% per month leaves about 43 minutes of budget.
- Lesson 22: Availability
- Event sourcing
- Storing every change as an event and rebuilding the current state by replaying them.
- Lesson 18: Event-driven architecture and streams
- Event stream (log)
- An append-only, ordered record of events that many consumers can read and replay, like Kafka.
- Lesson 18: Event-driven architecture and streams
- Event-driven architecture
- Services announce things that happened (events), and other services react, instead of calling each other directly.
- Lesson 18: Event-driven architecture and streams
- Eventual consistency
- Copies may disagree for a while, but if writes stop, they all end up the same.
- Lesson 21: Consistency models
- Exponential backoff
- Waiting longer after each failed attempt (1 s, 2 s, 4 s…), so retries don't pile on a struggling service.
- Lesson 23: Failure handling
F
- Failover
- Switching to a backup when the primary fails, such as promoting a follower to leader.
- Lesson 11: Replication
- Fan-out
- Delivering one item to many recipients, either when it's written (on write) or when it's read (on read).
- Lesson 28: News feed
- Full table scan
- Reading every row of a table to answer a query, because no index helps.
- Lesson 10: Indexing
- Functional requirement
- Something the system must do, such as "users can upload a photo".
- Lesson 1: What is system design?
G
- Geohash
- A short string for a map cell; nearby places share a prefix, which makes "what's near me" lookups fast.
- Lesson 30: Ride sharing
- Graph database
- A database that stores things and the connections between them, made for questions like "friends of friends".
- Lesson 9: SQL vs NoSQL
- GraphQL
- An API style where the client sends a query describing exactly which fields it wants, to one endpoint.
- Lesson 4: APIs: REST, GraphQL, gRPC, WebSockets
- gRPC
- A fast API style for service-to-service calls that sends compact binary messages over HTTP/2.
- Lesson 4: APIs: REST, GraphQL, gRPC, WebSockets
H
- Health check
- A regular probe (often an HTTP request to /health) that tells a load balancer whether a server can take traffic.
- Lesson 6: Load balancers
- Hit rate
- The share of requests answered from the cache. 90% means 9 in 10 requests never reach the database.
- Lesson 14: Caching
- Horizontal scaling
- Adding more machines and splitting the work between them. Also called scaling out.
- Lesson 5: Vertical vs horizontal scaling
- Hotspot
- One shard or server getting far more traffic than the rest.
- Lesson 12: Sharding and partitioning
- HTTP
- The request–response language browsers and servers speak, with methods like GET and POST and status codes like 200 and 404.
- Lesson 2: How a request travels
I
- Idempotency
- Doing the same operation twice has the same effect as doing it once, which makes retries safe.
- Lesson 23: Failure handling
- Index
- A sorted lookup structure that lets the database find rows without reading the whole table.
- Lesson 10: Indexing
- IP address
- The numeric address of a machine on a network, like 93.184.216.34.
- Lesson 2: How a request travels
J
- Jitter
- Random variation added to retry delays so many clients don't retry at the same instant.
- Lesson 23: Failure handling
- JWT
- JSON Web Token. A signed token that carries claims like user ID and expiry, which servers can check without a lookup.
- Lesson 25: Security basics
K
- Key-value store
- A database that stores values under unique keys, like a giant dictionary. Very fast lookups by key.
- Lesson 9: SQL vs NoSQL
L
- Latency
- How long one request takes from start to finish, usually measured in milliseconds.
- Lesson 3: Latency vs throughput
- Layer 4 (L4)
- The transport layer (TCP/UDP). An L4 load balancer routes using IP addresses and ports without reading the request content.
- Lesson 6: Load balancers
- Layer 7 (L7)
- The application layer (HTTP). An L7 load balancer can read URLs, headers and cookies to decide where a request goes.
- Lesson 6: Load balancers
- Leader–follower replication
- One copy (the leader) takes all writes and streams them to read-only copies (followers).
- Lesson 11: Replication
- Leaky bucket
- A rate-limiting algorithm that queues requests and lets them out at a fixed rate.
- Lesson 16: Rate limiting
- Least connections
- A load-balancing algorithm that sends each request to the server currently handling the fewest requests.
- Lesson 6: Load balancers
- LFU
- Least frequently used. An eviction policy that removes the item read the fewest times.
- Lesson 14: Caching
- Load balancer
- A component that receives incoming requests and spreads them across several servers.
- Lesson 6: Load balancers
- Logs
- Timestamped records of individual events, such as one failed request and why.
- Lesson 24: Monitoring
- LRU
- Least recently used. An eviction policy that removes the item that hasn't been read for the longest time.
- Lesson 14: Caching
M
- Message queue
- A buffer where producers leave messages and consumers pick them up later, so neither waits for the other.
- Lesson 17: Message queues and pub/sub
- Metrics
- Numbers measured over time, like requests per second, error rate and latency.
- Lesson 24: Monitoring
- Microservices
- An app split into small services, each owning one business area and its own data, deployed independently.
- Lesson 19: Microservices vs monolith
- Monolith
- One application that contains all features, deployed as a single unit.
- Lesson 19: Microservices vs monolith
- Multi-leader replication
- Several copies accept writes and sync with each other, which needs a way to resolve conflicts.
- Lesson 11: Replication
N
- Network partition
- A network failure that splits machines into groups that can't reach each other.
- Lesson 20: CAP theorem and PACELC
- Non-functional requirement
- How well the system must do it, such as speed, uptime, cost or security targets.
- Lesson 1: What is system design?
- NoSQL
- Databases that don't use relational tables, such as key-value, document, wide-column and graph stores.
- Lesson 9: SQL vs NoSQL
O
- OAuth 2.0
- A standard for letting an app act on your behalf with limited access, without sharing your password.
- Lesson 25: Security basics
- Object storage
- Storage for whole files (objects) addressed by a key in a bucket, with nearly unlimited capacity.
- Lesson 13: Object and blob storage
- Observability
- How well you can tell what's happening inside a system from its outputs: metrics, logs and traces.
- Lesson 24: Monitoring
- Offset
- A consumer's position in a stream partition, so it can resume or replay from any point.
- Lesson 18: Event-driven architecture and streams
P
- PACELC
- Extends CAP. If Partitioned, choose Availability or Consistency; Else, choose Latency or Consistency.
- Lesson 20: CAP theorem and PACELC
- Partition
- One slice of a dataset or stream. Sharding splits data into partitions spread across machines.
- Lesson 12: Sharding and partitioning
- Percentile (p50, p99)
- The p99 latency is the time that 99% of requests beat. It shows how slow your slowest users' requests are.
- Lesson 3: Latency vs throughput
- Presigned URL
- A temporary link that lets someone upload or download one object without having your credentials.
- Lesson 13: Object and blob storage
- Pub/sub
- Publish/subscribe. A publisher sends a message to a topic and every subscriber gets its own copy.
- Lesson 17: Message queues and pub/sub
- Purge (invalidation)
- Telling a CDN to drop cached copies so the next request fetches a fresh version.
- Lesson 15: CDNs
Q
- QPS
- Queries (or requests) per second, the usual unit for load.
- Lesson 34: Back-of-the-envelope estimation
- Quorum
- A majority (or set number) of replicas that must agree on a read or write.
- Lesson 21: Consistency models
R
- Rate limiting
- Capping how many requests a client can make in a period of time.
- Lesson 16: Rate limiting
- Read-your-writes
- A guarantee that after you change something, you see your change, even if others don't yet.
- Lesson 21: Consistency models
- Redundancy
- Running extra copies of a component so one can fail without an outage.
- Lesson 22: Availability
- Replication lag
- The delay between a write on the leader and that write appearing on a follower.
- Lesson 11: Replication
- Resharding
- Changing how data is split across shards, which means moving data while the system keeps running.
- Lesson 12: Sharding and partitioning
- REST
- An API style built on HTTP where URLs name resources and methods (GET, POST, PUT, DELETE) act on them.
- Lesson 4: APIs: REST, GraphQL, gRPC, WebSockets
- Round robin
- A load-balancing algorithm that hands requests to servers in turn, one after another.
- Lesson 6: Load balancers
- Round-trip time (RTT)
- How long a message takes to reach the other side and for the reply to come back.
- Lesson 2: How a request travels
S
- Scalability
- How well a system keeps working as load grows, ideally by adding more resources rather than redesigning.
- Lesson 1: What is system design?
- Scaling policy
- The rule auto-scaling follows, such as "keep average CPU near 60%".
- Lesson 8: Auto-scaling
- Server
- A computer that waits for requests over a network and sends back responses.
- Lesson 1: What is system design?
- Service discovery
- How services find the current network addresses of other services by name.
- Lesson 19: Microservices vs monolith
- Service mesh
- A layer of proxies beside each service that handles retries, encryption and metrics for service-to-service traffic.
- Lesson 19: Microservices vs monolith
- Session
- Data the server remembers about a logged-in user between requests, such as who they are and what's in their cart.
- Lesson 7: Stateless vs stateful services
- Single point of failure
- One component whose failure takes the whole system down.
- Lesson 22: Availability
- SLA
- Service level agreement. A promise to customers, usually with refunds if it's missed.
- Lesson 22: Availability
- SLI
- Service level indicator. The measured number an SLO is based on, such as the success rate.
- Lesson 22: Availability
- Sliding window
- A rate-limiting algorithm that counts requests in the last N seconds measured from now, avoiding burst gaps at window edges.
- Lesson 16: Rate limiting
- SLO
- Service level objective. The internal target, such as 99.9% of requests succeed each month.
- Lesson 22: Availability
- SQL
- The language for querying relational databases, which store data in tables with fixed columns.
- Lesson 9: SQL vs NoSQL
- Stateful service
- A service that keeps data about users or work in its own memory or disk between requests.
- Lesson 7: Stateless vs stateful services
- Stateless service
- A service that keeps no user data between requests, so any copy of it can answer any request.
- Lesson 7: Stateless vs stateful services
- Sticky session
- Sending every request from the same user to the same server, usually with a cookie. Also called session affinity.
- Lesson 7: Stateless vs stateful services
- Storage tier
- A price/speed class for stored data. Rarely read data can move to cheaper, slower tiers.
- Lesson 13: Object and blob storage
- Strong consistency
- Every read sees the most recent write, as if there were only one copy of the data.
- Lesson 21: Consistency models
- System design
- Deciding which parts a software system needs, how they connect, and how data moves between them so it stays fast and reliable as it grows.
- Lesson 1: What is system design?
T
- TCP
- The protocol that gives two machines a reliable, ordered stream of bytes, starting with a three-step handshake.
- Lesson 2: How a request travels
- Throughput
- How many requests a system can handle per unit of time, such as requests per second.
- Lesson 3: Latency vs throughput
- TLS / HTTPS
- Encryption for data travelling over the network. HTTPS is HTTP sent over TLS.
- Lesson 2: How a request travels
- Token bucket
- A rate-limiting algorithm where requests spend tokens that refill at a steady rate, allowing short bursts.
- Lesson 16: Rate limiting
- TTL (time to live)
- How long a cached item stays valid before it expires and must be fetched again.
- Lesson 14: Caching
V
- Vertical scaling
- Making one machine bigger (more CPU, memory or disk). Also called scaling up.
- Lesson 5: Vertical vs horizontal scaling
W
- WebSocket
- A long-lived, two-way connection so the server can push messages to the client at any time.
- Lesson 4: APIs: REST, GraphQL, gRPC, WebSockets
- Wide-column store
- A database that groups data by a partition key and sorts rows inside each partition; built for huge write volumes.
- Lesson 9: SQL vs NoSQL
- Write-back
- Writes go to the cache first and are saved to the database later in batches. Fast, but data can be lost if the cache fails.
- Lesson 14: Caching
- Write-through
- Every write goes to the cache and the database at the same time, so the cache is never stale.
- Lesson 14: Caching