← Back to System Design

System Design Glossary

Key terms from the System Design course, linked to the lesson that introduces each one.

688 terms.

A

ABAC policy engine
An ABAC policy engine is a dedicated component that evaluates authorization policies written in a specialized language.
Lesson 936 — ABAC Policy Engines
Access Control List
An Access Control List is a table attached to a resource that specifies exactly which users or groups have what permissions on that specific resource.
Lesson 937 — Access Control Lists (ACLs)
Access Token
A short-lived credential (minutes to hours) that your application includes with every API request to access protected resources
Lesson 926 — Access Tokens vs Refresh Tokens
accuracy
In distributed rate limiting, accuracy means precisely enforcing your quota (e.g., exactly 1000 requests per minute), while latency refers to how fast you can make the accept/reject decision.
Lesson 985 — Trade-offs: Accuracy vs Latency
Actionable alerts only
Every alert should have a clear action. If your response is "wait and see," it shouldn't page anyone.
Lesson 1171 — Log Review and Alert Fatigue
Active invalidation on write
Active invalidation on write means your system explicitly deletes or updates cache entries the instant you modify the source data.
Lesson 157 — Active Invalidation on Write
Active-Active
All replicas actively serve production traffic simultaneously. Load is distributed across them, and if one fails, the remaining replicas absorb its share. Think of multiple cashiers working at a grocery store — all are serving customers at once.
Lesson 1332 — Active-Active vs Active-Passive Redundancy
Aggregation
Aggregation means combining multiple raw metric values into a single summary value over a time window.
Lesson 1179 — Aggregation and Roll-Ups
Aggregation accuracy
Test that roll-ups, percentiles, and rate calculations produce correct results. Send a controlled burst of histogram samples and verify the p99 matches expectations. Check that labels are preserved or dropped as intended.
Lesson 1218 — Testing Metric Pipelines
Alerts
Alerts are urgent, actionable signals that require immediate human intervention to prevent or mitigate user impact.
Lesson 1285 — Alert vs Notification
Alternative Service Paths
Route to a backup service or simplified version. If your primary recommendation engine is down, fall back to "trending items" or "popular products" from a simpler, more reliable service.
Lesson 1061 — Fallback Strategies
Always use HTTPS
Tokens in transit over HTTP are trivial to intercept
Lesson 931 — OAuth2 Security Best Practices
Always-On Protection
Unlike scrambling to respond after an attack begins, CDN-based protection is continuously active at the edge, closest to attack sources.
Lesson 195 — CDN for DDoS Protection
Amazon DynamoDB
Amazon DynamoDB is the managed service evolution of the original paper.
Lesson 378 — Dynamo's Influence on Modern Systems
Analogy
A topic is like a highway, and partitions are the individual lanes. More lanes mean more cars (events) can travel simultaneously without bottlenecks.
Lesson 223 — Detecting Read vs Write QueriesLesson 434 — HBase Architecture ComponentsLesson 641 — Consensus in Multi-Region DeploymentsLesson 701 — Topics and PartitionsLesson 1274 — SLI Measurement Windows and Aggregation
Anti-entropy
Anti-entropy is a continuous background reconciliation process where replicas compare their data and synchronize differences.
Lesson 369 — Anti-Entropy and Merkle Trees
Anycast
Anycast is a network addressing method where multiple edge servers share the same IP address across different locations worldwide.
Lesson 181 — Anycast Routing for CDNsLesson 1616 — Geographic Routing and DNS
Apache Flink
Apache Flink is purpose-built for stream processing with true event-time processing and stateful computations.
Lesson 744 — Stream Processing Frameworks
Apache Kafka
Apache Kafka is designed for high-throughput event streaming and log-based messaging.
Lesson 665 — Overview of Message Broker Landscape
API Gateway
An API Gateway is a server that acts as a centralized front door for all client requests before they reach your backend services.
Lesson 870 — What is an API Gateway?Lesson 872 — API Gateway vs Reverse ProxyLesson 1585 — Upload Flow Architecture Overview
Append-Only Logs
Streams never update or delete events—they only append new ones. Once written, an event is immutable. Databases routinely UPDATE and DELETE rows, losing historical context.
Lesson 692 — Streams vs Traditional Databases
Application Cache Layer
Between your API gateway and trie cluster, maintain an in-memory cache (Redis, Memcached) of the hottest queries. Cache hit rates of 80-90% are common for popular prefixes, offloading massive query volume from your trie.
Lesson 1766 — Caching Suggestions at Multiple Layers
Approximate limits
The actual global limit may be exceeded (up to N×local_limit in worst case)
Lesson 979 — Centralized vs Decentralized Approaches
Architecture
The big-picture structure (like deciding if your city is a grid or has winding streets)
Lesson 1 — What Is System Design?
Asynchronous
The chef jots notes on a clipboard, and a dedicated person transcribes them later. Fast cooking, but if the kitchen catches fire before transcription, those notes are lost.
Lesson 1134 — Synchronous vs Asynchronous Logging
Asynchronous processing
Fast API responses even when delivery is slow
Lesson 1598 — Synchronous vs Asynchronous ProcessingLesson 1698 — Message Queue for Decoupling
At rest
At rest means data sitting in storage—on disk, tape, or cloud object storage.
Lesson 1409 — Backup Encryption and Security
at-least-once delivery
In distributed event processing systems (like Kafka, RabbitMQ, or AWS EventBridge), at-least-once delivery is the common guarantee.
Lesson 1035 — Idempotency in Event Processing
Atomicity
Atomicity means all-or-nothing execution.
Lesson 309 — ACID Properties Overview
attributes
In distributed tracing, tags (also called attributes) are key-value pairs attached to spans.
Lesson 1233 — Span Tags and Attributes
aud
audience (which client this token is for)
Lesson 929 — ID Tokens and the UserInfo Endpoint
Authentication Layer
Implement OAuth2 or JWT-based authentication to verify user identity. Store user credentials (hashed passwords) separately from paste data. On each request, validate tokens to determine if the user is authenticated and authorized to access specific pastes.
Lesson 1578 — User Accounts and Paste Management
Auto-ack
Message is acknowledged automatically upon delivery (risky—enables at-most-once delivery)
Lesson 681 — Acknowledgment Mechanisms
Automatic failover
The system uses algorithms like Raft or Paxos to elect a new leader based on criteria like "most up-to-date replica" or "lowest node ID"
Lesson 1366 — Leader Election and Failover
Automatic instrumentation
Automatic instrumentation means frameworks detect and wrap common libraries (HTTP clients, database drivers, message queues) to create spans without code changes.
Lesson 1224 — Automatic vs Manual Instrumentation
Automatic load balancing
The broker distributes messages across available consumers
Lesson 661 — Competing Consumers Pattern
Availability
Availability is the percentage of time a system is operational and capable of serving requests successfully.
Lesson 1318 — Defining Availability and Uptime
Availability Goals
Social feeds are often the primary engagement driver. A "three nines" (99.9%) availability target means maximum 8.76 hours downtime per year, or about 43 minutes per month. For critical social platforms, "four nines" (99.99%) is more appropriate—just 52 minutes of downtime yearly.
Lesson 1633 — Non-Functional Requirements: Scale and Performance
Availability over consistency
Temporary inconsistency is acceptable
Lesson 375 — Sloppy Quorum and Hinted Handoff
AWS App Mesh
AWS App Mesh is Amazon's managed service mesh that works seamlessly with AWS services like ECS, EKS, EC2, and Fargate.
Lesson 864 — AWS App Mesh and Cloud-Native Meshes

B

B-tree indexes
B-tree indexes (balanced trees) are the most common type.
Lesson 307 — Indexes and Query Optimization
Backfilling
Backfilling is reprocessing historical data after fixing bugs or adding new logic.
Lesson 777 — Workflow Orchestration Patterns
Backpressure
Backpressure is what happens when even the buffer reaches capacity.
Lesson 1155 — Log Buffering and BackpressureLesson 1680 — Backpressure and Rate Limiting Updates
backup
A backup is a point-in-time copy of your data stored separately from the primary system.
Lesson 1400 — What Are Backups and Why They Matter
Backups
Backups are point-in-time copies of data designed for disaster recovery.
Lesson 1401 — Backup vs Replication vs Snapshots
backward compatibility
Versioning is the practice of explicitly marking API changes, and backward compatibility means new versions still support old clients.
Lesson 809 — Versioning and Backward CompatibilityLesson 1898 — Why API Versioning Matters
baggage
While trace context (lesson 1230) passes trace IDs and span IDs between services, baggage is a separate mechanism for propagating arbitrary key-value pairs alongside the trace.
Lesson 1237 — Baggage and Cross-Cutting Concerns
Bandwidth ceiling
Even a high-speed connection (1 Gbps) can only download so much per second. Fetching billions of pages at reasonable speeds is physically impossible from one location.
Lesson 1862 — Why Distribute a Web Crawler
Basically Available
Basically Available means the system keeps working during partial failures.
Lesson 314 — BASE Properties Overview
Batch
Batch is cost-effective—processing large volumes together maximizes resource utilization and allows scheduled compute during off-peak hours.
Lesson 746 — Choosing Batch vs Stream
batch layer
In Lambda Architecture, the batch layer is your source of absolute truth.
Lesson 748 — Lambda Architecture: Batch Layer
Batch processing
Batch processing is a data processing approach where you collect data over time and then process it all at once during a scheduled job.
Lesson 736 — What is Batch Processing?
Bearer Token Transport
The client explicitly includes the token in the Authorization header (e.g., Authorization: Bearer <token>). The client must manually attach this header with every request—like actively showing your ID card at each checkpoint.
Lesson 918 — Cookie vs Bearer Token Transport
Better partition tolerance
The system stays operational during network splits
Lesson 560 — Eventual Consistency with Quorums
blameless culture
A blameless culture means treating system failures as organizational learning moments rather than individual mistakes deserving punishment.
Lesson 1317 — Blameless Culture and Learning from Failure
blameless postmortem
After an incident (which you've already triaged, mitigated, and resolved), a blameless postmortem is a structured review meeting focused entirely on what happened and how to prevent it, not who caused it.
Lesson 1304 — Blameless Postmortems
Blazing fast reads
feeds are pre-built, just fetch and display
Lesson 1638 — Push (Write-Time) Feed Model
blocking protocol
Key Takeaway: 2PC is called a blocking protocol because coordinator failure after the prepare phase leaves participants in limbo, unable to make progress while holding critical resources locked.
Lesson 573 — The Blocking Problem in 2PC
Bloom filter
A Bloom filter is a probabilistic data structure that tells you:
Lesson 1853 — Bloom Filters for URL Seen Checking
Booking systems
preventing double-bookings for flights, hotels, or appointments
Lesson 318 — When to Choose ACID or BASE
Bottleneck
The central store becomes a single point of failure and a throughput limit.
Lesson 1793 — Centralized vs Distributed Rate Limiting
Bottleneck potential
The shared store becomes a performance constraint at scale
Lesson 979 — Centralized vs Decentralized Approaches
bounded context
A bounded context is a boundary within which a specific business term or model has a precise, consistent meaning.
Lesson 815 — Domain-Driven Design and Bounded Contexts
breach
A breach is a failing dependency (slow database, unresponsive microservice)
Lesson 1068 — The Ship Bulkhead Analogy: Containing Damage
broker
A broker is a single Kafka server that stores data and serves client requests.
Lesson 700 — Kafka Overview and Core ComponentsLesson 704 — Brokers and Cluster Architecture
Bulkheads
Bulkheads are physical walls that contain flooding to one section
Lesson 1074 — Bulkheads vs Circuit Breakers: Complementary Patterns
Business Continuity
Business Continuity is the broader organizational strategy for keeping critical business operations running during and after any disruption—including non-technical issues like pandemics, supply chain failures, or key personnel losses.
Lesson 1433 — Disaster Recovery vs Business Continuity
Byzantine failures
Byzantine failures are the nightmare scenario.
Lesson 602 — Crash-Stop vs Byzantine Failures

C

cache hit ratio
A cache hit ratio is the percentage of requests successfully served from cache versus those requiring a trip to the slower underlying data source.
Lesson 27 — Memory Requirements for CachingLesson 129 — Cache Hit Ratio Optimization
Cache Key
Typically the paste ID (cdn.example.com/paste/abc123). Ensure your URL structure is clean and deterministic.
Lesson 1569 — CDN Integration for Paste Delivery
Cache Miss Handling
If no robots.txt exists (404), cache that fact too—assume all paths are allowed but still respect politeness.
Lesson 1861 — Robots.txt Caching and Parsing
Cache tagging
Cache tagging means attaching labels (tags) to cache entries when you store them.
Lesson 164 — Cache Tagging and Grouping
Cache-Control
The primary directive. For a paste with 24-hour TTL:
Lesson 1570 — CDN Cache Control Headers
Cached Responses
Return stale but acceptable data from a cache. If your product catalog service is down, serve yesterday's product listings rather than showing nothing. Users get slightly outdated information instead of errors.
Lesson 1061 — Fallback Strategies
caching hierarchy
A caching hierarchy is a multi-layer strategy where data is stored at different levels of your architecture, each progressively closer to the end user.
Lesson 120 — Caching Hierarchy Overview
Candidate
The campaigning state. When a follower stops hearing from a leader (election timeout expires), it transitions to candidate and starts an election, requesting votes from other servers to become the new leader.
Lesson 619 — Server States: Leader, Follower, Candidate
Capacity limits
The heaviest partition determines your scaling ceiling
Lesson 1491 — Data Skew and Cardinality Issues
Carbon
The listener daemon that receives metrics over the network (typically via plaintext protocol or pickle)
Lesson 1202 — Graphite Time-Series Database
Cascading failures
Service A's error might be caused by Service B, which is actually failing because of Service C
Lesson 807 — Debugging and Troubleshooting
Case-insensitive
Case-insensitive means they're treated identically.
Lesson 1518 — Case Sensitivity Considerations
Case-sensitive
Case-sensitive means mysite.com/Abc and mysite.com/abc redirect to different destinations.
Lesson 1518 — Case Sensitivity Considerations
Centralized logging
Centralized logging means shipping logs to an external aggregation system (like Elasticsearch, Loki, or Splunk) as soon as they're generated.
Lesson 1148 — Centralized Logging ArchitectureLesson 1169 — Centralized vs Localized Logging
Centralized logic
The workflow is explicit and visible in one place
Lesson 591 — Orchestration-Based Sagas
Challenges
UUIDs are 128 bits (16 bytes), causing index bloat and random insertion patterns that fragment B-tree indexes, hurting performance.
Lesson 1520 — Primary Key Selection: Auto-Increment vs UUID
changelog topic
Here's the crucial part: every write to your local state store is also written to a Kafka topic called a changelog topic.
Lesson 723 — Kafka Streams State Stores
Chat applications
Each room is a channel; users subscribe to rooms and publish messages
Lesson 357 — Redis Pub/Sub for Real-Time Messaging
Chunking
Data is organized into time-based blocks (e.g., 2-hour chunks). Old blocks become immutable and highly compressible. Recent data stays in memory for fast writes.
Lesson 1269 — Time Series Databases for Metrics
circuit breaker
A circuit breaker is a fault tolerance mechanism that monitors calls between services and "opens" (blocks requests) when a downstream service becomes unhealthy.
Lesson 1043 — What Is a Circuit Breaker?
Circuit breakers
Circuit breakers are emergency shutoff valves that stop pumping water into a compromised section
Lesson 1074 — Bulkheads vs Circuit Breakers: Complementary Patterns
Cleaner URLs
Resource paths stay stable; /users/123 is always the same user
Lesson 1902 — Content Negotiation with Media Types
Clear accountability
The team that needs the feature builds it
Lesson 906 — BFF Ownership and Team Structure
Clear popularity hierarchies
Some items are consistently more popular
Lesson 147 — Least Frequently Used (LFU)
Client-side
Client-side means the calling application throttles itself before sending requests.
Lesson 1789 — Client-Side vs Server-Side Rate Limiting
Client-side enforcement
Client-side enforcement is essential when:
Lesson 1123 — Client-Side vs Server-Side Timeout Enforcement
Client-side timeout
The maximum time a client will wait for a response before giving up
Lesson 1090 — Client-Side vs Server-Side Timeouts
Clock drift
A node with a fast clock can perpetually "win," even if its writes are genuinely older
Lesson 1381 — Limitations of Last-Write-Wins
clock skew
But in distributed systems, clock skew is inevitable—different servers' clocks drift apart, sometimes by seconds or more.
Lesson 1381 — Limitations of Last-Write-Wins
Closed state
The Closed state is where your circuit breaker starts and where it spends most of its time when everything is healthy.
Lesson 1045 — The Three States: Closed
Coding
Coding is like being the carpenter who hammers nails, installs drywall, and connects the plumbing pipes.
Lesson 3 — System Design vs Coding
Cognitive load matches team size
A small team can hold the entire system in their heads
Lesson 820 — When a Monolith is the Right Choice
Cold data
Cold data is older timeline content that users rarely view.
Lesson 1663 — Hot and Cold Timeline Data
cold standby
A cold standby is a backup that exists only as stored data—backups, snapshots, or archived configurations.
Lesson 1417 — Hot Standby vs Cold Standby
Cold storage
Cold storage is your archival glacier—tape libraries, AWS Glacier, or deep archive tiers.
Lesson 1428 — Backup Storage Tiers
collection
A collection is a group of related documents, conceptually similar to a table in relational databases, but without enforcing a fixed schema.
Lesson 389 — MongoDB Document Model and Collections
collections
In a document store, collections are groups of related documents, similar to how tables group rows in a relational database.
Lesson 383 — Collections and Databases
Collision risk
Truncation increases collision probability (two different URLs producing the same short code). With 7 Base62 characters (≈3.5 trillion combinations), collisions are rare but possible—requiring collision detection and handling logic.
Lesson 1508 — Hash-Based Generation Approach
Columnar layouts
Values, timestamps, and tags are stored separately. When you query "average CPU over 5 minutes," the TSDB reads only the values column, not the entire row structure.
Lesson 1269 — Time Series Databases for Metrics
Columnar storage
storing columns together instead of rows, perfect for aggregations
Lesson 760 — Data Warehouse Architecture
Commit index
The commit index is a variable each server maintains that tracks the highest log entry known to be committed.
Lesson 624 — AppendEntries RPC: Replication MechanismLesson 626 — Commitment and the Commit Index
Committing
Committing means saving your current offset position back to Kafka.
Lesson 710 — Offsets and Commit Strategies
Compaction
Compaction is the background process that merges these SSTables, removes deleted or expired data, and reduces disk usage and read amplification.
Lesson 417 — Compaction StrategiesLesson 428 — Compaction Strategies
compartment
Each compartment represents an isolated resource pool (thread pool, connection pool, memory allocation)
Lesson 1068 — The Ship Bulkhead Analogy: Containing Damage
Complete audit trail
You know why something is in its current state
Lesson 691 — Events as First-Class Citizens
Complete rewrites
The codebase becomes so tangled that starting over feels easier than fixing it
Lesson 2 — Why System Design Matters
Complex service meshes
If a request touches 10+ microservices, tracing becomes essential. Metrics show what is slow; traces show where and why. Without traces, debugging cascading failures or identifying the bottleneck in a long chain is like solving a puzzle blindfolded.
Lesson 1260 — Cost-Benefit Analysis
Complexity
Debugging and reasoning about distributed failure modes is notoriously difficult
Lesson 263 — Shard Key Immutability ProblemLesson 1489 — Cross-Partition Transactions
Components
The individual parts that do specific jobs (like databases that store data, servers that handle requests, or caches that speed things up)
Lesson 1 — What Is System Design?
Composability
Composability means these services can be combined in different ways—like LEGO bricks—to build diverse experiences without rewriting code.
Lesson 800 — Reusability and Composability
Compression
Since consecutive values are often similar, TSDBs use delta encoding (storing differences) and specialized compression algorithms. A CPU metric going 50.1%, 50.3%, 50.2% stores more efficiently as base value + tiny deltas.
Lesson 724 — Kafka Performance TuningLesson 1269 — Time Series Databases for Metrics
Configuration changes
Adding or removing nodes safely is extremely tricky
Lesson 617 — Why Paxos Is Difficult in Practice
Connection Pooling
Connection pooling means distributing connections across multiple servers:
Lesson 186 — Dynamic Content AccelerationLesson 267 — What is Connection PoolingLesson 1674 — Connection Management at Scale
Connection validation
Connection validation is the practice of testing a connection before handing it to application code.
Lesson 271 — Connection Validation and Stale Connections
Consistency
Transactions move the graph from one valid state to another. Constraints (like unique usernames) are enforced before committing.
Lesson 470 — Transaction Model and ACID in Neo4j
Consistency with changing data
If items are inserted/deleted during pagination, cursors keep you at the logical position. With offsets, you'd skip items or see duplicates.
Lesson 1889 — Cursor-Based Pagination
Consistent Policy Enforcement
A user shouldn't be able to bypass limits by hitting different endpoints. Centralized rate limiting tracks usage across your entire API surface—whether someone queries search, uploads files, or triggers notifications, their total quota is enforced consistently.
Lesson 1782 — Rate Limiter Service Overview
Consistent security policies
The gateway enforces TLS versions (e.g., requiring TLS 1.2+), cipher suites, and certificate validation uniformly across all traffic.
Lesson 891 — SSL/TLS Termination
Constraint boundaries
If your limit is 1,000 QPS and you estimate 980, don't round to 1,000
Lesson 32 — Rounding and Approximation Techniques
consumer group
In Kafka, a consumer group is a logical grouping of consumers that coordinate to consume messages from a topic.
Lesson 716 — Consumer Groups and Partition Assignment
consumers
In event streaming platforms, producers are applications or services that write events to the stream (the commit log), while consumers are applications that read those events.
Lesson 694 — Producers and Consumers
Continuous Consumption
Streams are designed for consumers to read continuously, processing events as they arrive. Databases are queried on-demand with sporadic SELECT statements. A stream consumer might run 24/7, reacting to every new event.
Lesson 692 — Streams vs Traditional Databases
control plane
The control plane is the brain of the mesh.
Lesson 837 — Service Mesh Architecture: Control vs Data Plane
Cookie Transport
The server sets an HTTP cookie containing the token. Browsers automatically attach cookies to every matching request—no client code needed. Think of it like a backstage pass clipped to your shirt; you don't even think about showing it.
Lesson 918 — Cookie vs Bearer Token Transport
Cookies
Cookies are vulnerable to CSRF (Cross-Site Request Forgery) attacks because browsers auto-send them even from malicious sites.
Lesson 94 — Session Affinity (Sticky Sessions)Lesson 918 — Cookie vs Bearer Token Transport
coordinator
In Two-Phase Commit (2PC), the coordinator is a single node responsible for driving the entire transaction to completion or rollback.
Lesson 569 — The Coordinator Role in 2PCLesson 1863 — Coordinator-Worker Pattern for Crawling
correlation ID
A correlation ID is a unique identifier (often a UUID) attached to a request when it enters your system.
Lesson 1132 — Correlation IDs and Request Tracing
Cost
Run jobs when compute is cheaper or resources are idle
Lesson 349 — Redis In-Memory Storage ModelLesson 736 — What is Batch Processing?
Cost considerations
SMS is expensive; route non-urgent messages to push or email when possible.
Lesson 1703 — Channel Routing Logic
Cost inefficiency
Database storage is typically 10-20× more expensive than object storage
Lesson 1550 — Object Storage for Paste Content
Cost reduction
Storing 1% of debug logs instead of 100% can reduce your logging bill by 99%
Lesson 1164 — Sampling for High-Volume Logs
Cost-sensitive calculations
Bandwidth costs compound; 10% error means real money
Lesson 32 — Rounding and Approximation Techniques
counter
A counter is a metric type that represents a monotonically increasing value—it only goes up (or resets to zero).
Lesson 1174 — Counter MetricsLesson 1183 — Counter Metrics
covering index
A covering index is an index that contains all the columns needed to satisfy a query.
Lesson 279 — Covering Indexes
CP
If users can wait or retry later without major impact, CP is viable.
Lesson 503 — Choosing Between CP and AP
CPU and Memory
Every sidecar proxy is a separate process consuming resources. In a cluster with 100 services across 500 pods, you now have 500 additional proxy containers running. Each might use 50-200MB of memory and require CPU for encryption, routing logic, metrics collection, and policy evaluation.
Lesson 834 — Service Mesh Performance Overhead
CPU and memory utilization
tighten limits when resources are strained
Lesson 972 — Adaptive Rate Limiting
CPU constraints
Parsing HTML, extracting links, and computing content fingerprints are CPU-intensive. One processor can't keep up.
Lesson 1862 — Why Distribute a Web Crawler
Crawl delay
Crawl delay is the enforced wait time between consecutive requests to the same domain, ensuring you don't hammer servers with rapid-fire requests.
Lesson 1842 — Politeness Budget and Crawl Delay
Crawl freshness
Crawl freshness is about keeping your index up-to-date while respecting resource limits—you can't recrawl the entire web constantly.
Lesson 1835 — Crawl Freshness Requirements
Crawling
Crawling is the process of systematically discovering and downloading web pages (or internal documents) so they can be indexed later.
Lesson 1732 — Crawling and Document Collection
critical path
A critical path is a dependency chain whose failure would cause the most severe cascading damage to your system.
Lesson 1082 — Critical Path Identification
Crystal clear
Version is immediately visible in URLs and logs
Lesson 1899 — URI Versioning (Path-Based)
culture of chaos
Building a culture of chaos means normalizing failure testing across your entire organization—where breaking things intentionally is not just accepted but celebrated.
Lesson 1349 — Building a Culture of Chaos
Current metrics
The actual value that triggered the alert (e.g., "CPU at 94%, threshold 85%")
Lesson 1293 — Alert Context and Enrichment
Cypher
Cypher (used by Neo4j) is designed to look like the graph patterns you're searching for.
Lesson 456 — Graph Query Languages: Cypher and Gremlin

D

DAG
A DAG is the blueprint of your pipeline.
Lesson 766 — Apache Airflow Fundamentals
Dashboards
Dashboards are collections of panels organized into rows.
Lesson 1200 — Grafana for Metrics Visualization
data lake
A data lake is a centralized repository that stores vast amounts of raw data in its original, native format—structured, semi-structured, or unstructured—without requiring you to define a schema upfront.
Lesson 758 — Data Lake Fundamentals
Data locality matters
Accessing nearby memory addresses is dramatically faster
Lesson 127 — CPU and Disk Caching Layers
Data loss risk
if cache crashes before flushing, recent writes are lost
Lesson 136 — Write-Behind (Write-Back) Caching Pattern
data pages
The database checks if the needed data pages are already in the buffer pool
Lesson 126 — Database Internal Caching (Buffer Pool)
Data partitioning
Data partitioning is the defining feature.
Lesson 360 — What Makes a Key-Value Store Distributed
data plane
Lightweight proxies that handle all request traffic, routing, authentication, and plugin execution. These are stateless and horizontally scalable.
Lesson 837 — Service Mesh Architecture: Control vs Data PlaneLesson 838 — Data Plane: Sidecar Proxy PatternLesson 894 — Kong Gateway Architecture
Data replication
Data replication means storing the same data on multiple servers (nodes) instead of keeping it in just one place.
Lesson 68 — What is Data Replication?
data warehouse
A data warehouse is a centralized repository designed specifically for analytical workloads, not day-to-day transactions.
Lesson 757 — Data Warehouse Fundamentals
Database replication
Database replication is the process of copying data from a primary (master) database to one or more replica (slave) databases.
Lesson 198 — What is Database Replication?
Databases
Databases are the top-level organizational unit.
Lesson 383 — Collections and Databases
dbt
dbt (data build tool) is a transformation framework that treats your SQL queries as software code.
Lesson 774 — dbt for Analytics Engineering
deadline
A timeout is a relative duration: "wait up to 5 seconds." A deadline is an absolute timestamp: "must complete by 14:32:15.500 UTC."
Lesson 1108 — What is Deadline Propagation
Debezium
Debezium is an open-source CDC platform built on Kafka Connect.
Lesson 776 — Change Data Capture Tools
Debouncing
Debouncing means waiting for a brief pause in typing before sending a request.
Lesson 1763 — Debouncing and Request Optimization
Default Expiration Policy
Instead of allowing infinite TTL, set a "very long" default—perhaps 1 year, 5 years, or 10 years. This provides the illusion of permanence while ensuring eventual cleanup. Think of it like a library lease: users can always renew, but nothing is truly permanent by default.
Lesson 1573 — Handling Never-Expiring Pastes
Defense in depth
Defense in depth means implementing rate limits at every major boundary, so if one layer fails, others still protect your resources.
Lesson 962 — Rate Limiting at Different Layers
DELETE
Removes a resource. Delete it once, it's gone. Delete it again, it's still gone (the end state is identical).
Lesson 1009 — HTTP Methods and Natural Idempotency
Denormalization
Storing click_count directly trades write amplification for read speed—acceptable since reads vastly outnumber writes.
Lesson 1519 — Database Schema for URL Shortener
Dependency graphs
Dependency graphs are like service maps but focus on a specific trace or trace set.
Lesson 1248 — Trace Visualization and UI
Deployment Simplicity
Rolling updates are trivial—kill a worker, deploy new version, start it up. No state migration required.
Lesson 1864 — Stateless Worker Design
Detection Speed vs Accuracy
Fast detection means quicker failover, but too sensitive checks cause false positives. Most systems use multiple consecutive failures before triggering failover.
Lesson 1335 — Failover Mechanisms
Disaster Recovery
Disaster Recovery is the technical plan for restoring IT systems, data, and infrastructure after a catastrophic failure—think fires, server crashes, regional outages, or data corruption.
Lesson 1433 — Disaster Recovery vs Business Continuity
distributed monolith
A distributed monolith is the worst of both worlds: you have multiple services (microservices architecture) but they're so tightly coupled that they must be deployed together, changed together, and can't be understood or tested independently.
Lesson 824 — Avoiding Distributed Monoliths
distributed transaction
A distributed transaction is a single logical operation that must update data across multiple independent databases or services while maintaining consistency guarantees.
Lesson 566 — What is a Distributed Transaction?
distributed worker architecture
A distributed worker architecture means running multiple independent worker processes across many servers, all pulling jobs from the same queue and processing them in parallel.
Lesson 1605 — Distributed Worker Architecture
Document ID
A unique identifier (often an integer) pointing to the actual document
Lesson 1736 — Posting Lists and Document IDs
document processing pipeline
The document processing pipeline is the multi-stage assembly line that extracts pure text, standardizes it, and breaks it into searchable pieces.
Lesson 1733 — Document Processing Pipeline
document store
A document store is a type of NoSQL database that stores data as complete, self-contained documents—typically in formats like JSON, BSON (binary JSON), or XML.
Lesson 379 — What Is a Document Store?
Documenting your decisions
Documenting your decisions means writing down what you decided, why you chose it, and what alternatives you rejected.
Lesson 42 — Document Your Decisions
Downtime risk
The record might be temporarily unavailable during the move
Lesson 263 — Shard Key Immutability Problem
Dropping messages
Dropping messages means data loss—unacceptable for critical operations like payments or orders.
Lesson 1080 — Queue Saturation and Backpressure Loss
Dry runs
Dry runs are practice incidents where teams rehearse their response procedures without actual customer impact.
Lesson 1295 — Testing Alerts and Dry Runs
Duplicate Critical Fields
Duplicate Critical Fields means intentionally copying certain data across multiple tables so you can retrieve everything you need without performing joins.
Lesson 293 — Duplicate Critical Fields
dynamic algorithm selection
Rather than hardcoding a single load balancing algorithm forever, dynamic algorithm selection means your load balancer adapts its strategy on the fly.
Lesson 97 — Dynamic Algorithm Selection
DynamoDB
Cassandra and DynamoDB are classic PA/EL systems.
Lesson 521 — PACELC Tradeoffs in Real Systems

E

E-commerce orders
RPO of minutes (recent orders are critical)
Lesson 1411 — Defining Recovery Point Objective (RPO)
Early rejection
Early rejection means your services never waste resources processing malformed requests.
Lesson 886 — Request Validation
Easier to monitor
Fewer moving parts means clearer signals and less noise
Lesson 1315 — Simplicity as a Core Value
Easy communication
Simpler designs are easier to explain and discuss with interviewers or teammates
Lesson 34 — Start Simple: The Minimum Viable Design
Easy to understand
The mental model is straightforward—everyone talks to everyone
Lesson 1369 — Multi-Leader Topologies: All-to-All
Economic Defense
Without rate limiting, a single misbehaving client (malicious or buggy) can rack up massive infrastructure costs or degrade service for everyone. The rate limiter is your economic moat.
Lesson 1782 — Rate Limiter Service Overview
Edge servers
Edge servers are distributed caching nodes deployed in many geographic locations around the world.
Lesson 170 — CDN Architecture: Edge Servers and Origin
Egress cost savings
Cloud providers charge heavily for data leaving a region (egress fees). If your Tokyo users are downloading media stored in Tokyo, you avoid cross-region transfer charges entirely. These costs scale dramatically—potentially reducing bills by 50-70% for globally distributed apps.
Lesson 1626 — Geolocation-Based Storage
Elasticsearch
Elasticsearch is a distributed, RESTful search and analytics engine built on Apache Lucene.
Lesson 1150 — The ELK Stack: Elasticsearch
Email addresses or UUIDs
Guaranteed uniqueness means guaranteed cardinality explosion.
Lesson 1211 — Avoiding High-Cardinality Labels
Embedding
Embedding means storing related data directly inside the parent document—like keeping all order items inside an order document.
Lesson 292 — Embedding vs Referencing in DocumentsLesson 386 — Embedded Documents vs References
End-to-end latency
Measure the time from metric emission to dashboard visibility. High latency means you'll miss rapid incidents.
Lesson 1218 — Testing Metric Pipelines
Entity integrity
Entity integrity is a fundamental database principle: the primary key of a table must never be null or duplicated.
Lesson 299 — Primary Keys and Entity Integrity
Envoy
Envoy is an open-source, high-performance proxy designed for microservices and service mesh architectures.
Lesson 115 — Envoy Proxy Architecture
Envoy Proxy
Unlike traditional API gateways built on older technologies, Envoy Proxy is a high-performance C++ proxy originally developed at Lyft.
Lesson 897 — Envoy Proxy for API Management
error budget
An error budget is the mathematical inverse of your SLO — it represents the amount of "failure" you can afford before breaking your reliability promise.
Lesson 1279 — Error Budgets: The Core ConceptLesson 1280 — Calculating and Tracking Error Budget
Error Budget Policies
Error Budget Policies are predefined agreements that answer these questions by establishing team behaviors and priorities tied to budget health.
Lesson 1281 — Error Budget Policies
Error Code
A machine-readable identifier (e.g., INVALID_EMAIL, RESOURCE_NOT_FOUND). This lets clients distinguish between error types without parsing human-readable messages.
Lesson 1883 — Error Response Structure and Consistency
Error message
The human-readable description from the exception itself.
Lesson 1142 — Logging Exceptions and Stack Traces
Errors
The count of error events (e.g., network packet drops)
Lesson 1189 — The USE Method
ETag
ETag (entity tag) is a unique identifier for a resource version.
Lesson 121 — Browser Caching and HTTP HeadersLesson 1570 — CDN Cache Control Headers
etcd
etcd is a distributed key-value store used by Kubernetes for cluster coordination.
Lesson 530 — Strong Consistency in Practice
Event streaming
A river flows continuously, and anyone can drink from it at any time
Lesson 690 — What is Event Streaming?
Eventually consistent
The system will become consistent eventually, but not immediately
Lesson 314 — BASE Properties Overview
Exactly one leader
Exactly one leader is elected per term (logical time period)
Lesson 636 — Consensus for Leader Election
Exactly-once
Exactly-once is necessary when duplicates are unacceptable and natural idempotency is hard: financial transactions, inventory updates, or billing events.
Lesson 689 — Choosing Delivery SemanticsLesson 718 — Exactly-Once Semantics (EOS)
Exactly-once semantics
The effect appears as if each message was processed once, even if internal retries occurred. This requires:
Lesson 680 — Exactly-Once Delivery
Example scenario
An order table with a unique constraint on order_id prevents creating the same order twice, even if two identical requests race to the database.
Lesson 1034 — Database Patterns for Idempotency
Exception type
The class name (e.g., NullPointerException, TimeoutException) tells you the category of failure.
Lesson 1142 — Logging Exceptions and Stack Traces
exchange
Unlike simple message queues where producers write directly to queues, RabbitMQ inserts an intermediary layer called an exchange.
Lesson 666 — RabbitMQ Architecture Fundamentals
Exhausting resources
Exhausting resources means consuming CPU, memory, disk I/O, or file descriptors until components struggle.
Lesson 1347 — Common Chaos Experiments
Expiration
The indexed expires_at field enables efficient cleanup jobs that periodically delete or recycle expired links.
Lesson 1519 — Database Schema for URL Shortener
Expires
Expires is the older header specifying an absolute date/time when the resource becomes stale (mostly replaced by Cache-Control).
Lesson 121 — Browser Caching and HTTP HeadersLesson 1570 — CDN Cache Control Headers
Exponential backoff
Exponential backoff is key: the proxy waits progressively longer between retries (e.g., 1s, 2s, 4s).
Lesson 853 — Retry Policies and Timeout Configuration
externalizing state
This is why externalizing state (lesson 59) is often preferred—but sticky sessions remain useful for performance optimization or legacy applications that can't easily be refactored.
Lesson 60 — Sticky Sessions and Load Balancer Affinity

F

Failback
Failback is the reverse—returning operations from the DR site back to the restored primary site.
Lesson 1437 — Failover and Failback Procedures
Failure count threshold
Failure count threshold is the simplest approach: open the circuit after N consecutive failures (e.g., "open after 5 failed requests in a row").
Lesson 1048 — Failure Thresholds and Detection
Failure rate threshold
Failure rate threshold is more sophisticated: open when the error rate exceeds a percentage over a time window (e.g., "open when >50% of requests fail over 10 seconds").
Lesson 1048 — Failure Thresholds and Detection
Failure Scenarios
Model what happens when a dependency hangs. If your database query timeout is 5 seconds and you receive 50 req/sec, you need at least 250 threads in that bulkhead to handle requests piling up during an outage—but probably more for safety margin.
Lesson 1073 — Bulkhead Sizing: Balancing Isolation and Utilization
false positive
A false positive means the health check incorrectly reports a server as unhealthy when it's actually fine—just experiencing a temporary issue.
Lesson 106 — Health Check False Positives and Flapping
Fan-out
Fan-out is when a single event triggers multiple parallel actions.
Lesson 662 — Fan-Out with Pub-Sub
Fanout
Fanout is the process of delivering a newly published post to all followers' feeds.
Lesson 1645 — What is Fanout in Social Media Systems
fanout service
A fanout service is a specialized backend component responsible for the heavy lifting of post distribution.
Lesson 1650 — Fanout Service Architecture
Fast reads
Set W=4, R=2 (4+2 > 5). Reads are quick, writes wait for more acknowledgments.
Lesson 759 — Schema-on-Write vs Schema-on-ReadLesson 1361 — Quorum-Based Replication
Fast single-user queries
All posts for one user are co-located
Lesson 1661 — Timeline Schema Design
Faster iteration
Refactoring across service boundaries is painful; refactoring within one codebase is straightforward
Lesson 820 — When a Monolith is the Right Choice
Faster than full backups
Only changed data is backed up
Lesson 1404 — Differential Backups
Fault injection
Fault injection is the practice of intentionally causing failures in production-like environments to test whether your fault-tolerant design holds up under real conditions.
Lesson 1342 — Testing Redundancy with Fault Injection
fault tolerance
If a worker crashes mid-fetch, nothing is lost permanently. The coordinator can reassign that URL to another worker. No complex state recovery needed.
Lesson 47 — Single Point of Failure in Vertical ScalingLesson 1330 — What is Fault Tolerance?Lesson 1806 — Rate Limiting with Consistent HashingLesson 1864 — Stateless Worker Design
final line of defense
The final line of defense is the client application itself, which can intelligently filter duplicates before displaying them to users.
Lesson 1714 — Client-Side Deduplication
Fixed window counters
Fixed window counters are extremely memory-efficient.
Lesson 970 — Fixed vs Sliding Window Tradeoffs
Fixed windows
Fixed windows are trivial to implement: increment a counter, check it, reset at window boundaries.
Lesson 970 — Fixed vs Sliding Window Tradeoffs
flapping
This rapid on-off-on-off behavior is called flapping, and it creates instability across your entire system.
Lesson 106 — Health Check False Positives and Flapping
Flexible execution
The framework decides how to optimize—chunking data like batch processing when appropriate, or flowing continuously when needed
Lesson 756 — Hybrid and Modern Alternatives
Flooding
Flooding represents resource exhaustion spreading across your system
Lesson 1068 — The Ship Bulkhead Analogy: Containing Damage
Flow
The prioritizer selects the next URL by importance, then routes it to the appropriate host-specific politeness queue. Worker threads pull from politeness queues that are ready (delay expired), ensuring both importance and etiquette.
Lesson 1843 — Multi-Queue Frontier Architecture
Follower
The passive state. Followers don't initiate actions; they simply respond to requests from leaders and candidates. When a cluster starts, all servers begin as followers. They wait to hear from a leader.
Lesson 619 — Server States: Leader, Follower, Candidate
foreign key
A foreign key is a column (or set of columns) in one table that references the primary key of another table.
Lesson 300 — Foreign Keys and Referential Integrity
front queue
The front queue is where you make these decisions before URLs flow into the politeness-controlled back queues.
Lesson 1844 — Front Queue: Priority Management
Frontend proxy
The first point of contact for client requests
Lesson 112 — HAProxy Overview
full mesh
In an all-to-all topology (also called a full mesh), every leader replicates its writes directly to every other leader.
Lesson 1369 — Multi-Leader Topologies: All-to-All
Full table scans
Full table scans are a graph database's Achilles heel.
Lesson 478 — When Graphs Underperform: Aggregations and Scans

G

Game Day
A Game Day is a scheduled, controlled event where your team intentionally breaks things in a safe environment to practice incident response.
Lesson 1345 — Starting with Game Days
gauge
A gauge is a metric type that represents a single numerical value that can arbitrarily go up or down over time.
Lesson 1175 — Gauge MetricsLesson 1184 — Gauge Metrics
Geo-Distributed Replication
Data is replicated across multiple nodes (typically 3+ copies) using a consensus protocol (Raft). You can place replicas in specific geographic regions to optimize for latency or compliance requirements.
Lesson 334 — CockroachDB and Distributed SQL
GeoDNS
GeoDNS is a DNS service that returns different IP addresses based on the requester's geographic location.
Lesson 1616 — Geographic Routing and DNS
Geographic Distribution
Because PoPs exist worldwide, attack traffic is naturally dispersed rather than concentrated on your single data center.
Lesson 195 — CDN for DDoS Protection
Geographic latency
Crawling sites hosted worldwide from a single data center means high latencies and slow throughput.
Lesson 1862 — Why Distribute a Web Crawler
Geographic redundancy
Geographic redundancy means deploying your system components across multiple physical locations, often hundreds or thousands of miles apart, so that a disaster in one location doesn't destroy your entire service.
Lesson 1334 — Geographic Redundancy and Multi-Region
Geolocation-aware crawling
Geolocation-aware crawling means routing requests through IP addresses physically near the target server.
Lesson 1860 — IP Address Rotation and Geolocation
Geolocation-based storage
Geolocation-based storage means distributing your original media files across multiple regional storage clusters, placing them nearest to where your primary audience lives.
Lesson 1626 — Geolocation-Based Storage
GET
GET is naturally idempotent—reading data multiple times doesn't change anything.
Lesson 1884 — Idempotency in RESTful APIs
Graceful degradation
Graceful degradation means your system stays partially operational even when parts of it fail, rather than crashing entirely.
Lesson 105 — Graceful Degradation and Circuit BreakingLesson 1329 — Partial Availability and Graceful DegradationLesson 1336 — Graceful Degradation
Grant or Deny
Whether the permission is allowed or blocked
Lesson 937 — Access Control Lists (ACLs)
graph database
A graph database is a database system optimized for storing and querying data where relationships between entities are just as important as the entities themselves.
Lesson 451 — What is a Graph Database?
Graphite-web
The web application for querying and rendering graphs
Lesson 1202 — Graphite Time-Series Database
gzip
gzip is the universal standard—widely supported, fast decompression, good compression ratios (typically 60-70% reduction for text).
Lesson 1562 — Content Compression and Encoding

H

Hadoop and GCP ecosystem integration
HBase runs directly on HDFS alongside your Hadoop jobs. BigTable integrates seamlessly with Google Cloud services like Dataflow and Dataproc. If you're already in these ecosystems, the integration is nearly effortless—you can run MapReduce or Spark jobs directly against your database.
Lesson 442 — When to Use HBase or BigTable
hash ring
A hash ring is a conceptual circle (typically representing the range 0 to 2^n - 1) where both your data keys and your server nodes are mapped to positions using a hash function.
Lesson 1457 — The Hash Ring Concept
HBase
HBase is an open-source, distributed, column-oriented NoSQL database modeled after Google's BigTable.
Lesson 433 — What is HBase?
Head-based sampling
Head-based sampling means making the decision to keep or discard a trace at the moment it begins—at the "head" or root span of the request.
Lesson 1253 — Head-Based Sampling
Header forwarding
Header forwarding is the most common approach.
Lesson 945 — Token Propagation Across Services
health check endpoint
A health check endpoint is a dedicated URL (like /health or /status) specifically designed to return your service's readiness.
Lesson 101 — Health Check Endpoints
Health checks
Health checks are periodic tests that load balancers perform to verify each backend server is operational and ready to handle traffic.
Lesson 98 — What Are Health Checks?
Heaps
Both insert and extract-min are O(log n), balancing writes and reads beautifully.
Lesson 1847 — Heap-Based Priority Queue Implementation
Heterogeneous hardware
A server with 64GB RAM might get 200 vnodes, while a 32GB server gets 100 vnodes
Lesson 363 — Virtual Nodes and Load Distribution
High availability
Writes can continue as long as a quorum of nodes is reachable
Lesson 73 — Leaderless Replication Model
High Cardinality
High Cardinality means your shard key has many unique values.
Lesson 247 — Choosing the Right Shard Key
High cohesion
High cohesion means everything inside a service is closely related and works toward the same purpose.
Lesson 818 — High Cohesion, Low Coupling in Service Design
High read throughput
The tail can handle many concurrent reads without coordinating with other replicas
Lesson 1362 — Chain Replication
High Throughput
The platform must handle millions of messages per second. Unlike traditional message queues that optimize for individual message delivery, streaming platforms batch and optimize for sustained data flow, much like a high-capacity pipeline versus individual deliveries.
Lesson 699 — Event Streaming Platform Requirements
Higher availability
If 3 nodes are down, you can still read (R=2) and write (W=2) successfully
Lesson 560 — Eventual Consistency with Quorums
Higher throughput
The primary isn't bottlenecked by the slowest replica
Lesson 1356 — Asynchronous Replication: Speed and Risk
hinted handoff
This reconciliation process is called hinted handoff.
Lesson 561 — Sloppy Quorums and Hinted Handoff
Hit rate
Hit rate is the percentage of requests served from cache.
Lesson 166 — Monitoring Cache Performance
Horizontal expansion
Horizontal expansion means adding more worker instances rather than making one worker bigger (vertical scaling).
Lesson 1708 — Scalability and Horizontal Expansion
Horizontal scaling
You can add or remove workers at any time without coordination. Spin up 100 more workers during peak hours, then scale down—each new worker is immediately productive.
Lesson 44 — What is Horizontal Scaling?Lesson 1864 — Stateless Worker Design
Hot data
Hot data is recent timeline content (e.g., last 7–30 days) that gets frequent access.
Lesson 1663 — Hot and Cold Timeline Data
hot standby
A hot standby is a fully-running, continuously synchronized backup system that can take over almost instantly when the primary fails.
Lesson 1417 — Hot Standby vs Cold Standby
Hot storage
Hot storage is your fastest, most expensive tier—think SSDs optimized for low latency.
Lesson 1428 — Backup Storage TiersLesson 1589 — Storage Tiering Strategy
Human-readable
Human-readable means clear messages, logical ordering, and context that makes sense at a glance:
Lesson 1166 — Human-Readable vs Machine-Parseable
Human-Readable Message
A clear explanation for developers debugging the issue (e.g., "The email address format is invalid").
Lesson 1883 — Error Response Structure and Consistency
Hybrid
Whichever limit is reached first
Lesson 1397 — Bounded Staleness Consistency
Hybrid sharding
Hybrid sharding means applying different sharding techniques together—either in layers or combined into a composite key—to balance multiple goals simultaneously.
Lesson 250 — Hybrid Sharding Strategies
HyperLogLog
HyperLogLog is Redis's probabilistic data structure that estimates cardinality (unique counts) with ~0.81% standard error while using only 12KB per counter, regardless of how many unique items you're tracking.
Lesson 359 — Redis for Leaderboards and Counting

I

Idempotency
Idempotency is a property of an operation where executing it multiple times with the same inputs produces the same result as executing it once.
Lesson 686 — Idempotency and DeduplicationLesson 998 — What is Idempotency?
idempotency key
An idempotency key is a unique identifier (often a UUID) attached to each notification request.
Lesson 1003 — Idempotency KeysLesson 1711 — Idempotency Keys for Notifications
idempotency token
An idempotency token (or key) is a unique identifier the client generates and includes with each request.
Lesson 1027 — Idempotency Tokens in Retry Logic
idempotent consumer
An idempotent consumer is designed so that processing the same message multiple times produces the same outcome as processing it once.
Lesson 686 — Idempotency and Deduplication
idempotent operation
An idempotent operation is one that produces the same result no matter how many times you execute it.
Lesson 584 — Alternative: Idempotent Operations
Identical behavior
Identical behavior means any load balancer can route requests randomly
Lesson 57 — Scaling Stateless Services Horizontally
Identity federation
Identity federation means delegating authentication to external identity providers (IdPs) while maintaining your own authorization layer.
Lesson 932 — Multi-Tenant OAuth2 and Identity Federation
Immediate consistency
The paste URL is instantly valid
Lesson 1559 — Write Path: Synchronous vs Asynchronous Storage
Immediate response required
The client needs data right now (e.g., fetching a user profile to display)
Lesson 654 — When to Use Async vs Sync
In transit
In transit means data moving across networks—from your database server to backup storage, or when retrieving backups for restoration.
Lesson 1409 — Backup Encryption and Security
Incident Command System
The Incident Command System is a structured framework borrowed from emergency response that assigns specific roles to coordinate your response effectively.
Lesson 1300 — Incident Command System (ICS)
Increased propagation delay
Changes must traverse multiple hops; a 3-level tree means 3 sequential replication steps
Lesson 1374 — Tree Replication Topology
Index-Free Adjacency
This is called index-free adjacency, meaning each node contains direct references to its adjacent neighbors stored right alongside it on disk.
Lesson 460 — Neo4j Architecture OverviewLesson 477 — Index-Free Adjacency and Physical Storage
Indexing Strategy
Only public pastes should be indexed. When a paste is created with public visibility, an asynchronous job sends its metadata (title, language, creation date) and content to your search engine (like Elasticsearch or Solr). Private pastes never enter the index.
Lesson 1582 — Search and Discovery
Instant Cache Hits
Popular URLs are ready immediately after cache restarts
Lesson 1529 — Preloading Hot URLs into Cache
Instant revocation
Delete the session record, user is logged out immediately
Lesson 916 — Session vs Token Tradeoffs
Interactive workflows
User is waiting for confirmation (e.g., login verification)
Lesson 654 — When to Use Async vs Sync
invariants
Your database enforces rules (called invariants) like "account balances can't be negative" or "every order must have a valid customer ID." The consistency property ensures these rules are never broken, even when multiple transactions happen simultaneously.
Lesson 311 — Consistency: Maintaining Database Invariants
inverted index
An inverted index is essentially a giant lookup table that flips the traditional document-to-words relationship upside down.
Lesson 1735 — Inverted Index StructureLesson 1743 — What Is an Inverted Index
IP Hash algorithm
The IP Hash algorithm is a load balancing strategy that uses the client's IP address to determine which backend server handles their request.
Lesson 89 — IP Hash Algorithm
Isolation
Preventing one failure from cascading to other components
Lesson 1330 — What is Fault Tolerance?

J

Jitter
Jitter is controlled randomization added to retry delays.
Lesson 1024 — Adding Jitter to Prevent Thundering Herd

K

Kafka Streams
Kafka Streams is a lightweight library that runs within your application (no separate cluster needed).
Lesson 744 — Stream Processing Frameworks
key-value store
A key-value store is a database that works like a giant dictionary or hash map.
Lesson 338 — What is a Key-Value Store?
Killing instances
Killing instances is the simplest experiment.
Lesson 1347 — Common Chaos Experiments
Knowledge gaps
the expert who wrote the procedure is unavailable
Lesson 1441 — Runbooks and Automation
knowledge graph
A knowledge graph is a graph database where nodes represent entities (people, places, concepts) and edges represent meaningful semantic relationships between them—not just "connected to," but why they're connected.
Lesson 475 — Knowledge Graphs and Semantic Networks
KRaft
KRaft (Kafka Raft) is the newer approach that eliminates ZooKeeper by implementing consensus directly within Kafka itself, using a Raft-based protocol among controller brokers.
Lesson 704 — Brokers and Cluster Architecture

L

Lag-aware load balancing
Lag-aware load balancing means your load balancer (or routing layer) actively monitors each replica's current lag and makes intelligent decisions about where to send read queries.
Lesson 218 — Lag-Aware Load Balancing
Latency
In distributed rate limiting, accuracy means precisely enforcing your quota (e.g., exactly 1000 requests per minute), while latency refers to how fast you can make the accept/reject decision.
Lesson 12 — Performance Requirements: Latency and ThroughputLesson 22 — Throughput vs LatencyLesson 985 — Trade-offs: Accuracy vs Latency
Latency reduction
A user in Tokyo accessing files stored in Tokyo sees sub-50ms retrieval times versus 200+ ms from a US data center.
Lesson 1626 — Geolocation-Based Storage
Layer 4
Layer 4 refers to the Transport Layer of the OSI networking model—where TCP and UDP protocols operate.
Lesson 109 — Layer 4 (Transport) Load Balancing
Lazy deletion
Instead of cleaning up expired keys synchronously, lazy deletion means you ignore expired counters when you encounter them but don't actively delete them during the request flow.
Lesson 1567 — Lazy vs Eager Deletion StrategiesLesson 1812 — Lazy Deletion and Background Cleanup
LCS
Better read performance, use when reads dominate and disk space is limited
Lesson 428 — Compaction Strategies
Leader
The active state. Only one leader exists per term. The leader handles all client requests, replicates log entries to followers, and sends regular heartbeats to prevent followers from starting new elections.
Lesson 619 — Server States: Leader, Follower, Candidate
Leader Completeness Property
The Leader Completeness Property is Raft's fundamental safety rule: if a log entry is committed in a given term, that entry will be present in the logs of all leaders for all higher-numbered terms.
Lesson 627 — Safety: Leader Completeness Property
Leader election
Leader election is the process of choosing a new leader from the surviving replicas, and failover is the orchestrated transition to that new leader.
Lesson 707 — In-Sync Replicas (ISR)Lesson 1366 — Leader Election and Failover
Leader-based replication
Like Raft, one server is the leader handling writes; followers replicate
Lesson 633 — ZooKeeper: Coordination Service Built on Consensus
leaf node
Each leaf node represents a hash of a data block (a range of keys)
Lesson 369 — Anti-Entropy and Merkle Trees
Length penalty
Standard UUIDs are 36 characters; even truncated versions need ~16-22 characters to maintain low collision probability
Lesson 1516 — Counter-Based vs UUID Approaches
Limited impact
If you have 8 shards and one fails, roughly 1/8 of users are affected
Lesson 266 — Shard Failure and Partial Outages
Limited scale
One data center's capacity is your ceiling
Lesson 1791 — Single Data Center vs Distributed Setup
Limited test requests
Limited test requests are permitted (often just one, or a small percentage)
Lesson 1047 — The Three States: Half-Open
Linearizability
Both sequential consistency and linearizability are strong consistency models, but they differ in one critical way: real-time guarantees.
Lesson 523 — Linearizability DefinedLesson 524 — Sequential Consistency vs Linearizability
Liveness
Eventually, a value will be chosen (assuming failures stop and the system stabilizes). This is an eventually property: given enough time and cooperation, progress happens.
Lesson 604 — Safety vs Liveness PropertiesLesson 609 — Paxos Safety and Liveness Guarantees
load balancer
A load balancer is a component that sits between clients (users) and your servers, distributing incoming requests across multiple backend servers.
Lesson 76 — What Is a Load Balancer?
Load Leveling
The queue acts as a shock absorber, smoothing out bursts of incoming messages so consumers can process them at a steady, sustainable rate.
Lesson 647 — Message Queue Basics
Load smoothing
Load smoothing means using a message queue as a buffer between producers (incoming requests) and consumers (processing services).
Lesson 649 — Load Smoothing and Backpressure
Localized logging
Localized logging means writing logs directly to disk on the server where your application runs.
Lesson 1169 — Centralized vs Localized Logging
Log Matching Property
The Log Matching Property is a crucial safety guarantee in Raft that ensures consistency across replicated logs.
Lesson 625 — Log Matching Property
Logging and analytics
Losing a few log entries during a crash is acceptable
Lesson 137 — Write-Behind: Risks and Use Cases
Logical shards
Logical shards are data partitions defined by ranges or hash buckets of your shard key—they exist as a concept independent of physical hardware.
Lesson 235 — Logical vs Physical Shards
logrus
logrus (Go) is one of the earliest and most popular structured logging libraries.
Lesson 1147 — Structured Logging Libraries
Logs
Metrics are the security camera snapshots showing "someone was here at 3 PM." Logs are the detailed witness statements with full context.
Lesson 1173 — Metrics vs Logs vs Traces
Loose coupling
Loose coupling means components don't know (or care) about each other's internal details.
Lesson 38 — Design for Change
Low coupling
Low coupling means services depend minimally on each other, communicating through well-defined interfaces rather than sharing internal details.
Lesson 818 — High Cohesion, Low Coupling in Service Design
Low Latency Priority
Results appear in milliseconds or seconds, not hours. The goal is fast reaction, not perfect completeness.
Lesson 737 — What is Stream Processing?

M

Machine-parseable
Machine-parseable means consistent field names, predictable types, and structured formats (JSON, structured text).
Lesson 1166 — Human-Readable vs Machine-Parseable
major
Think of SemVer as a traffic light: major is red (stop and refactor), minor is yellow (proceed with awareness), patch is green (no action needed).
Lesson 1906 — Semantic Versioning for APIs
Manual instrumentation
Manual instrumentation means you explicitly create spans in your code to track custom business logic, internal functions, or application-specific workflows that frameworks can't automatically detect.
Lesson 1224 — Automatic vs Manual Instrumentation
Max lifetime
The absolute maximum age of any connection before forced retirement and replacement. Database servers often close connections after a certain time; this setting proactively rotates them first.
Lesson 272 — Connection Timeouts and Limits
Maximum compactness
A counter of 1 billion encoded in Base62 is just 6 characters (15ftgG)
Lesson 1516 — Counter-Based vs UUID Approaches
measurement window
A measurement window is the time period over which you collect and combine SLI measurements.
Lesson 1274 — SLI Measurement Windows and Aggregation
Memcached
Redis and Memcached are the two most popular distributed cache stores:
Lesson 123 — Distributed Cache Layer (Redis/Memcached)
Memory exhaustion
The server must load all results into RAM simultaneously. A response with 1 million user records (each ~1KB) requires 1GB of memory per request. Under moderate load, your server runs out of memory and crashes.
Lesson 1887 — Why Pagination Is Essential at Scale
Memory limits
The URL Frontier, Bloom filters for deduplication, DNS cache, and robots.txt cache all compete for RAM. A single machine runs out quickly.
Lesson 1862 — Why Distribute a Web Crawler
Memory per server
The difference between 8 GB and 16 GB affects instance type selection
Lesson 32 — Rounding and Approximation Techniques
memtable
Memtable (In-Memory Buffer): Simultaneously, the write is also stored in an in-memory structure called a memtable.
Lesson 426 — Write Path and Commit Log
Message durability
Message durability means writing messages to disk storage before acknowledging receipt, ensuring they persist beyond memory and process failures.
Lesson 651 — Message Durability
message queue
A message queue is a data structure that stores messages from producing services and holds them until consuming services retrieve and process them.
Lesson 647 — Message Queue Basics
Metadata checks
Ensuring backup catalogs are complete and accurate
Lesson 1408 — Backup Verification and Testing
Metrics
Metrics are the security camera snapshots showing "someone was here at 3 PM." Logs are the detailed witness statements with full context.
Lesson 1173 — Metrics vs Logs vs Traces
min-heap
A min-heap is a binary tree where each parent node has a smaller value than its children.
Lesson 1847 — Heap-Based Priority Queue Implementation
Minimal Resource Footprint
The Linkerd proxy typically uses 10-20MB of memory per instance (compared to Envoy's 50-100MB), making it dramatically cheaper to run at scale.
Lesson 862 — Linkerd: Lightweight Service Mesh
minor
Think of SemVer as a traffic light: major is red (stop and refactor), minor is yellow (proceed with awareness), patch is green (no action needed).
Lesson 1906 — Semantic Versioning for APIs
MirrorMaker 2
MirrorMaker 2 (MM2) is Kafka's built-in tool for replicating topics between clusters.
Lesson 726 — Multi-Datacenter Replication
Miss rate
Miss rate is the opposite—requests that went to the backend.
Lesson 166 — Monitoring Cache Performance
modular monolith
A modular monolith is a single deployable application that's internally organized into well-defined, loosely-coupled modules with clear boundaries.
Lesson 790 — Modular Monoliths as Middle GroundLesson 825 — Starting with a Modular Monolith
Monitoring
Monitoring is the continuous observation of your system's health, performance, and behavior over time.
Lesson 1262 — What is Monitoring and Why It Matters
Monitoring complexity
Instead of watching one database's CPU, memory, disk I/O, and query performance, you must monitor all shards independently. One slow shard can degrade user experience for a subset of users, but detecting which shard is the culprit requires comprehensive observability across the entire fleet.
Lesson 264 — Operational Complexity of Sharded Systems
Monolithic Applications
A mesh is designed for inter-service communication. If you're running a monolith or modular monolith, there's nothing for it to manage—functions call each other in-process.
Lesson 835 — When You Don't Need a Service Mesh
monolithic architecture
A monolithic architecture is a traditional software design approach where your entire application—all its features, business logic, data access, and user interfaces—lives together in one unified codebase.
Lesson 779 — What is a Monolithic Architecture?
Monotonic Reads
Monotonic reads is a consistency guarantee that ensures: once you've read a particular value (or version) for a key, all subsequent reads will return that value or a newer one—never an older version.
Lesson 210 — Monotonic Reads GuaranteeLesson 535 — Monotonic Reads
Monotonic writes
Monotonic writes is a consistency guarantee stating that if a single client performs multiple write operations, those writes will be applied to all replicas in the same order they were issued.
Lesson 536 — Monotonic Writes
Multi-burn-rate
Multi-burn-rate means calculating how fast you're burning your error budget relative to your SLO target.
Lesson 1289 — Multi-Window and Multi-Burn-Rate Alerting
multi-CDN strategy
A multi-CDN strategy means routing traffic across two or more CDN providers simultaneously rather than relying on just one.
Lesson 196 — Multi-CDN Strategies
multi-level
Composite partitioning (also called multi-level or hybrid partitioning) means applying two or more partitioning strategies in sequence.
Lesson 1453 — Composite Partitioning
Multi-window
Multi-window means observing your error budget consumption across several time periods simultaneously (e.g., 1 hour, 6 hours, 3 days).
Lesson 1289 — Multi-Window and Multi-Burn-Rate Alerting

N

N+1 redundancy
N+1 redundancy means if you need N components to handle your workload, you provision N+1 — one extra.
Lesson 1333 — N+1 and N+2 Redundancy
N+2
Critical systems where even brief degradation is unacceptable, or where maintenance windows require taking components offline without impacting capacity.
Lesson 1333 — N+1 and N+2 Redundancy
Namespace Reuse
A 6-character base62 code gives you 56 billion combinations. Without expiration, you might exhaust this. With expiration, you recycle codes and can use shorter URLs.
Lesson 1504 — Link Expiration and Retention Policies
Namespacing
Namespacing means combining the idempotency key with additional scope identifiers to create a unique composite key:
Lesson 1017 — Idempotency Key Scope and Namespacing
Neither dominates
The writes were concurrent. Conflict detected!
Lesson 562 — Version Vectors and Conflict Detection
Netflix Conductor
Netflix Conductor is an orchestration engine that defines sagas as JSON workflows with tasks.
Lesson 598 — Saga Frameworks and Real-World Adoption
Network Bandwidth
The mesh control plane continuously pushes configuration updates to sidecars. Envoy proxies also collect detailed metrics on every request, generating significant observability data.
Lesson 834 — Service Mesh Performance Overhead
No boundary problem
A user can't exploit window edges to exceed limits (100 requests at 12:59:59, then 100 more at 13:00:00)
Lesson 968 — Sliding Window Log
No coordination overhead
No coordination overhead means no performance penalty for adding instances
Lesson 57 — Scaling Stateless Services Horizontally
No duplicate cross-service work
Each service processes the event exactly once (though retries within a service are possible)
Lesson 663 — Hybrid Patterns: Topic + Queue
No enduring value
the problem returns—fixing it once doesn't prevent future occurrences
Lesson 1311 — Toil: The Enemy of Scale
No health awareness
DNS doesn't know if a server is down; clients may receive IPs of failed servers
Lesson 116 — DNS-Based Load Balancing
No horizontal scaling
Adding servers means losing session data
Lesson 356 — Redis as a Session Store
No manual expiration needed
The algorithm self-adjusts based on actual access patterns
Lesson 1525 — Cache Eviction Policy for URL Shortener
No shared memory
No shared memory means no conflicts between instances
Lesson 57 — Scaling Stateless Services Horizontally
nodes
In consistent hashing, both keys (data items) and nodes (servers) are mapped to positions on a circular hash ring using the same hash function.
Lesson 1459 — Clockwise Key Assignment Rule
Non-functional
The system must handle 10 million daily users, load pages in under 2 seconds, store data reliably for 10 years, cost less than $X per month to operate
Lesson 9 — Functional vs Non-Functional: Core Distinction
Notification state tracking
Notification state tracking means storing each notification's lifecycle status in a database so you can monitor, debug, and audit your entire notification pipeline.
Lesson 1706 — Notification State Tracking
Notifications
Notifications are informational messages that provide awareness but don't require urgent response.
Lesson 1285 — Alert vs Notification

O

ObjectId
A 12-byte unique identifier MongoDB generates automatically for document _id fields
Lesson 390 — BSON Format and Data Types
Observability Integration
The mesh automatically emits metrics when timeouts fire, correlating them with service topology and request traces.
Lesson 1126 — Timeout Configuration in Service Mesh
offset
An offset is a unique sequential number assigned to each message within a partition.
Lesson 701 — Topics and PartitionsLesson 710 — Offsets and Commit Strategies
Open
Redis is down, all requests bypass Redis entirely
Lesson 1803 — Handling Redis Failures and Fallbacks
OpenTelemetry Logs
An emerging standard that unifies logs with traces and metrics, providing consistent correlation IDs and context propagation across your observability stack.
Lesson 1136 — Logging Libraries and Standards
Operations
Operations are basic: set a value, get a value, delete a value
Lesson 338 — What is a Key-Value Store?
operator
In Airflow, an operator is a template for a specific type of work.
Lesson 767 — Airflow Operators and Executors
Optimistic UI update
The client immediately shows your post in the feed (before server confirmation), then reconciles if the server response differs.
Lesson 1678 — Read-After-Write Consistency
Origin servers
Origin servers are your application's home base—they hold the original, authoritative version of your content (images, videos, JavaScript files, etc.).
Lesson 170 — CDN Architecture: Edge Servers and Origin
Origin Shield
Origin Shield is an additional caching layer positioned between your edge PoPs and your origin server.
Lesson 179 — Origin Shield: Protecting Origin ServersLesson 1614 — Origin Shield Pattern
orphaned records
You'd end up with orders pointing to a user that no longer exists—these are called orphaned records, and they cause data inconsistency.
Lesson 300 — Foreign Keys and Referential Integrity
overage buffer
An overage buffer is a small allowance added on top of each node's local rate limit to absorb temporary inconsistencies.
Lesson 986 — Local Rate Limiting with Overage Buffers

P

p95
95% of requests are faster than this (5% are slower)
Lesson 1188 — Percentiles and Tail Latencies
p99
99% of requests are faster than this (1% are slower)
Lesson 1188 — Percentiles and Tail Latencies
Panels
Panels are individual visualization blocks.
Lesson 1200 — Grafana for Metrics Visualization
parent node
Each parent node is a hash of its children's hashes
Lesson 369 — Anti-Entropy and Merkle Trees
partition key
In Cassandra, the partition key is the portion of your primary key that determines which node stores a particular row.
Lesson 421 — Partitioning with Partition Keys
Partition pruning
organizing data by time ranges so queries only scan relevant chunks
Lesson 760 — Data Warehouse Architecture
Partition quotas
Divide the 100 requests/minute into 40 for US, 30 for EU, 30 for Asia. Simple, but wastes capacity when traffic is uneven.
Lesson 1804 — Multi-Region Rate Limiting Challenges
Partition tolerance
Partition tolerance means your system continues to operate correctly despite these communication failures between nodes.
Lesson 486 — Partition Tolerance Explained
Partitioning
Partitioning is the general concept of dividing a dataset into smaller, more manageable pieces.
Lesson 70 — Partitioning and Replication TogetherLesson 1447 — Partitioning vs Sharding vs Replication
Passive health checks
Passive health checks are more observational—the load balancer watches actual user requests as they happen.
Lesson 99 — Active vs Passive Health Checks
patch
Think of SemVer as a traffic light: major is red (stop and refactor), minor is yellow (proceed with awareness), patch is green (no action needed).
Lesson 1906 — Semantic Versioning for APIs
Per-endpoint limits
The expensive /search endpoint allows 100 requests/minute, while /health is unlimited
Lesson 885 — Rate Limiting and Throttling
Per-key sequential consistency
Per-key sequential consistency means that all operations on a single key appear to execute in some sequential order that all clients agree on, but operations on different keys can be reordered independently.
Lesson 552 — Per-Key Sequential Consistency
Per-region quotas
Divide the global limit by number of regions (1000 req/min → 333/region). Simple but wastes capacity if traffic is uneven.
Lesson 987 — Multi-Region Rate Limiting Challenges
Per-shard metrics
Identify if specific database shards are slower
Lesson 1657 — Measuring Fanout Performance
Percentile analysis
If 99% of users make <100 req/min but your limit is 50, you're blocking normal behavior
Lesson 997 — Testing and Monitoring Rate Limiters
Perfect accuracy
Global limits are enforced precisely since all nodes see the same state
Lesson 979 — Centralized vs Decentralized Approaches
Performance
Aggressive invalidation means more cache misses, which defeats the purpose of caching.
Lesson 118 — SSL/TLS Termination at Load BalancersLesson 155 — Cache Invalidation Problem
Performance anomalies
Slow queries, timeout warnings, resource exhaustion signals. Log when thresholds are breached.
Lesson 1129 — What to Log vs What Not to Log
Performance benefits
Encryption/decryption is CPU-intensive. The gateway handles this once per request, rather than forcing every backend service to perform cryptographic operations. Services can focus on business logic.
Lesson 891 — SSL/TLS Termination
Performance penalty
Multi-partition transactions are 10-100x slower than single-partition operations
Lesson 1489 — Cross-Partition Transactions
Periodic polling
Every 30-60 seconds while app is active
Lesson 1671 — Real-Time Requirements for Social Feeds
Physical shards
Physical shards (or nodes) are the actual database servers that host those logical shards.
Lesson 235 — Logical vs Physical Shards
playbooks
Runbooks are step-by-step troubleshooting guides for specific incidents, while playbooks are broader response frameworks for classes of problems.
Lesson 1299 — Runbooks and Playbooks
politeness budget
A politeness budget is the allowance of resources (requests, bandwidth, time) your crawler may consume from a single host within a given time window.
Lesson 1842 — Politeness Budget and Crawl Delay
politeness table
A politeness table is an in-memory data structure that maintains crawling metadata for each host your crawler interacts with.
Lesson 1848 — Politeness Table and Per-Host State
Polyglot Persistence Pattern
The Polyglot Persistence Pattern means using different types of databases within a single application, rather than forcing all your data into one database system.
Lesson 327 — Polyglot Persistence Pattern
Poor Key Distribution
If your partition key is a timestamp and everyone writes at the current time, all writes hit one partition. Similarly, celebrity accounts in social media, trending hashtags, or popular products can concentrate load.
Lesson 1482 — The Hot Partition Problem
POST
Creates or appends. POST /orders might create a new order each time—run it twice, get two orders. This is the double-charge problem.
Lesson 1009 — HTTP Methods and Natural Idempotency
Postgres-Compatible SQL
You can use standard SQL queries, transactions, and tools. If you know Postgres, you largely know CockroachDB. This means minimal application code changes when migrating.
Lesson 334 — CockroachDB and Distributed SQL
posting list
A posting list is the data structure that stores all occurrences of a specific term across your document collection.
Lesson 1745 — Posting Lists and Document IDs
Pre-Generated Key Pools
Pre-Generated Key Pools means creating millions of keys in advance and storing them in a dedicated table.
Lesson 1551 — Key Generation Strategy
pre-signed URL
A pre-signed URL is a temporary, cryptographically signed URL that grants specific upload permissions to object storage (like S3 or Google Cloud Storage) without requiring the client to have storage credentials.
Lesson 1587 — Pre-Signed URLs for Direct Upload
Precomputed ranking
Precomputed ranking means maintaining a pre-sorted feed in storage.
Lesson 1667 — Real-Time vs Precomputed Ranking
Predictable latency
Dedicated hardware means consistent behavior
Lesson 108 — Hardware vs Software Load Balancers
Predictable read performance
Read latency is constant regardless of how many people a user follows.
Lesson 1646 — Fanout-on-Write (Push Model)
Prefetching
Prefetching means resolving DNS records before you actually need them.
Lesson 1858 — DNS Prefetching and Batch Resolution
Prepare Phase
In the Paxos two-phase protocol, the Prepare Phase is where a proposer tries to reserve the right to make a proposal.
Lesson 613 — The Prepare Phase
Primary connection pool
A set of pre-established database connections to the primary server, used exclusively for INSERT, UPDATE, DELETE operations
Lesson 221 — Application-Level Connection Management
primary key
A primary key is a column (or set of columns) that uniquely identifies each row in a table.
Lesson 299 — Primary Keys and Entity Integrity
producer
A producer is any application that publishes messages (events) to Kafka topics.
Lesson 702 — Producers and Message Publishing
producers
In event streaming platforms, producers are applications or services that write events to the stream (the commit log), while consumers are applications that read those events.
Lesson 694 — Producers and Consumers
Product catalogs
item descriptions rarely change instantly; eventual sync is fine
Lesson 318 — When to Choose ACID or BASE
Progressive Technology Adoption
Progressive Technology Adoption means you can introduce new tools, languages, or platforms incrementally by creating new microservices or refactoring individual services—while the rest of your system continues running unchanged.
Lesson 799 — Progressive Technology Adoption
Psychological safety
Psychological safety means people can admit errors without fear, knowing the team will analyze systems, not scapegoat individuals.
Lesson 1317 — Blameless Culture and Learning from Failure
Public marketing campaigns
URLs are meant to be shared anyway
Lesson 1515 — Short URL Predictability Tradeoffs
publisher
The publisher is like a newspaper company that produces content
Lesson 656 — Pub-Sub Pattern Fundamentals
Pull Model
A central collector periodically requests (scrapes) metrics from your application's exposed endpoint. This is like a mail carrier visiting your mailbox on a schedule—the collector decides when to gather data.
Lesson 1181 — Push vs Pull Collection ModelsLesson 1267 — Push vs Pull Monitoring Models

Q

Quality assurance
Bad data is rejected at write time
Lesson 759 — Schema-on-Write vs Schema-on-Read
query optimizer
The query optimizer is your database's smart assistant.
Lesson 307 — Indexes and Query Optimization
Queue depth
The number of items waiting to be processed fluctuates constantly
Lesson 1184 — Gauge Metrics
Queue Partitioning
Split your notification queue into multiple partitions (e.g., by user ID hash or notification type). Each partition has dedicated workers, preventing one hot partition from blocking others. This is like having separate lanes for "express checkout" vs "full cart."
Lesson 1708 — Scalability and Horizontal Expansion
QUORUM
In distributed systems with replicas, a quorum is the minimum number of nodes that must agree on an operation before it's considered successful.
Lesson 425 — Tunable Consistency LevelsLesson 555 — What is a Quorum?Lesson 556 — Read and Write QuorumsLesson 605 — Quorums and Majority AgreementLesson 1361 — Quorum-Based Replication
quorum queues
Queue mirroring (now called quorum queues in modern RabbitMQ) replicates queue data across nodes, ensuring messages aren't lost when a node crashes.
Lesson 668 — RabbitMQ Clustering and High Availability
Quota sharding
Quota sharding means splitting the total allowed quota across your nodes.
Lesson 984 — Quota Sharding Across Nodes

R

RabbitMQ
RabbitMQ is a versatile broker built on the AMQP protocol.
Lesson 665 — Overview of Message Broker Landscape
Raft
Protocols like Paxos and Raft are battle-tested algorithms that provide this agreement.
Lesson 527 — Consensus and Strong Consistency
Random Selection
Round Robin and Random Selection are dead simple—minimal computation, easy to understand and debug.
Lesson 96 — Algorithm Selection Tradeoffs
random selection algorithm
The random selection algorithm is perhaps the simplest load balancing strategy: for each incoming request, the load balancer randomly picks one server from the pool.
Lesson 91 — Random Selection Algorithm
Range partitioning
Range partitioning is simpler to implement and operate.
Lesson 1481 — Range vs Directory Tradeoffs
Ranking signals
Ranking signals are measurable properties or metadata about posts and users that indicate how relevant or interesting a post might be.
Lesson 1666 — Ranking Signals and Features
read path
Think of it like a restaurant: the write path is the kitchen (preparation, quality control, storage), while the read path is the dining area and waitstaff (fast delivery, pleasant experience).
Lesson 1548 — Read vs Write Path Architecture
Read replicas
Read replicas are synchronized copies of your primary database that handle read-only operations, allowing you to horizontally scale retrieval capacity.
Lesson 1522 — Read-Heavy Workload and Database ScalingLesson 1561 — Read Replicas for Retrieval Scaling
Real-time ranking
Real-time ranking means running your ranking model every time a user requests their feed.
Lesson 1667 — Real-Time vs Precomputed Ranking
Recency
For news or time-sensitive queries, newer documents should rank higher. A 2024 article about "AI trends" is more relevant than a 2010 piece.
Lesson 1755 — Relevance Tuning: Boosting and Signals
Redis Sentinel
Redis Sentinel is a separate process (or cluster of processes) that acts as a watchdog for your Redis deployment.
Lesson 353 — Redis Sentinel for High Availability
Reduce configuration surface area
Every config flag is a potential production incident
Lesson 1315 — Simplicity as a Core Value
Reduced availability
If any replica is down, writes may fail or block
Lesson 1355 — Synchronous Replication: Guarantees and Costs
Reduced replication lag risk
At least one replica is guaranteed up-to-date
Lesson 217 — Semi-Synchronous Replication Trade-offs
Reduced risk
A bad deployment affects only one service, not everything
Lesson 786 — Independent Deployability of Microservices
Reduces leader load
The root node handles far fewer replication connections
Lesson 1374 — Tree Replication Topology
Reference counting
Reference counting is critical: only delete the physical file when all metadata references are gone.
Lesson 1622 — Deduplication Strategies
Referencing
Referencing means storing only an ID pointer to another document—like storing a customer ID in an order and fetching customer details separately.
Lesson 292 — Embedding vs Referencing in Documents
Referential integrity
Referential integrity is the guarantee that relationships between tables remain valid.
Lesson 300 — Foreign Keys and Referential Integrity
Refresh Token
A long-lived credential (days to months) that you use only to obtain new access tokens when the old ones expire
Lesson 926 — Access Tokens vs Refresh Tokens
region
A region is a contiguous range of rows from a table, sorted by row key.
Lesson 435 — HBase Regions and Region Servers
regions
HBase solves this by dividing tables into manageable chunks called regions and spreading them across multiple servers.
Lesson 435 — HBase Regions and Region Servers
RegionServer
A RegionServer is a worker node that hosts multiple regions.
Lesson 435 — HBase Regions and Region Servers
Regular posts
30 seconds to 2 minutes is typically acceptable
Lesson 1671 — Real-Time Requirements for Social Feeds
Reliability
Messages persist in the queue even if consumers are temporarily down
Lesson 646 — The Producer-Consumer Model
Reliability per service
If Service A is down, its queue holds messages until it recovers—Service B is unaffected
Lesson 663 — Hybrid Patterns: Topic + Queue
replica affinity
Sticky sessions (also called replica affinity) mean that once a user is assigned to a specific read replica, all their subsequent reads go to that same replica for the duration of their session.
Lesson 215 — Sticky Sessions and Replica Affinity
Replica processing time
Replicas must apply the changes they receive. If a replica is busy serving read queries or processing a large batch of updates, new changes queue up.
Lesson 208 — Replication Lag: What It Is and Why It Happens
Replica promotion
Replica promotion is the process of elevating one of your read replicas to become the new primary database when the original primary fails.
Lesson 207 — Replica Promotion and Failover Basics
replication lag
If you read from a replica right after writing to the primary, you might not see your recent write yet—this is called replication lag.
Lesson 71 — Single-Leader Replication ModelLesson 204 — Asynchronous Replication ExplainedLesson 208 — Replication Lag: What It Is and Why It HappensLesson 1358 — Replication Lag in Async Systems
Replication Strategy
You need to keep data synchronized across regions using either synchronous or asynchronous replication. Synchronous provides consistency but adds latency; asynchronous is faster but introduces replication lag and potential data loss (affecting your RPO).
Lesson 1435 — Multi-Region Architecture for DR
Request and Response Transformation
Request and Response Transformation is the gateway's ability to rewrite, reshape, and adapt messages bidirectionally.
Lesson 882 — Request and Response Transformation
resharding
This process is called resharding, and it involves migrating massive amounts of live data while your application continues running.
Lesson 258 — Resharding and Data Migration
Resilience Improves Dramatically
If one gateway instance crashes, requests simply flow to healthy instances. No sessions are lost, no users are logged out, no context disappears. The system self-heals automatically.
Lesson 878 — Stateless Gateway Design
Resilience4j
Resilience4j is the lightweight, modern successor.
Lesson 1075 — Implementing Bulkheads in Practice: Hystrix and Resilience4j
Resolvers
Resolvers are the implementation functions that fulfill that contract by actually fetching or manipulating data.
Lesson 1912 — GraphQL Schema and Resolvers
Resource blocking
The API server is tied up during the entire fanout process
Lesson 1651 — Asynchronous Fanout Processing
Resource constraints
Reduce sampling if storage or processing capacity is stressed
Lesson 1255 — Adaptive Sampling
Retry amplification
Clients retry after timeout, but the original request is still processing, doubling the load
Lesson 1096 — Why Timeouts Must Propagate
retry budget
A retry budget is a cap on the percentage of requests that can be retried within a time window.
Lesson 1029 — Retry Budgets and Rate Limiting
reusability
In microservices architecture, reusability means creating services that solve one problem so well they can be used by multiple products or features.
Lesson 800 — Reusability and Composability
reverse proxy
A reverse proxy is primarily a traffic forwarder.
Lesson 872 — API Gateway vs Reverse Proxy
Risk
If your consumer crashes mid-processing, the message is already gone from the queue—message loss occurs.
Lesson 683 — Consumer Acknowledgment Timing
Root cause analysis
The underlying system or process failures (often multiple contributing factors)
Lesson 1127 — What is Logging and Why It MattersLesson 1350 — What is a Postmortem?
root hash
The root hash represents the entire dataset
Lesson 369 — Anti-Entropy and Merkle Trees
root span
The root span is the first span created for a new request, marking the beginning of the trace's hierarchy.
Lesson 1232 — Span Relationships and HierarchyLesson 1239 — Root Span and Entry Points
Round Robin
Round Robin is perfectly fair for identical servers.
Lesson 96 — Algorithm Selection Tradeoffs
row key
In a wide-column store like Cassandra or HBase, the row key is not just a unique identifier—it's the most critical design decision you'll make.
Lesson 413 — Row Keys and Clustering
RPO Zero
RPO Zero means that your Recovery Point Objective is literally zero — you cannot afford to lose any data, not even one millisecond's worth of writes.
Lesson 1414 — RPO Zero: Synchronous Replication
runbook
A runbook is a detailed, step-by-step playbook that documents exactly how to respond to specific failure scenarios—like a database outage, region failure, or data corruption event.
Lesson 1441 — Runbooks and Automation
Runbooks
Runbooks are step-by-step troubleshooting guides for specific incidents, while playbooks are broader response frameworks for classes of problems.
Lesson 1299 — Runbooks and Playbooks

S

Safety
Only one value can ever be chosen. Once a value is decided, it remains decided forever—no contradictions, no changing minds. This is an always property: it must hold even if the network fails, nodes crash, or messages are delayed indefinitely.
Lesson 604 — Safety vs Liveness PropertiesLesson 609 — Paxos Safety and Liveness Guarantees
saga
A saga is a sequence of local transactions where each step is a separate, independent transaction that commits immediately.
Lesson 588 — The Saga Pattern: Motivation and Definition
Sampling
Sampling means intentionally recording only a subset of these verbose logs (say, 1% or 0.1%), while still logging all errors and warnings at full rate.
Lesson 1157 — Log Sampling and FilteringLesson 1164 — Sampling for High-Volume LogsLesson 1252 — Sampling Strategies Overview
Saturation
The degree to which the resource has extra work queued (e.g., run queue depth)
Lesson 1189 — The USE Method
Scalability
The platform must scale horizontally—add more brokers to handle more throughput, more topics for isolation, and more partitions for parallelism. Growing from thousands to billions of events per day shouldn't require architecture changes.
Lesson 699 — Event Streaming Platform Requirements
Scalability bottleneck
The directory can become a performance choke point
Lesson 242 — Directory-Based Sharding
Scalability limits
More nodes means more coordination overhead
Lesson 526 — The Cost of Strong Consistency
Scheduled maintenance
Scheduled maintenance is planned downtime where you intentionally take systems offline for upgrades, patches, or infrastructure changes.
Lesson 1328 — Scheduled Maintenance and Availability Accounting
schema registry
A schema registry is a centralized service that stores and validates message schemas (data formats).
Lesson 725 — Schema Registry and Evolution
Schema-on-Write
Schema-on-Write is the traditional data warehouse approach.
Lesson 759 — Schema-on-Write vs Schema-on-Read
Scope
Local cache is instance-specific; distributed cache is shared across all instances
Lesson 143 — Multi-Tier Caching Pattern
Scopes
Scopes are string identifiers that represent specific permissions.
Lesson 930 — OAuth2 Scopes and Consent
Scrape Interval Matters
Most monitoring systems (like Prometheus) scrape metrics periodically. A 15-second scrape interval means you calculate rates over 15-second windows. Shorter intervals give more granular rates but increase overhead.
Lesson 1187 — Rate Calculations from Counters
search engine
A search engine is a system that indexes large volumes of documents (web pages, product listings, social posts, emails) and allows users to quickly retrieve the most relevant results based on text queries.
Lesson 1730 — What is a Search Engine?
Seed URLs
Seed URLs are the initial set of web addresses you feed into your crawler before it discovers anything on its own.
Lesson 1828 — Seed URLs and Starting Point
Selective push
Selective push means making smart choices about who gets what updates when, based on user activity, relationship strength, and content importance.
Lesson 1677 — Selective Push Strategies
Self-hosted vs managed
Self-hosted vs managed is your first decision.
Lesson 735 — Choosing a Streaming Platform
Server-side
Server-side means the service itself enforces limits by tracking requests and rejecting those that exceed thresholds.
Lesson 1789 — Client-Side vs Server-Side Rate Limiting
Server-side enforcement
Server-side enforcement is critical when:
Lesson 1123 — Client-Side vs Server-Side Timeout Enforcement
Server-side timeout
The maximum time a server allows itself to process a request before abandoning work
Lesson 1090 — Client-Side vs Server-Side Timeouts
serving layer
The serving layer is where these two worlds meet to answer user queries.
Lesson 750 — Lambda Architecture: Serving Layer
session affinity
Sticky sessions (also called session affinity) solve this by configuring your load balancer to remember which server initially handled a user's request.
Lesson 60 — Sticky Sessions and Load Balancer Affinity
Shallow checks
Shallow checks are fast, lightweight, and won't overload your infrastructure.
Lesson 102 — Shallow vs Deep Health Checks
shard key
The shard key (or partition key) is the database column or attribute you use to decide which shard will store each row.
Lesson 232 — Shard Key SelectionLesson 243 — Geo-Based ShardingLesson 249 — Time-Based Sharding
shard map
A shard map is essentially a directory or lookup table that tracks which shard key values live on which physical shard.
Lesson 236 — Shard Mapping and Routing
sharding
Data partitioning (also called sharding) is the technique of splitting a large dataset into smaller, independent pieces distributed across multiple servers.
Lesson 65 — What is Data Partitioning?Lesson 1150 — The ELK Stack: ElasticsearchLesson 1446 — What is Data Partitioning?Lesson 1447 — Partitioning vs Sharding vs ReplicationLesson 1815 — Sharding Rate Limit Data Across Redis Instances
shards
Sharding (also called horizontal partitioning) means dividing your database into smaller, independent pieces called shards, with each shard living on a separate server.
Lesson 229 — What is Sharding?
Short circuit
A dangerous direct path allowing excessive current flow
Lesson 1044 — The Electrical Analogy
sidecar proxy
In the service mesh architecture, a sidecar proxy is a small network proxy deployed alongside each service instance—like a companion container in the same pod (in Kubernetes terms).
Lesson 828 — The Sidecar Proxy Pattern
signed URL
A signed URL is a temporary, cryptographically secured link that grants access to a specific resource.
Lesson 1627 — Access Control and Signed URLs
Simple architectures
A monolith or 2-3 service systems rarely need full tracing. Structured logs with correlation IDs plus RED metrics (Rate, Errors, Duration) provide sufficient observability at far lower cost.
Lesson 1260 — Cost-Benefit Analysis
Simple hash-based
Simple hash-based is easiest to implement and understand
Lesson 253 — Evaluating Sharding Strategy Tradeoffs
Simple reasoning
The linear structure makes it easier to reason about ordering and consistency
Lesson 1362 — Chain Replication
Simple request-response
The operation is fast and unlikely to fail
Lesson 654 — When to Use Async vs Sync
Simpler broker design
The platform doesn't need complex flow control
Lesson 697 — Push vs Pull Consumption Models
Simpler implementation
A recursive approach with a stack is often easier to code
Lesson 1830 — Breadth-First vs Depth-First Crawling
Single Codebase
All functionality exists in one repository. User authentication, payment processing, inventory management—everything is interconnected in the same code structure.
Lesson 779 — What is a Monolithic Architecture?
Single point of failure
The directory itself must be highly available
Lesson 242 — Directory-Based Sharding
Single point of write coordination
The leader serializes all writes to its partition, ensuring consistent ordering
Lesson 706 — Leaders and Followers
Single-system image
The distributed database behaves as if it's one atomic system
Lesson 484 — Consistency in CAP Context
SLO setting
MTBF informs realistic availability targets (remember: availability and reliability are different but related)
Lesson 1323 — Mean Time Between Failures (MTBF)
Slow Query Logs
Slow Query Logs are built into most databases (MySQL, PostgreSQL, etc.).
Lesson 287 — Monitoring Slow Queries
Slow response times
The user waits while thousands (or millions) of feeds update
Lesson 1651 — Asynchronous Fanout Processing
Small Deployments
If you have 3-5 microservices, manually configuring communication is straightforward. The overhead of deploying, monitoring, and maintaining sidecar proxies across every service outweighs the benefit.
Lesson 835 — When You Don't Need a Service Mesh
snapshot
A snapshot is a point-in-time image of your storage system that appears to capture the entire state instantly, but actually uses clever tricks to avoid copying all data immediately.
Lesson 1426 — Snapshot-Based Backups
Snapshots
Snapshots are instantaneous, space-efficient copies of data at a specific moment.
Lesson 1401 — Backup vs Replication vs Snapshots
Snapshotting
Snapshotting is Raft's log compaction mechanism.
Lesson 632 — Log Compaction: Snapshotting
Social media feed
If image processing is down, display low-resolution thumbnails or placeholders rather than blocking the entire feed
Lesson 1336 — Graceful Degradation
Social media metrics
If a "like" counter is temporarily off, it's not catastrophic
Lesson 137 — Write-Behind: Risks and Use Cases
Soft State
In the BASE model (which you learned in the previous lessons), Soft State means that the system's state may change over time even without new input, as replicas synchronize and updates propagate.
Lesson 316 — Soft State and Eventual Consistency
Sorted arrays
Insertion is O(n) — too slow when millions of URLs arrive.
Lesson 1847 — Heap-Based Priority Queue Implementation
span
Each span is one runner's segment—when they received the baton, when they passed it, and how long they ran.
Lesson 855 — Observability: Distributed TracingLesson 1221 — Traces, Spans, and Parent-Child Relationships
span events
While a span represents a unit of work with a start and end time, span events are timestamped snapshots of interesting moments within that span.
Lesson 1226 — Span Events and Logs
Span ID
A unique identifier for each individual operation or span within the trace. Every API call, database query, or processing step gets its own span ID. Example: 7b2e3f9a
Lesson 1230 — Trace Context Fundamentals
span logs
While a span represents a unit of work with a start and end time, span events (also called span logs) let you record specific moments within that work.
Lesson 1234 — Span Events and Logs
Speed
Sessions live in memory, so lookups are microsecond-fast—critical when every HTTP request needs session data.
Lesson 356 — Redis as a Session Store
split points
You define boundary values called split points.
Lesson 1471 — Range Partitioning Fundamentals
Splunk
While the ELK stack and Grafana Loki offer open-source logging solutions, Splunk is an enterprise-grade, proprietary platform built specifically for machine-generated data at massive scale.
Lesson 1154 — Alternative: Splunk Architecture
SSTable
An SSTable is a persistent, immutable file containing sorted key-value pairs.
Lesson 446 — SSTable and GFS Dependencies
Stack trace
The call chain showing exactly which line of code threw the error and how execution reached it. This is your breadcrumb trail.
Lesson 1142 — Logging Exceptions and Stack Traces
Star Schema
Star Schema is the simplest: one central fact table surrounded by dimension tables, like planets around a sun.
Lesson 760 — Data Warehouse Architecture
State Synchronization
The backup must have up-to-date state—often achieved through replication or shared storage—so users don't lose data mid-failover.
Lesson 1335 — Failover Mechanisms
Stateful interactions
The bug might only appear with specific data flowing through the system
Lesson 807 — Debugging and Troubleshooting
Stateless services
Stateless services are ideal candidates for horizontal scaling.
Lesson 51 — When to Choose Horizontal Scaling
stateless workers
In a distributed web crawler, stateless workers are processing units that don't store any persistent state locally.
Lesson 1864 — Stateless Worker Design
statement limits
Query timeouts and statement limits are safety mechanisms that prevent individual queries from consuming excessive resources.
Lesson 285 — Query Timeout and Statement Limits
Static assets
Static assets are files that remain the same for all users and don't change on every request.
Lesson 173 — Content Types Suited for CDNs
Static sizing pain
Pre-allocating 50 threads per bulkhead when average usage is 5 wastes memory
Lesson 1076 — Bulkhead Tradeoffs: Complexity and Resource Overhead
sticky sessions
Session affinity, often called sticky sessions, is a load balancing strategy that ensures all requests from a specific client always go to the same backend server.
Lesson 94 — Session Affinity (Sticky Sessions)
Storage costs
Longer retention means more keys in your database or cache
Lesson 1012 — Idempotency Key Expiration Strategy
storage engine
A storage engine is the underlying component that manages how data is physically written to and read from disk.
Lesson 400 — Storage Engines: WiredTiger
Storage growth
2.3 TB/day → 2-3 TB/day is perfectly fine
Lesson 32 — Rounding and Approximation Techniques
Storage Layer
A notifications table tracking unread status per user
Lesson 1585 — Upload Flow Architecture OverviewLesson 1687 — In-App Notifications
Storage tiering
Storage tiering means automatically moving data between different storage classes based on how frequently it's accessed, balancing performance and cost.
Lesson 1589 — Storage Tiering StrategyLesson 1620 — Storage Tiering for Cost Optimization
Strangler Fig Pattern
The Strangler Fig Pattern is named after a tropical plant that grows around a host tree, eventually replacing it.
Lesson 822 — The Strangler Fig Pattern for Migration
Stream processing
Stream processing is like instant messaging—every message arrives immediately, but requires constant connectivity and resources.
Lesson 746 — Choosing Batch vs Stream
Strict serializability
Strict serializability is the marriage of both: transactions execute in a serial order that respects real-time, meaning if transaction T1 commits before T2 begins in wall-clock time, T1 must appear before T2 in the serial order.
Lesson 525 — Strict Serializability
Strings
Strings are the most basic type—text or binary data stored as-is.
Lesson 341 — Data Types and Value Complexity
strong consistency
In relational databases (SQL databases like PostgreSQL, MySQL, Oracle), strong consistency means that once a transaction commits successfully, every subsequent read will see that new data immediately.
Lesson 308 — Strong Consistency by DefaultLesson 1362 — Chain Replication
Subscribers
Subscribers are readers who subscribe to that newspaper
Lesson 656 — Pub-Sub Pattern Fundamentals
summary tables
Aggregation tables (also called summary tables or rollup tables) store pre-computed metrics and summaries.
Lesson 294 — Aggregation Tables
Switchover Logic
Once failure is detected, the mechanism updates routing (DNS, load balancer configuration, virtual IP reassignment) to point traffic to the backup. In active-passive setups, the passive node may need to "warm up." In active-active, traffic just stops going to the failed node.
Lesson 1335 — Failover Mechanisms
Synchronous
The chef stops cooking, walks to the office, writes in the logbook, and returns. Reliable records, but service slows to a crawl.
Lesson 1134 — Synchronous vs Asynchronous Logging
Synchronous processing
Synchronous processing means the upload request waits until all operations complete—validation, virus scanning, thumbnail generation, and storage.
Lesson 1598 — Synchronous vs Asynchronous Processing
System Design
System Design is like being the architect who decides where the rooms go, how many bathrooms you need, and whether the foundation can support a second story.
Lesson 3 — System Design vs Coding

T

Tablet servers
Tablet servers are the workers that manage tablets.
Lesson 445 — Tablet Architecture and Distribution
tags
Span attributes (also called tags or labels) let you attach key-value metadata to spans, transforming them from skeletal timing information into rich, searchable debugging narratives.
Lesson 1225 — Span Attributes and Tags
targets
At its core, it periodically scrapes HTTP endpoints (called targets) to collect metrics, stores them locally, and makes them queryable via PromQL.
Lesson 1198 — Prometheus Architecture and Data Model
Task Distribution
A producer adds work items to the queue—image resize jobs, email sends, report generation, anything time-consuming. Workers continuously poll the queue, claiming tasks one at a time.
Lesson 659 — Queue Use Cases: Work Distribution
TaskManagers
TaskManagers are the worker nodes that execute the actual stream processing logic.
Lesson 770 — Apache Flink Architecture
TCP Optimization
The edge server is geographically close to you, so the initial TCP connection completes quickly. The longer origin connection benefits from TCP window scaling and congestion control tuning.
Lesson 186 — Dynamic Content Acceleration
team autonomy
In a microservices architecture, team autonomy means each small team owns one or more services completely—from writing code to deploying, monitoring, and fixing production issues.
Lesson 794 — Team Autonomy and Ownership
Technology Heterogeneity
Technology Heterogeneity means different services in your system can use entirely different programming languages, frameworks, databases, and tools—whatever works best for that specific job.
Lesson 792 — Technology Heterogeneity
Technology Lock-In
The entire system typically uses one language and framework. You can't experiment with better tools for specific problems or adopt new technologies incrementally.
Lesson 785 — When Monoliths Become Problematic
Temporal
Temporal is a workflow orchestration platform that treats long-running sagas as durable workflows.
Lesson 598 — Saga Frameworks and Real-World Adoption
Temporal data
For time-series data, sorting by created_at DESC is common and should have an index on created_at
Lesson 1895 — Default Sorting and Index Alignment
Tenant isolation
Tenant isolation is enforced through namespaces and authorization rules
Lesson 860 — Multi-Cluster and Multi-Tenancy
terms
In Raft, time is divided into sequential periods called terms.
Lesson 620 — Terms: Logical Time in Raft
Testing alerts
Testing alerts means deliberately triggering conditions that should generate alerts, verifying they reach the right people, and confirming responders know how to act.
Lesson 1295 — Testing Alerts and Dry Runs
They're hard to trace
The root cause may be buried under layers of dependent failures
Lesson 1077 — What is a Cascading Failure
Think of it like a restaurant
The waiter (API) takes orders and pins them to the kitchen board (queue) immediately, then serves other customers. The kitchen (workers) processes orders as they can, without the waiter waiting around or customers backing up at the counter.
Lesson 1698 — Message Queue for Decoupling
Thread pool bulkhead per dependency
Even if payment threads are exhausted waiting for timeouts, notification and recommendation threads remain available
Lesson 1085 — Preventing Cascades with Circuit Breakers and Bulkheads
Throughput
Throughput is how many requests the system can handle in a given time period — usually expressed as requests per second (RPS) or queries per second (QPS).
Lesson 12 — Performance Requirements: Latency and ThroughputLesson 22 — Throughput vs Latency
Thumbnails
Thumbnails are scaled-down versions of images (e.g., 200×200 pixels) that load instantly, while previews might be larger (1024×768) for lightbox views or video posters.
Lesson 1624 — Thumbnail and Preview Generation
Tiered rate limiting
Tiered rate limiting means assigning different rate limit policies based on user class—typically determined by subscription level, authentication status, or organizational size.
Lesson 990 — Tiered Rate Limits for Different User Classes
tiered storage
Older timeline entries can move to slower, cheaper storage—a pattern called tiered storage.
Lesson 1659 — Timeline Storage Requirements
Tight Coupling
Components become tangled together. Changing one module unexpectedly breaks others. Teams fear touching unfamiliar code because the blast radius is unpredictable.
Lesson 785 — When Monoliths Become Problematic
time series
A time series is a sequence of data points indexed by time.
Lesson 1180 — Time Series Data Model
Time-based row keys
Time-based row keys are the secret weapon.
Lesson 418 — Time-Series and Time-Ordered Data
timeout
A timeout is a relative duration: "wait up to 5 seconds." A deadline is an absolute timestamp: "must complete by 14:32:15.500 UTC."
Lesson 1086 — What Timeouts Are and Why They MatterLesson 1108 — What is Deadline Propagation
Timeout budget management
Timeout budget management means intelligently dividing the remaining time among all downstream dependencies so every hop has a realistic chance to succeed.
Lesson 1119 — Timeout Budget Management Across Service Chains
Timeout Distribution by Endpoint
Different operations have different normal timeout rates. Your /healthcheck endpoint timing out is more alarming than a complex analytics query occasionally timing out.
Lesson 1124 — Timeout Metrics and Anomaly Detection
Timeout Rate
The percentage of requests that time out. A sudden spike from 0.1% to 2% indicates something is wrong, even if most requests still succeed.
Lesson 1124 — Timeout Metrics and Anomaly Detection
Timeout testing and chaos engineering
Timeout testing and chaos engineering means intentionally breaking your system in controlled ways—injecting artificial delays, dropping packets, or simulating unresponsive dependencies—to validate that your timeout logic prevents cascading failures rather than contributing to them.
Lesson 1125 — Timeout Testing and Chaos Engineering
Toil
In SRE terminology, toil is manual, repetitive, automatable work that scales linearly with service growth.
Lesson 1288 — Alert Fatigue and ToilLesson 1311 — Toil: The Enemy of Scale
Token validation across regions
If you use JWT tokens, every region needs access to the same signing keys. If a key rotates in one region, all regions must learn about it quickly—but network partitions or delays can create windows where tokens are rejected incorrectly.
Lesson 952 — Cross-Region Authentication
Tokenization
Tokenization is the process of breaking raw text into standardized, searchable units called tokens.
Lesson 1744 — Building an Inverted Index: Tokenization
tokens
Break text into individual units called tokens (usually words).
Lesson 1733 — Document Processing Pipeline
Tombstones
Tombstones are deletion markers that accumulate when you frequently delete data.
Lesson 432 — Data Modeling Best Practices
Total order
All state changes are applied in the same order across all replicas
Lesson 633 — ZooKeeper: Coordination Service Built on Consensus
Trace context
Trace context is the set of identifiers that gets passed along with each request, enabling this linkage.
Lesson 1230 — Trace Context Fundamentals
Trace ID
A Trace ID is a globally unique identifier assigned to an entire request journey.
Lesson 1222 — Trace ID and Span IDLesson 1230 — Trace Context Fundamentals
Trace sampling
Trace sampling means intentionally recording only a subset of traces—say 1% or 0.1%—rather than capturing everything.
Lesson 1228 — Trace Sampling Fundamentals
Traces
Traces are the complete timeline tracking one suspect's journey through multiple locations.
Lesson 1173 — Metrics vs Logs vs Traces
Track client writes
The client remembers the timestamp/version of its last write and only reads from replicas caught up to at least that point.
Lesson 542 — Read-Your-Writes Consistency
Trade-off
Data is volatile. If Redis crashes, you lose all counters. Users might briefly exceed limits during recovery.
Lesson 589 — Saga Fundamentals: Local Transactions and CompensationsLesson 1807 — In-Memory vs Persistent Storage for Rate Limiting
Transactional semantics
Transactional semantics means coordinating database operations and message operations so they succeed or fail together, maintaining consistency.
Lesson 688 — Transactional Semantics
Transient errors
Transient errors are temporary hiccups that might succeed if you try again:
Lesson 1026 — Retry on Which Errors
transient failures
These problems are called transient failures — temporary hiccups that resolve themselves within seconds or milliseconds.
Lesson 1020 — Why Retries Are Necessary in Distributed Systems
Tunable consistency
Tunable consistency means you don't choose one consistency level for your entire database—you choose it per operation.
Lesson 563 — Tunable Consistency in Practice

U

Unbounded convergence
Unbounded convergence means the system will converge, but provides no upper limit on how long it takes.
Lesson 533 — Convergence Guarantees
Uneven distribution
If traffic is imbalanced, some nodes may reject requests while others sit idle
Lesson 979 — Centralized vs Decentralized Approaches
Unified Runtime
The application runs as one process (or a few identical copies for scaling). All components share the same memory, dependencies, and resources.
Lesson 779 — What is a Monolithic Architecture?
Uniform load distribution
Uniform load distribution is the primary benefit.
Lesson 1450 — Hash-Based Partitioning
Unsorted queues
Finding the minimum is O(n) — unacceptable per fetch.
Lesson 1847 — Heap-Based Priority Queue Implementation
Upload Service
The workhorse layer. These servers receive the actual file data, perform preprocessing (virus scanning, format validation, metadata extraction), and orchestrate the storage process. They may generate unique file identifiers, create thumbnails on-the-fly, or split large videos into chunks for parallel processing.
Lesson 1585 — Upload Flow Architecture Overview
Uptime
Uptime is the actual duration your system was available during a measurement period.
Lesson 1318 — Defining Availability and Uptime
URL frontier
The URL frontier is the central queue (or collection of queues) in a web crawler that stores all discovered URLs waiting to be crawled.
Lesson 1838 — URL Frontier: Definition and Purpose
User preferences
Users who ignore SMS waste money; push notification fans are cheaper to reach
Lesson 1694 — Channel Costs and Economics
User-specified language
User-specified language is simpler: let users tag their paste explicitly.
Lesson 1575 — Syntax Highlighting and Language Detection
Users don't notice
The difference between 99.99% and 99.999% is 4 minutes per month—often imperceptible
Lesson 1310 — Embracing Risk: The 100% Availability Trap
Users expect responsiveness
a loading spinner that never completes is worse than slightly stale data
Lesson 532 — Why Eventual Consistency Exists
Utilization
Percent of time the disk is servicing requests (from counter metrics)
Lesson 1189 — The USE Method

V

version vector
A version vector is a data structure where each replica maintains a counter for every replica in the system.
Lesson 1382 — Version Vectors and Causality
Versioning
Versioning is the practice of explicitly marking API changes, and backward compatibility means new versions still support old clients.
Lesson 809 — Versioning and Backward Compatibility
Vertical Partitioning
Vertical Partitioning means splitting your table by columns.
Lesson 231 — Vertical Partitioning vs Horizontal Partitioning

W

Warehouses
Compression is balanced with indexing and columnar organization for fast scans. Storage costs more, but queries run 10-100x faster.
Lesson 763 — Cost and Storage Efficiency
waterfall diagram
The waterfall diagram is the primary trace visualization.
Lesson 1248 — Trace Visualization and UI
When combined with authentication
The short URL just redirects; actual access requires login
Lesson 1515 — Short URL Predictability Tradeoffs
When to use
Critical workflows where losing messages is unacceptable (payments, orders, important state changes). Pair with idempotent operations to handle potential duplicates.
Lesson 683 — Consumer Acknowledgment Timing
Whisper
The fixed-size database format that stores time-series data on disk
Lesson 1202 — Graphite Time-Series Database
wide-column store
A wide-column store is a type of NoSQL database that organizes data into rows and columns, but with a crucial twist: each row can have a different set of columns.
Lesson 410 — What is a Wide-Column Store?
Windowing
Since streams are infinite, you often analyze chunks of time (e.g., "events in the last 5 minutes") rather than "all events ever."
Lesson 737 — What is Stream Processing?
write-ahead log
A write-ahead log is a durable record written to disk before performing any action.
Lesson 574 — Recovery Protocols and Logs
Write-Back
In the Write-Behind (also called Write-Back) pattern, writes are immediately accepted by the cache and acknowledged to the client before being persisted to the database.
Lesson 136 — Write-Behind (Write-Back) Caching Pattern

Z

zap
zap (Go) is Uber's high-performance alternative to logrus.
Lesson 1147 — Structured Logging Libraries
Zipkin wins on simplicity
single binary deployment works for many use cases. Jaeger wins on scalability: its separated components (agent, collector, query) provide better horizontal scaling and fault isolation for large-scale systems. Zipkin's monolithic option means one failure point affects everything; Jaeger's architecture isolates failures better.
Lesson 1242 — Zipkin Architecture and Design
Zookeeper
Zookeeper is another PC/EC system, essential for distributed locking where correctness trumps speed.
Lesson 521 — PACELC Tradeoffs in Real Systems