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
- attributes
- In distributed tracing, tags (also called attributes) are key-value pairs attached to spans.
- Lesson 1233 — Span Tags and Attributes
- 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
- Cardinality
- Cardinality is the number of unique label combinations (time series) a metric creates.
- Lesson 1178 — Metric Cardinality and LabelsLesson 1203 — InfluxDB and Time-Series DatabasesLesson 1258 — Cardinality ExplosionLesson 1269 — Time Series Databases for MetricsLesson 1491 — Data Skew and Cardinality Issues
- 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
- 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?
- 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
- 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?
- Eventual consistency
- In Dynamo's design, eventual consistency means that after a write, not all replicas are immediately synchronized—different nodes may temporarily hold different versions of the same data.
- Lesson 15 — Consistency Requirements and TradeoffsLesson 316 — Soft State and Eventual ConsistencyLesson 377 — Eventual Consistency and Application ReconciliationLesson 512 — Social Media: Availability Over ConsistencyLesson 531 — What is Eventual Consistency?Lesson 585 — Alternative: Saga Pattern Introduction
- 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
- failover
- Dead servers are bypassed automatically
- Lesson 1366 — Leader Election and FailoverLesson 1437 — Failover and Failback ProceduresLesson 1616 — Geographic Routing and DNS
- 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 recovery
- Restoring from snapshots is much quicker than traditional backups
- Lesson 446 — SSTable and GFS DependenciesLesson 730 — Apache Pulsar ArchitectureLesson 1426 — Snapshot-Based Backups
- Faster iteration
- Refactoring across service boundaries is painful; refactoring within one codebase is straightforward
- Lesson 820 — When a Monolith is the Right Choice
- 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
- 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
- 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 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
- Local memory lookups are faster than network calls
- Lesson 699 — Event Streaming Platform RequirementsLesson 979 — Centralized vs Decentralized Approaches
- 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 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
- 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
- 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
- In a distributed wide-column store like Cassandra, replication means storing multiple copies of each piece of data on different nodes.
- Lesson 70 — Partitioning and Replication TogetherLesson 360 — What Makes a Key-Value Store DistributedLesson 364 — Replication in Distributed Key-Value StoresLesson 424 — Replication Strategy and FactorLesson 1447 — Partitioning vs Sharding vs Replication
- 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 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
- topic
- A topic is a logical channel or category for organizing events.
- Lesson 656 — Pub-Sub Pattern FundamentalsLesson 700 — Kafka Overview and Core ComponentsLesson 701 — Topics and Partitions
- Total order
- All state changes are applied in the same order across all replicas
- Lesson 633 — ZooKeeper: Coordination Service Built on Consensus
- trace
- The trace is the entire race from start to finish.
- Lesson 855 — Observability: Distributed TracingLesson 1219 — What is Distributed Tracing?Lesson 1221 — Traces, Spans, and Parent-Child Relationships
- 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
- vector clock
- A vector clock is a simple data structure where each replica maintains a counter for every other replica in the system:
- Lesson 367 — Vector Clocks and Conflict DetectionLesson 374 — Vector Clocks for Conflict DetectionLesson 548 — Causal Consistency ImplementationLesson 1396 — Implementing Consistency with Vector Clocks
- 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