Glossary

912 technical terms from the course, one definition each. Linked terms in lessons open the same definition in place.

.

.dockerignoreContainers: A file listing paths to exclude from the build context, such as node_modules, .git and .env files. Keeps builds fast and secrets out of images.Build context
.gitignoreDevOps: A file listing paths git must never track, such as .env files with secrets, build output and dependency folders.Env file Secret scanning

1

12-factor appDevOps: A widely used set of practices for cloud services: config in environment variables, stateless disposable processes, backing services as attached resources, logs as event streams.Stateless Graceful shutdown

2

2PCTwo-phase commitDistributed systems: A protocol where a coordinator asks every participant to 'prepare' (lock and promise), then tells all to commit or all to abort. Atomic, but blocking and fragile across services.Transaction Saga

3

3-2-1 backup ruleReliability: Keep at least 3 copies of data, on 2 different kinds of storage, with 1 copy off-site (today often: another region or account).Immutable backup

A

A/B testProduct engineering: Sending a random share of real traffic to variant B and the rest to A, then comparing a business or quality metric.Eval
ABACAttribute-Based Access ControlSecurity: Decisions computed from attributes of the user, the resource, the action and the context (e.g. same hotel, during the shift, amount up to €100).RBAC ReBAC
AbstentionRAG & embeddings: A model or system deliberately declining to answer ("I can't find that in our policies") because the evidence is missing or too weak. A designed outcome, not a failure.Groundedness Hallucination
Acceptance criteriaBuilding with AI: Concrete, testable statements of when a change is done, often written as Given / When / Then. If you can't check it, it isn't a criterion.Spec (feature specification)Unit test
Acceptance testTesting: A test written from the requirement, not from the code: given this situation, when the user does this, the result must be that. If it passes, the feature does what was asked.Given / When / Then End-to-end (e2e) test
Access tokenSecurity: A short-lived credential (often minutes) presented on each API request, typically as `Authorization: Bearer …`.Refresh token JWT
Accessibility (a11y)Frontend: Building products that people with disabilities (visual, motor, hearing, cognitive) can perceive, operate and understand. "a11y" = a + 11 letters + y.WCAG Semantic HTML
Accessibility treeFrontend: A browser-built parallel of the DOM exposing each element's role, name and state to assistive technology.Semantic HTML Screen reader
ACIDAtomicity, Consistency, Isolation, DurabilityDatabases: The guarantees a database transaction gives: all-or-nothing, rules kept, no interference, and survives crashes.Transaction
Active-activeReliability: Several copies serve traffic at the same time. Failure just shifts load, but writes accepted in several places need conflict handling.Active-passive Multi-region
Active-passiveReliability: One copy serves traffic while a standby waits to take over. Simple and consistent, but the standby is idle capacity and failover takes time.Active-active Failover
AdapterArchitecture: Code that connects a port to a real technology: a Stripe adapter implements PaymentPort, an HTTP controller drives a use case. Swappable without touching the core.Port (hexagonal architecture)Hexagonal architecture
ADRArchitecture Decision RecordArchitecture: A short document recording a decision, its context, the alternatives and the trade-offs accepted.
Agent runtimeAgents & tools: The server-side program that runs an agent: it assembles context, calls the model, executes tools, enforces policies and budgets, persists run state and emits traces. The model is one dependency of it.AI agent AI gateway Step budget
Agent trajectoryAgents & tools: The full sequence of an agent run: model messages, tool calls with arguments, tool results and the final answer. Used for debugging and for evaluating how a task was done, not just whether.AI agent Distributed tracing
Agentic systemAgents & tools: A larger system where one or more agents act with some autonomy across multiple steps, tools and sometimes other agents.AI agent
AI agentAgents & tools: A system where a model runs in a loop: it decides on actions, calls tools, observes results, and continues until the goal is met.Tool calling Agentic system
AI coding agentBuilding with AI: A language model running in a loop with tools in your project: it reads files, edits them and runs commands until it thinks the task is done. It only knows what it has read.AI agent Claude Code Context window
AI gatewayAI infrastructure: A proxy in front of model providers: routing, fallbacks, rate limits, caching, token and cost tracking.Model routing
Alert fatigueObservability: When so many alerts fire (most not actionable) that on-call engineers start ignoring them, and miss the real one.On-call
ALIAS / apex flatteningNetworking: A provider-specific DNS feature that behaves like a CNAME at the zone apex: the DNS provider resolves the target itself and returns its IP addresses as A/AAAA records.CNAME record DNS record
AllowlistSecurity: An explicit list of what is permitted (tools, domains, recipients). Anything not on it is denied by default.Least privilege
ANNApproximate Nearest NeighbourRAG & embeddings: Search that finds vectors that are *almost certainly* among the closest, much faster than comparing against every vector.HNSW Vector database
Anti-corruption layerArchitecture: Your own interface and translation code around an external system, so the vendor's model and API don't leak into your domain and can be replaced in one place.Vendor lock-in Adapter
AnycastNetworking: Announcing the same IP address from many locations; internet routing delivers each packet to the nearest one. Used by DNS providers and CDNs.BGP CDN GeoDNS
APIApplication Programming InterfaceBackend: A contract that lets one program use another: which requests you can send and what you get back.REST Endpoint
API gatewayArchitecture: A reverse proxy specialised for APIs: one entry point that handles authentication, rate limiting, routing to services, request transformation and API keys.Reverse proxy Rate limiting L7 load balancer
API versioningBackend: Publishing breaking changes as a new version (e.g. /v2 or a version header) while keeping the old one running for existing clients until they migrate.API REST
APMApplication Performance MonitoringObservability: Tooling that instruments your services to record request latency, errors and traces automatically, so you can see which endpoint, query or dependency is slow in production.Distributed tracing Observability
Approval gateAgents & tools: A point in an agent run, enforced in code, where an action is paused until a human approves it. The model can request the action but cannot skip the gate.Human-in-the-loop Least privilege
Argon2Security: A modern password hashing function that is deliberately slow and memory-hard, making large-scale guessing on GPUs expensive. Argon2id is the usual recommended variant.Password hashing bcrypt
ARIAAccessible Rich Internet ApplicationsFrontend: HTML attributes (`role`, `aria-label`, `aria-expanded`…) that describe semantics to assistive technology. They change what is announced, not how anything behaves.
The first rule of ARIA: if a native HTML element already does the job, use it instead. ARIA used wrongly makes pages less accessible.
Semantic HTML Screen reader
ArrayProgramming: Items stored in order in contiguous memory. Reading by index is O(1); searching an unsorted array or inserting at the front is O(n).Hash map Big O
ASRAutomatic Speech RecognitionAI infrastructure: Converting spoken audio into text (speech-to-text). Streaming ASR emits partial transcripts while the person is still talking.TTS VAD
async/awaitProgramming: Syntax that lets you write promise-based code top to bottom: `await` pauses the async function (not the thread) until the promise settles.Promise Event loop
Asynchronous replicationDistributed systems: The leader acknowledges the write immediately and ships it to followers afterwards. Fast, but followers lag and the last writes can be lost on failover.Synchronous replication Replication lag
At-least-once deliveryDistributed systems: Every message is delivered, but possibly more than once (e.g. after a crash before commit). Consumers must be idempotent.Idempotency Kafka
Audit logSecurity: An append-only record of who did what, when, on whose behalf and with what result. For agents it records every tool call, its arguments, approvals and the content that was in context.Least privilege
AuthenticationSecurity: Verifying who a caller is, e.g. by checking a password, a session cookie or a signed token. Failure is HTTP 401.Authorization
Authoritative nameserverNetworking: The DNS server that holds the real records for a domain (e.g. the A record for www.example.com). Every other answer is a cached copy of what it said.DNS DNS resolver TTL (DNS)
AuthorizationSecurity: Deciding whether an authenticated caller may perform this action on this resource. Failure is HTTP 403 (or 404 to hide existence).Authentication Least privilege
Authorization codeSecurity: A short-lived, one-time value an OAuth provider returns in the redirect URL. The app exchanges it for tokens over a back channel, so tokens never travel through the browser's address bar.OAuth PKCE
AutoscalingCloud: Automatically adding or removing instances based on load metrics like CPU or requests per second.
Availability zone (AZ)Cloud: One or more physically separate data centres inside a region, with independent power, cooling and networking, linked to the other zones by low-latency fibre.Region Multi-AZ

B

B-treeDatabases: A balanced, sorted tree where each node holds many keys. The default index structure in relational databases: finds a row among millions in a few page reads.Index Big O
Back-of-the-envelope estimateSystem design: A quick, order-of-magnitude calculation (rounded numbers, powers of ten) to check whether a design is plausible before building it.QPS Capacity planning
BackendBackend: The part of an application that runs on servers you control: business rules, data access, integrations.Frontend API
Background jobBackend: A unit of work (send an email, resize a photo, sync a partner) that runs outside the request/response cycle, usually picked from a queue by a worker.Message queue Worker
BackpressureReliability: A way for an overloaded consumer to tell producers to slow down (bounded queues, blocking writes, 429/503 responses) instead of buffering without limit.Load shedding Message queue
BackpropagationAI foundations: The algorithm that efficiently computes the gradient of the loss with respect to every weight in a neural network, by applying the chain rule backwards from the output layer.Gradient descent
BandwidthNetworking: How much data a link can carry per second (e.g. 1 Gbit/s). Different from latency: a high-bandwidth link can still have slow round trips.Latency Throughput
Barge-inAI infrastructure: The caller interrupting while the voice agent is speaking. The system must stop playback within a few hundred milliseconds, cancel pending generation and listen.VAD Echo cancellation
Base62System design: Writing a number with 62 symbols (0-9, a-z, A-Z). Seven base62 characters can represent about 3.5 trillion values, which is why short links look like aZ3kQ9x.
Base64Security: A reversible way to write any bytes as text using 64 characters. It is an encoding, not encryption: anyone can decode it instantly.Secret (Kubernetes)Encryption at rest
Bastion hostSecurity: A hardened jump machine in a public subnet used to reach private resources over SSH. Increasingly replaced by provider session managers or VPNs that need no open inbound port.VPN Security group
Batch API (LLM)AI infrastructure: An asynchronous way to submit many LLM requests at once, returned within hours instead of seconds, usually at a significant discount. Fits offline work like tagging or summarising.Model routing Background job
bcryptSecurity: A long-established, deliberately slow password hashing function with a tunable cost factor and a built-in salt. Still widely used; note it only uses the first 72 bytes of input.Password hashing Argon2
BGPBorder Gateway ProtocolNetworking: The protocol networks (ISPs, clouds, large companies) use to announce which IP address ranges they can reach, so routers across the internet know where to send packets.Router IP address
Bi-encoderRAG & embeddings: A model that embeds the query and each document separately into vectors, so documents can be embedded ahead of time and searched fast. Cheap at query time, but it never sees query and document together.Cross-encoder Embedding
Big OProgramming: Describes how work grows with input size: O(1) constant, O(log n), O(n) linear, O(n²) quadratic.Index
Binary searchProgramming: Finding an item in sorted data by checking the middle and discarding the half that can't contain it. O(log n): about 20 steps for a million items.Linear search Big O B-tree
Bind mountContainers: Mapping a host folder into a container (`-v ./src:/app/src`). Great for live code editing in development; ties the container to the host's file layout.Volume tmpfs mount
Blast radiusReliability: How many users, requests or systems a failure can reach. Gradual rollouts, cells and kill switches exist to keep it small.Canary deployment Kill switch
Block storageCloud: A virtual disk attached to one VM, formatted with a filesystem by the OS. Low latency, used for OS disks and self-run databases.File storage Object storage
Blue-green deploymentDevOps: Run the new version (green) as a full second environment next to the old one (blue), test it, then switch all traffic at once. Rollback is switching back.Canary deployment Rolling update Load balancer
BM25RAG & embeddings: A classic keyword-ranking formula used by full-text search engines. Great for exact terms, codes and names that embeddings blur.Hybrid search
BottleneckPerformance & scale: The component that limits the whole system's throughput. Optimising anything else barely helps.
Bounded contextArchitecture: A part of the business with its own language and model (Bookings, Payments, Search). A natural boundary for a module or service.Modular monolith Microservices
Bounding boxAI infrastructure: A rectangle (x, y, width, height) marking where something is in an image or on a page. Asking an extractor for boxes lets reviewers see exactly which pixels a value came from.Vision-language model OCR
BPEByte Pair EncodingAI foundations: A common tokenization method that starts from bytes and repeatedly merges the most frequent pairs into new tokens. Frequent words become one token; rare words, IDs and some languages split into many.Tokenizer Token
BranchDevOps: A movable name that points at a commit. Making a branch is nearly free; it just lets you add commits without touching the main line.Commit Merge
Branch protectionDevOps: Repository rules for a branch like main: changes only through pull requests, required checks must pass, required reviewers (such as CODEOWNERS) must approve.CODEOWNERS Pipeline Pull request (PR)
Bridge networkNetworking: Docker's default network type: a private virtual network on one host. On user-defined bridges, containers find each other by name through Docker's built-in DNS.Container DNS Port publishing
Build artifactDevOps: The immutable output of a build (container image, JAR, zip bundle), versioned and stored so the exact same thing can be deployed everywhere.Image Registry
Build contextContainers: The set of files sent to the Docker builder (the `.` in `docker build .`). COPY can only see these files, and a big context slows every build..dockerignore Dockerfile
BulkheadReliability: Separate pools of threads, connections or instances per dependency or tenant, so one slow dependency can only exhaust its own pool, not the whole service.Circuit breaker Timeout
Burn rateObservability: How fast you are consuming the error budget relative to plan. A burn rate of 1 uses exactly the budget over the SLO window; 14.4 would exhaust a 30-day budget in about 2 days.Error budget SLO

C

CachePerformance & scale: A fast, temporary copy of data kept closer to where it's needed so repeated reads skip the slow source.Redis CDN
Cache hit ratioPerformance & scale: The share of reads answered from the cache. At 90% the database sees 10% of reads; at 99% it sees 1%, a 10x difference from a few points of hit ratio.Cache
Cache invalidationPerformance & scale: Removing or updating cached data when the source of truth changes, so readers stop seeing old values. Famously hard because writes, caches and readers race.Cache TTL Cache-aside
Cache keyPerformance & scale: The value that decides whether two requests are 'the same' for a cache. Everything that can change the answer (model, prompt version, user permissions, locale, parameters) must be in it, or the cache serves wrong data.Cache Cache TTL
Cache mountContainers: A BuildKit feature (`RUN --mount=type=cache`) that keeps a package manager's download cache between builds without storing it in the image.Layer cache key
Cache stampedePerformance & scale: When a popular cache entry expires and many concurrent requests miss at once, all recomputing it against the database at the same moment. Also called thundering herd or dogpile.Request coalescing Cache TTL
Cache TTLTime to livePerformance & scale: How long a cached entry may be served before it expires and must be reloaded. The TTL is the maximum staleness you accept.Cache invalidation TTL (DNS)
Cache-asidePerformance & scale: The application checks the cache first; on a miss it reads the database and writes the result into the cache. Writes go to the database and usually delete the cache entry.Read-through cache Cache invalidation
Cache-ControlPerformance & scale: The HTTP header that tells browsers and CDNs whether and for how long a response may be cached, e.g. `public, max-age=31536000, immutable`.CDN Cache
CallbackProgramming: A function you pass to another function to be called later, e.g. when a timer fires or a file finishes reading. The original style of async code in JavaScript.Promise Event loop
Canary deploymentDevOps: Send a small share of real traffic (say 5%) to the new version, compare its error rate and latency with the old version, and only then widen the rollout.Blue-green deployment Blast radius Feature flag
CAP theoremDistributed systems: During a network partition, a distributed system must choose between consistency and availability.
Capability negotiationAgents & tools: The handshake where client and server declare which optional features they support (tools, resources, change notifications…) so neither uses something the other can't handle.MCP
Capacity planningSystem design: Estimating how much compute, storage and bandwidth a system needs for expected load plus headroom, and when it will run out.Back-of-the-envelope estimate Throughput
CDNContent Delivery NetworkNetworking: A network of servers around the world that cache your content close to users so it loads faster.Cache Latency
Certificate authorityCASecurity: An organisation trusted by browsers and operating systems to sign certificates after verifying that the requester controls the domain.TLS certificate TLS
Channel managerSystem design: Hotel software that pushes rates and availability to many sales channels (online travel agencies, the hotel's own site) and pulls their bookings back.PMS Overbooking
Characterization testBuilding with AI: A test that records what code does today, on real inputs, and fails on any difference. It pins current behaviour, bugs included, so you can change code without changing behaviour by accident.Golden master test Regression test Legacy code
ChoreographyArchitecture: Coordinating a multi-step process by having each service react to events and publish its own, with no central controller. Contrast with orchestration, where one component directs each step.Event Publish/subscribe (pub/sub)
Chunk overlapRAG & embeddings: Repeating the last few sentences or tokens of one chunk at the start of the next, so a fact that straddles a boundary survives in at least one chunk.Chunking
ChunkingRAG & embeddings: Splitting documents into smaller passages before embedding them, so retrieval returns focused text.
CIContinuous IntegrationDevOps: Automatically building and testing every code change before it is merged.Regression eval
CIDR blockClassless Inter-Domain RoutingNetworking: Notation for an IP range: 10.0.0.0/16 means 'the first 16 bits are fixed', which is 65,536 addresses; /24 is 256 addresses.VPC Subnet IP address
Circuit breakerDistributed systems: Stops calling a failing dependency for a while after repeated errors, failing fast instead of piling up waiting requests, then probes to see if it recovered.Timeout Graceful degradation
Claude CodeBuilding with AI: Anthropic's agentic coding tool. It works in your terminal, IDE, desktop or web: reads and edits your project's files, runs commands (with your permission), can plan before editing, and follows project instructions in CLAUDE.md files.AI coding agent CLAUDE.md Plan mode
CLAUDE.mdBuilding with AI: A Markdown file of project instructions that Claude Code reads at the start of a session: how to run the tests, conventions, what not to touch. Memory you write once instead of repeating every time.Claude Code System prompt
Clean architectureArchitecture: Code arranged in concentric rings (entities, use cases, interface adapters, frameworks) where source-code dependencies may only point inward, toward the business rules.Hexagonal architecture Layered architecture Dependency rule
ClientFundamentals: A program that sends requests to a server, such as a browser, a mobile app or a script.Server Request
Client (UI) stateFrontend: State that exists only in the browser and that the frontend owns: an open modal, the selected tab, a half-typed search.Server state Global store
CLSCumulative Layout ShiftPerformance & scale: A score for how much visible content unexpectedly jumps around while the page loads. Measures visual stability.Core Web Vitals
ClusterIP ServiceContainers: The default Service type: a stable virtual IP and DNS name reachable only inside the cluster, load-balancing connections across ready pods.Service (Kubernetes)NodePort Service LoadBalancer Service
CNAME recordCanonical nameNetworking: A DNS record saying 'this name is an alias for that other name'. The resolver then looks up the target. Not allowed at the zone apex (example.com itself).DNS record ALIAS / apex flattening
Code reviewDevOps: A teammate reading a change before it merges, to catch bugs, share knowledge and keep the design coherent.Pull request (PR)
Code splittingFrontend: Breaking the JavaScript bundle into chunks loaded on demand (per route or per feature) instead of shipping everything up front.JavaScript bundle Lazy loading
CODEOWNERSDevOps: A file in a repository that names the people or teams who must approve changes to certain paths (payments, auth, migrations) before a pull request can merge.Code review Pull request (PR)
Cohen's kappaLLM engineering: An agreement score between two raters (for example a judge and a human) that corrects for agreement expected by chance. 0 means chance-level, 1 means perfect; raw percent agreement can look high just because one label is common.LLM-as-judge
CohesionArchitecture: How strongly the things inside one module belong together. High cohesion: everything about pricing lives in the pricing module.Coupling
Cold startCloud: Extra latency when a serverless platform must create a fresh instance (load runtime, code and dependencies) before handling a request. Typically tens of milliseconds to several seconds.FaaS Scale to zero Provisioned concurrency
Command (message)Architecture: A message asking one specific handler to do something (ReserveRoom). Named in the imperative and may be rejected, unlike an event, which reports a fact.Event Publish/subscribe (pub/sub)
CommitDevOps: A snapshot of the whole project at one point in time, with an author, a message and a pointer to its parent commit(s).Branch
Compensating actionDistributed systems: A business-level undo for a step that already committed: refund a charge, release a held room, send a cancellation email. Not a rollback; the original happened and stays in history.Saga
Compose healthcheckContainers: A command Docker runs periodically inside a container to decide if it is healthy. `depends_on: condition: service_healthy` waits for it.Health check Docker Compose
Compose profileContainers: A label that makes a service start only when asked (`--profile tools`), useful for optional services like an admin UI or a load generator.Docker Compose
Composite indexDatabases: An index on several columns in a fixed order, e.g. (hotel_id, check_in). It helps queries that filter on a leftmost prefix of those columns.Index B-tree
CompositingFrontend: Combining painted layers into the final image, often on the GPU. Changing only `transform` or `opacity` can skip layout and paint entirely.Repaint Reflow (layout)
Composition rootArchitecture: The one place, usually at startup, where concrete adapters are created and wired into the core. The only module that knows every implementation.Dependency inversion Adapter
ConcurrencyProgramming: Dealing with many tasks in overlapping time periods, e.g. one thread juggling 1,000 open requests while each waits on I/O. Not necessarily at the same instant.Parallelism Event loop Thread
Confidence intervalLLM engineering: A range that likely contains the true value of a measured metric. Small samples give wide intervals, so small score differences may be noise.Eval
Confidence thresholdAgents & tools: A cut-off on a calibrated score above which a system acts automatically and below which it asks or escalates. Only useful if the score has been checked against real outcomes.Approval gate Escalation path
ConfigMapContainers: A Kubernetes object holding non-secret configuration that pods read as environment variables or files.Secret (Kubernetes)
Confused deputySecurity: A program with legitimate privileges that is tricked by a less-privileged party into using them on that party's behalf. A hijacked agent using its own credentials is the classic modern example.Privilege escalation Least privilege
Congestion windowNetworking: How much unacknowledged data a TCP sender allows itself in flight. It grows while ACKs arrive and shrinks on loss, so senders share the network fairly.TCP Packet loss
Connection poolDatabases: A set of reusable database connections shared by requests, because opening a connection per request is slow and limited.Database
Connection stormDatabases: A sudden flood of new database connections, typically from autoscaling or serverless bursts, that exhausts max_connections and often triggers retries that make it worse.Connection pool PgBouncer
ConsensusDistributed systems: Getting a group of machines to agree on one value (or one ordered log) even when some crash or messages are delayed. The basis of leader election and replicated config stores.Raft Quorum
Consistent hashingDistributed systems: Placing shards and keys on a hash ring so that adding or removing a shard moves only about 1/N of the keys, instead of nearly all of them with hash mod N.Resharding Hash partitioning
Constrained decodingLLM engineering: Generating text while masking every next token that would break a grammar or JSON Schema. The output is guaranteed to be syntactically valid; whether the values are correct is a separate question.Structured outputs JSON Schema Tokenizer
ConstraintDatabases: A rule the database enforces on every write: NOT NULL, UNIQUE, CHECK, FOREIGN KEY, EXCLUDE. Invalid data is rejected no matter which code path wrote it.Primary key Foreign key
Consumer groupDistributed systems: A set of consumers sharing the work of reading a topic. Each group gets every event (at least once, so duplicates are possible), and each partition is read by one member of the group at a time.Kafka
Consumer lagObservability: How many events a consumer group is behind the newest event. Growing lag means consumers can't keep up.Consumer group Offset
Consumer-driven contractTesting: A contract written by the consumer of an API listing exactly the requests it sends and the response fields it relies on. The provider's CI replays it to prove it still satisfies every consumer.Contract test Pact
ContainerContainers: A packaged application with its dependencies, run in isolation on a shared operating-system kernel.Image Virtual machine
Container DNSNetworking: Docker's embedded DNS server that resolves service or container names (like `db`) to container IPs on user-defined networks.Bridge network DNS
Container writable layerContainers: The thin copy-on-write layer on top of an image's read-only layers where a container's file changes go. Deleted with the container.Image layer Volume
Context budgetLLM engineering: An explicit allocation of the context window across system prompt, tools, retrieved documents, history and the reserved answer, enforced in code rather than hoped for.Context window Token
Context compactionLLM engineering: Replacing old conversation turns or tool outputs with a shorter summary (keeping decisions, ids and open tasks) so a long session fits the context budget.Context window Context engineering
Context engineeringLLM engineering: Deciding what goes into the model's context window (instructions, retrieved docs, history, tool results) and what stays out.RAG
Context switchFundamentals: The OS pausing one thread on a CPU core, saving its registers, and resuming another. Costs microseconds plus cache disruption; thousands per second are normal, millions are a problem.Thread Scheduler CPU
Context windowAI foundations: The maximum number of tokens (prompt + output) a model can consider in one call.Token
Contextual chunk headerRAG & embeddings: A short prefix added to each chunk before embedding, such as document title, section path and hotel name, so an isolated chunk still says what it is about.Chunking Metadata filtering
Continuous batchingAI infrastructure: An inference-server technique that adds new requests to the running GPU batch at every decode step instead of waiting for a whole batch to finish, greatly raising throughput under concurrent load.Inference server Prefill and decode
Continuous deliveryDevOps: Every change that passes the pipeline is releasable at any time; a human (or a schedule) decides when to push it to production.CI Continuous deployment
Continuous deploymentDevOps: Every change that passes the pipeline goes to production automatically, with no manual gate.Continuous delivery
Contract testTesting: A test that checks a provider and a consumer agree on an API's shape. In consumer-driven contracts, the consumer records its expectations and the provider's build verifies them.Integration test API versioning
Contrast ratioFrontend: Luminance ratio between text and background, from 1:1 to 21:1. WCAG AA asks for at least 4.5:1 for normal text and 3:1 for large text.WCAG
Control flowProgramming: The order in which code runs: which branch of an if is taken, when a loop repeats, when a function returns early or throws.Side effect
Control planeContainers: The 'brain' of a Kubernetes cluster: the API server, scheduler and controllers that store desired state and act to reach it.Kubernetes Reconciliation loop
Conway's lawArchitecture: Systems tend to mirror the communication structure of the organisations that build them.
CookieSecurity: A small value the server sets via `Set-Cookie` that the browser stores and automatically sends back on matching requests.
Security attributes matter: HttpOnly (JavaScript can't read it), Secure (HTTPS only), SameSite=Lax/Strict (limits cross-site sending, a CSRF defence), plus Path, Domain and Max-Age.
Session (server-side)CSRF
Coordinated omissionPerformance & scale: A load-testing bias where the tester waits for slow responses before sending the next request, so it under-samples exactly the moments the system was slow and reports a falsely good tail.HDR histogram Tail latency
Core vs contextTrade-offs: Core is what makes customers choose you over competitors; context is everything else you must do well but that gives no advantage. Build core, buy or outsource context.TCO Vendor lock-in
Core Web VitalsPerformance & scale: Three user-centred page metrics: LCP (loading), INP (responsiveness) and CLS (visual stability), measured on real users.
Commonly cited "good" thresholds at the 75th percentile of real visits: LCP ≤ 2.5 s, INP ≤ 200 ms, CLS ≤ 0.1. Check current guidance, since thresholds and metrics evolve.
LCP INP CLS
Cosine similarityRAG & embeddings: Measures the angle between two vectors: 1 = same direction (similar meaning), 0 = unrelated.Embedding
Cost allocation tagCost engineering: A label such as team=search or env=staging attached to cloud resources so the bill can be split by team, product, feature or environment.Unit economics FinOps
Cost crossover pointCost engineering: The scale at which a cheaper-per-unit but higher-fixed-cost option (self-hosting, building) starts beating the option with low fixed cost and a per-unit premium (managed, buying).TCO Managed service
Cost per successful taskLLM engineering: Total spend (model calls, retries, checks, human fallback) divided by tasks actually completed correctly. The honest unit for comparing AI setups.Model routing Eval
CouplingArchitecture: How much one part of a system must change when another part changes. Lower is usually better.
Covering indexDatabases: An index that contains every column a query needs, so the database answers from the index alone (an Index Only Scan) without visiting the table.Index Composite index
CPUCentral Processing UnitFundamentals: The chip that executes instructions. Each core runs one thread at a time; CPU time per second is a hard limit on how much work a server can do.RAM Thread Server
CPU cachePerformance & scale: Small, very fast memory on the CPU (L1, L2, L3) holding recently used data. An L1 hit takes about a nanosecond; going to RAM takes ~100× longer.CPU RAM Latency ladder
CPU profilerPerformance & scale: A tool that records where a program spends CPU time, usually by sampling the call stack many times per second. Shows hot functions, not time spent waiting.Flame graph CPU-bound
CPU-boundPerformance & scale: Work limited by computation (image resizing, encryption, JSON parsing of huge payloads). More or faster cores help; waiting differently does not.I/O-bound CPU
CRDCustom Resource DefinitionContainers: Extends the Kubernetes API with new object types (e.g. PostgresCluster, Certificate) that operators watch and reconcile.Operator (Kubernetes)
Critical pathPerformance & scale: The longest chain of steps that must happen one after another before the user gets a response. Only shortening the critical path makes the request faster.Latency budget
Cron jobBackend: A job triggered by a schedule ("every night at 02:00") instead of by a user action. Named after the Unix cron scheduler.Background job Worker
Cross-encoderRAG & embeddings: A model that reads the query and one candidate passage together and scores relevance. Slower but more accurate than vector similarity; used for reranking.Reranking
CSPContent Security PolicySecurity: An HTTP response header telling the browser which script, style and connection sources a page may use. Limits the damage when an XSS bug slips through.XSS Output encoding
CSRClient-Side RenderingFrontend: The server sends a nearly empty HTML shell plus JavaScript; the browser fetches data and builds the page. Live and cheap to host, slower first content, weaker SEO.SSR SSG Hydration
CSRFCross-Site Request ForgerySecurity: An attack where another site makes the victim's browser send a request to your site, with the victim's cookies attached automatically.Cookie
CSSCascading Style SheetsFrontend: Rules that say how elements look and are laid out (colours, fonts, sizes, flexbox, grid). The browser parses it into the CSSOM.CSSOM HTML
CSSOMCSS Object ModelFrontend: The browser's parsed model of all CSS rules. Combined with the DOM to compute the final style of every element.CSS DOM Render tree

D

Dark launchDevOps: Deploying code to production with its feature flag off, so the code is live but no user can reach it yet.Feature flag Shadow traffic
DASTDynamic Application Security TestingSecurity: Probing a running application from the outside with attack payloads (injection, XSS, misconfigured headers), like an automated, polite attacker.SAST Fuzzing
Data exfiltrationAI security: Getting sensitive data out of a system to an attacker, e.g. via a tool call, an email, or a rendered URL that carries the data.Prompt injection
Data minimisationSecurity: The principle of collecting and keeping only the personal data needed for a stated purpose, for no longer than needed. The cheapest privacy control: data you never stored cannot leak.GDPR Right to erasure
Data provenanceAI security: Recorded origin of a piece of content: who wrote or uploaded it, from which system, when, and what processing it went through. Lets you trust, filter, trace and remove it later.RAG poisoning Source trust tier
Data residencyCloud: A requirement that certain data be stored (and sometimes processed) in a specific country or jurisdiction.GDPR Region
DatabaseDatabases: Software that stores data durably and lets many users read and change it safely at the same time.SQL Index
DAUDaily active usersSystem design: Distinct users who use the product on a given day. The usual starting number for traffic estimates (MAU is the monthly version).QPS
DDoSDistributed Denial of ServiceSecurity: Flooding a service with traffic from many sources to exhaust bandwidth, connections or compute so real users can't get through.Rate limiting WAF
Dead-letter queueReliability: Where messages go after failing processing several times, so one poison message doesn't block the rest.Message queue Kafka
Deadline propagationReliability: Passing the caller's remaining time budget to every downstream call, so nobody keeps working on a request the user has already given up on.Timeout
DeadlockDatabases: Two or more transactions each hold a lock the other needs, so none can proceed. The database detects the cycle and aborts one of them, which can then be retried.Transaction SELECT … FOR UPDATE
Debt registerProduct engineering: A shared list of known technical debt items, each with its interest (ongoing cost), principal (effort to fix) and the trigger that should make the team repay it.Technical debt ADR
Decision driverArchitecture: A force that shapes an architecture decision: a requirement, constraint or quality goal (team skills, budget, latency target, compliance). Listed in an ADR so options can be judged against them.ADR Trade-off
Dedupe tableDistributed systems: A table (or key-value store) recording which request or message ids were already processed, usually with a unique constraint, so a duplicate is detected and skipped or answered from the stored result.Idempotency key Idempotency At-least-once delivery
Deep learningAI foundations: Machine learning with large neural networks made of many layers. LLMs are deep learning models.Machine learning Transformer
Definition of doneBuilding with AI: The checklist a change must meet before anyone calls it finished: acceptance tests pass, reviewed, security checked, deployed behind a flag, monitored. "The agent said done" is not on it.Acceptance test Rollback plan
Delivery receiptSystem design: An acknowledgement that travels back to the sender: sent (server stored it), delivered (recipient device received it), read (recipient opened it).Fan-out (messages)
DenormalizationDatabases: Deliberately copying data (a hotel name onto every booking, a precomputed count) to make reads cheaper, accepting the work of keeping copies in sync.Normalization Cache
Dense retrievalRAG & embeddings: Search by embedding similarity: query and documents become dense vectors and the nearest ones win. Good at paraphrases and meaning, weak on exact codes, names and rare words.Sparse retrieval Semantic search
Dependency inversionArchitecture: High-level policy depends on an abstraction it owns; low-level details implement that abstraction. The arrow in the code points against the flow of control.Dependency rule Hexagonal architecture
Dependency ruleArchitecture: Inner code (business rules) never imports outer code (frameworks, databases, SDKs). Outer code depends on interfaces the inner code defines.Clean architecture Dependency inversion
Deployment (Kubernetes)Containers: A Kubernetes object declaring 'run N replicas of this pod template'. It manages rollouts and replaces failed pods.Pod Kubernetes Rolling update
DiffBuilding with AI: The exact lines a change adds (+) and removes (−), file by file. The diff, not the agent's summary, is what you review.Pull request (PR)Code review
Dirty readDatabases: Reading another transaction's uncommitted change, which may later be rolled back. PostgreSQL never allows it.Isolation level
Discriminated unionProgramming: A type that is one of several shapes, told apart by a shared tag field, e.g. { status: 'paid', paidAt } | { status: 'pending' }. Makes impossible states unrepresentable.TypeScript Static typing
Distributed lockDistributed systems: A lock shared by processes on different machines, usually held in a coordination service. Because holders can pause or be partitioned, it gives 'probably exclusive', not 'certainly exclusive'.Lease Fencing token
Distributed monolithArchitecture: Services that are deployed separately but must change and release together. All the costs of microservices, none of the benefits.Microservices Monolith Coupling
Distributed tracingObservability: Recording one request as a tree of timed spans across every service, database and API it touches, linked by a shared trace id. Shows where the time went.Span APM
Distroless imageContainers: A base image with only the language runtime and its libraries: no shell, no package manager. Smaller attack surface, harder to debug interactively.Multi-stage build Image vulnerability scan
DNSDomain Name SystemNetworking: The internet's phone book: it translates names like example.com into IP addresses.IP address
DNS failoverReliability: Health-checking endpoints and removing unhealthy ones from DNS answers. Recovery speed is bounded by the TTL and by clients that cache longer than told.TTL (DNS)GeoDNS Health check
DNS recordNetworking: One entry in a domain's DNS zone: A (IPv4 address), AAAA (IPv6), CNAME (alias to another name), MX (mail server), TXT (verification text), NS (nameservers).DNS Authoritative nameserver
DNS resolverNetworking: The server (run by your ISP, company or a public provider) that answers DNS questions for you, walking the root → TLD → authoritative chain on a cache miss and caching results.DNS Authoritative nameserver TTL (DNS)
Docker ComposeContainers: A YAML file plus a CLI that starts several containers (app, database, cache) with their networks and volumes in one command.Container Image
DockerfileContainers: A recipe of steps that builds an image layer by layer.Image
Document databaseDatabases: Stores each entity as a JSON-like document with nested data. Fast to read or write a whole aggregate; weaker at joins and invariants spanning many documents.Denormalization Key-value store
Document understandingAI infrastructure: Extracting meaning and structure from documents (fields, tables, relations) rather than raw text: either OCR + rules/LLM, or a multimodal model reading the page image directly.OCR Structured outputs
DOMDocument Object ModelFrontend: The live tree of objects the browser builds from HTML. JavaScript reads and changes the page through it; every change may trigger re-rendering.HTML CSSOM Render tree
DORA metricsDevOps: Four delivery measures from the DevOps Research and Assessment programme: deployment frequency, lead time for changes, change failure rate and time to restore service.Pipeline
Dot productRAG & embeddings: Sum of pairwise products of two vectors: a·b = a₁b₁ + a₂b₂ + … . It grows with both the angle agreement and the lengths of the vectors.Cosine similarity L2 normalization
DriftDevOps: When real infrastructure no longer matches its code, usually because someone changed it by hand in the console.Terraform state IaC
Dry runAgents & tools: Executing an action in preview mode: computing exactly what would happen (price, recipients, records changed) without committing it, so a human can approve the real effect.Approval gate
Dual LLM patternAI security: A privileged model that can call tools never sees untrusted text; a quarantined model with no tools processes the untrusted text and returns only structured values or opaque references.Spotlighting Lethal trifecta
Dual writeDistributed systems: Writing the same change to two systems (database and broker) without a shared transaction. A crash between the two leaves them inconsistent; the outbox pattern avoids it.Transactional outbox Event
Durable executionAgents & tools: Running a multi-step workflow so each completed step is persisted; after a crash or deploy the run resumes from the last checkpoint instead of starting over (or repeating side effects).Agent runtime Idempotency key Saga
Dynamic typingProgramming: Types are attached to values at runtime and checked only when code executes (JavaScript, Python, Ruby). Faster to start; mistakes surface later.Static typing

E

Echo cancellationAEC: Acoustic Echo CancellationAI infrastructure: Removing the agent's own voice from the microphone signal, so the agent does not hear itself through the caller's speaker and 'interrupt' itself.Barge-in
Edge caseProgramming: An input at the boundary or outside the usual path: zero, empty, exactly 24 hours, a cancelled booking, two clicks at once. Where most bugs live.Unit test
Egress costCost engineering: What a cloud provider charges for data leaving its network (to the internet, another region, sometimes another zone). Ingress is usually free; egress often surprises teams.Bandwidth CDN NAT gateway
EmbeddingRAG & embeddings: A list of numbers (a vector) representing the meaning of text, so similar meanings land close together.Vector database Cosine similarity
Encryption at restSecurity: Encrypting data where it is stored (disks, database files, backups, object storage) so stolen media or snapshots are unreadable without the keys.Encryption in transit Envelope encryption
Encryption in transitSecurity: Encrypting data while it moves over a network, normally with TLS, so anyone on the path can't read or modify it.TLS Encryption at rest
End-to-end (e2e) testTesting: A test that drives the whole deployed system the way a user would, usually through a real browser. Highest confidence per test, but slow, costly and prone to flakiness.Flaky test Smoke test
EndpointBackend: One addressable operation of an API, like `POST /bookings`.API REST
Endpointing (turn detection)AI infrastructure: Deciding that the speaker has finished their turn, usually after a stretch of silence (300–800 ms), sometimes helped by a model that reads whether the sentence sounds complete.VAD Barge-in
EndpointSliceContainers: The Kubernetes object listing the IPs and ports of the ready pods behind a Service. Empty endpoints means the Service routes to nobody.Service (Kubernetes)Readiness probe
Env fileContainers: A file of KEY=value lines loaded as environment variables. Keep real ones out of git and commit a `.env.example` listing the names.Docker Compose
Envelope encryptionSecurity: Encrypt data with a fresh data key, then encrypt that data key with a master key held in a KMS, and store the wrapped key next to the data. Fast bulk encryption, central key control.KMS Encryption at rest
Environment variableDevOps: A named setting given to a program by the environment it runs in (DATABASE_URL, PAYMENT_API_KEY). The same code reads different values in development, staging and production.Secrets manager Env file
Error boundaryReliability: A deliberate place in a system that catches errors from everything below it and turns them into a safe outcome: an HTTP 500 with a request ID, a fallback UI, a retried job.Exception Graceful degradation
Error budgetReliability: The amount of unreliability an SLO allows: 1 − SLO. A 99.9% monthly SLO gives about 43 minutes (or 0.1% of requests) to spend on failures and risky changes.SLO Burn rate
Escalation pathAgents & tools: The defined route by which an automated system hands a case to a human: who receives it, with what context, within what time, and what the user is told meanwhile.Human-in-the-loop
ETagEntity tagNetworking: A version identifier for a response. The client sends it back in If-None-Match; if nothing changed, the server replies 304 Not Modified with no body.Cache-Control HTTP
etcdDistributed systems: A small, strongly consistent key-value store replicated with Raft. Kubernetes keeps all cluster state in it; also used for leader election, locks and config.Raft ZooKeeper Kubernetes
Euclidean distance (L2)RAG & embeddings: Straight-line distance between two points: √Σ(aᵢ − bᵢ)². Smaller means more similar. For unit-length vectors it ranks results exactly like cosine similarity.Cosine similarity Dot product
EvalLLM engineering: A repeatable test of an AI system: a dataset of inputs, the outputs, and a scoring method.LLM-as-judge
Eval hill-climbingLLM engineering: Repeatedly tweaking a system to raise its eval score. Productive when the eval is representative; harmful when the team overfits the specific cases instead of the underlying behaviour.Held-out eval set Overfitting
Eval-driven developmentLLM engineering: Building AI features the way TDD builds code: write the eval cases and the pass criteria first, then iterate on prompts, retrieval and models until the eval improves without regressions.Eval Golden dataset Regression eval
EventDistributed systems: A fact about something that happened, in the past tense: 'BookingCreated'. Consumers react to it.Kafka
Event loopProgramming: The scheduler in JavaScript runtimes (browsers, Node.js): one thread runs your code, and when the call stack is empty it takes the next ready callback from a queue.Promise async/await Concurrency
Eventual consistencyDistributed systems: Replicas may disagree for a while, but if writes stop they all converge to the same value. Reads can be stale in the meantime.Strong consistency Replication
ExceptionProgramming: An error object that is thrown and unwinds the call stack until some code catches it. Invisible in function signatures in most languages.Result type Stack trace Error boundary
EXIF metadataExchangeable Image File FormatSecurity: Data embedded in photos by the camera: timestamp, device and often GPS coordinates. Strip it before storing or sending images to third parties unless you need it.PII
Expand/contract migrationalso called parallel changeDatabases: Change a database schema in backward-compatible steps: add the new shape, migrate data and code, and only remove the old shape once nothing uses it.Rollback
EXPLAIN ANALYZEPerformance & scale: A PostgreSQL command that runs a query and prints the chosen plan (Seq Scan, Index Scan, joins) with estimated vs actual rows and timings.Index Full table scan
Exponential backoffReliability: Waiting longer after each failed attempt (e.g. 100 ms, 200 ms, 400 ms, 800 ms) so a struggling dependency gets breathing room instead of a constant hammering.Jitter Retry storm
Exponential backoff with jitterReliability: Waiting longer after each failed attempt (1s, 2s, 4s, 8s…) plus a random offset, so retries don't hammer a struggling dependency in synchronized waves.Timeout Circuit breaker
External Secrets OperatorSecurity: A Kubernetes operator that syncs values from an external secret manager into Kubernetes Secrets, so the source of truth stays outside the cluster and out of Git.Secrets manager Secret (Kubernetes)Operator (Kubernetes)

F

FaaSFunction as a ServiceCloud: Upload a function; the platform runs an instance per event (HTTP request, queue message, file upload), scales instances up and down, and bills per invocation and execution time.Serverless Cold start
FailoverReliability: Switching traffic from a failed component (server, zone, region, database primary) to a standby that takes over its job.Multi-AZ Health check
FaithfulnessRAG & embeddings: The share of claims in an answer that are supported by the provided context. Measured by splitting the answer into claims and checking each one against the sources.Groundedness LLM-as-judge
FakeTesting: A simple but working implementation of a dependency, such as an in-memory repository or a local payment simulator. Behaves like the real thing for the cases tests need.Test double (mock, stub, fake)
Fallacies of distributed computingDistributed systems: Eight false assumptions developers make about networks, starting with 'the network is reliable' and 'latency is zero'.
Fallback chain (LLM)AI infrastructure: An ordered list of models or providers a gateway tries when the first one errors, times out or is rate-limited, e.g. primary provider → same-tier model at a second provider → smaller model with a degraded answer.AI gateway Circuit breaker
Fan-out (messages)System design: Delivering one message or event to many recipients. Fan-out on write copies it to every recipient's inbox; fan-out on read assembles it when each recipient asks.
Fan-out (requests)Performance & scale: One incoming request triggering many parallel backend calls. The response waits for the slowest, so each backend's rare slow call becomes common at the top.Tail latency Hedged request
Feature flagDevOps: A runtime switch that turns code paths on or off without a deploy, so unfinished or risky features can be merged dark and enabled gradually.Trunk-based development
Fencing tokenDistributed systems: A number that increases every time a lock is granted. The protected resource rejects writes carrying an older token, so a stale lock holder can't do damage.Distributed lock Split brain
Few-shot promptingLLM engineering: Including a handful of input → output examples in the prompt so the model copies the format and decision style. Zero-shot means instructions only, no examples.Zero-shot prompting Fine-tuning
Field-level confidenceLLM engineering: A per-field signal that an extracted value is right, built from checks (format, checksum, totals that add up, agreement between two reads), not from the model saying it is 'sure'.Confidence threshold Human-in-the-loop
File storageCloud: A shared network filesystem (NFS/SMB) that many machines can mount at once. Useful for legacy apps and shared working directories.Block storage Object storage
Fine-tuningAI foundations: Further training a model on your examples to change its behaviour or style. Not a good way to add frequently changing facts.RAG
FinOpsCost engineering: The practice of making cloud spend visible and owned by engineering teams: tagging, budgets, alerts, regular cost reviews and trade-off decisions shared with finance.Unit economics Cost allocation tag
FirewallSecurity: Allows or blocks traffic by source/destination IP, port and protocol. It does not understand what is inside an HTTP request.WAF Security group
Flag debtDevOps: The cost of flags left in the code after their job is done: dead branches, untested combinations and surprises when someone flips an old flag.Feature flag Technical debt
Flag targetingDevOps: Rules that decide who gets a flag variant: staff, a list of accounts, a country, a plan, or a stable hash-based percentage of users.Feature flag
Flaky testTesting: A test that sometimes passes and sometimes fails on the same code, usually because of timing, ordering or shared state. It erodes trust in the pipeline.Pipeline
Flame graphPerformance & scale: A visualisation of sampled call stacks: each box is a function, its width is the share of samples it appeared in, and callers sit below callees. Wide boxes are where time goes.CPU profiler
Focus indicatorFrontend: The visible outline showing which element has keyboard focus. Removing it (`outline: none`) leaves keyboard users lost.Accessibility (a11y)
Foreign keyDatabases: A column that references another table's primary key (bookings.room_id → rooms.id). The database refuses values that point to nothing.Primary key SQL
Forward passAI foundations: One run of the input through the network's layers. An LLM does one forward pass per generated token.Inference Transformer
Forward proxyNetworking: A proxy that acts on behalf of clients: they send their outbound traffic through it, and it can filter, log or anonymise it. Servers see the proxy, not the client.Reverse proxy
Foundation modelAI foundations: A large model pretrained on broad data that can be adapted to many tasks by prompting, retrieval or fine-tuning, instead of training one model per task.Pretraining Fine-tuning
FrontendFrontend: The part of an application that runs on the user's device and draws the interface.Backend
Full table scanDatabases: Reading every row of a table to answer a query ("Seq Scan" in PostgreSQL). Fine for small tables; the usual cause of slow queries on large ones.Index Big O
Functional requirementSystem design: What the system must do: 'guests can search hotels by city and dates', 'a short URL redirects to the long URL'.Non-functional requirement
FuzzingSecurity: Feeding a program large amounts of random or mutated input to find crashes, hangs and unexpected behaviour that hand-written tests never try.DAST

G

GDPRGeneral Data Protection RegulationSecurity: The EU law on personal data. It restricts transfers of personal data outside the EU/EEA unless safeguards exist, so it often drives region choice.Data residency
GenAI semantic conventionsObservability: OpenTelemetry's standard attribute names for model calls (model name, token counts, operation, finish reason), so traces from different libraries and vendors look the same.OpenTelemetry Span
GeoDNSNetworking: DNS that returns different answers depending on where the query comes from, sending European users to a European endpoint and Asian users to an Asian one.DNS DNS failover Anycast
git bisectDevOps: A git command that finds the commit that introduced a bug by binary search: you (or a script) mark commits good or bad until git points at the first bad one.Commit
git resetDevOps: Moves a branch back to an earlier commit. With --hard it also throws away uncommitted changes. Rewrites history, so keep it to branches only you use.git revert Working tree
git revertDevOps: Creates a new commit that undoes an earlier one. Safe on shared branches because history is kept.git reset Commit
Git worktreeDevOps: A second (or third) working folder attached to the same repository, each with its own branch checked out. Lets several agent sessions work in parallel without touching each other's files.Branch Merge conflict
GitFlowDevOps: A branching model with long-lived develop and main branches plus feature, release and hotfix branches. Suits scheduled, versioned releases.Trunk-based development
GitOpsDevOps: Operating infrastructure and deployments by making Git the source of truth: changes happen through pull requests, and an agent continuously reconciles the live system to match the repository.IaC Reconciliation loop
Given / When / ThenTesting: A plain-language format for examples: Given a starting situation, When something happens, Then this outcome is expected. Non-coders can write them; an agent can turn each one into a test.Acceptance test
Global storeFrontend: A shared container for client state that many components read and update, such as Redux, Zustand or React context.
Stores solve prop drilling for state that is genuinely shared across distant parts of the UI. They are a poor home for server data, which needs caching, refetching and invalidation that a plain store does not provide.
Client (UI) state Server-state cache
Go / no-go decisionBuilding with AI: A planned moment before a launch (or each rollout step) where named people check agreed criteria and decide to proceed, wait or stop. The criteria are written before the day, not on it.Definition of done Feature flag
Goal driftAgents & tools: An agent gradually pursuing something other than the user's goal over many steps, for example optimising a sub-task or following instructions found in a tool result.AI agent Indirect prompt injection
Golden datasetLLM engineering: A curated, versioned set of realistic inputs with expected outputs or grading criteria, used to score every change to an AI system the same way.Eval Regression eval
Golden master testBuilding with AI: A characterization test that compares a whole output (an invoice, a page, a report) with a saved "golden" copy produced by the old code. Any difference fails.Characterization test Regression test
Golden pathBuilding with AI: The supported, recommended way to do a common task in a codebase (add an endpoint, a job, a migration), with one real example to copy. Humans and agents follow it by default.CLAUDE.md
Graceful degradationReliability: Keeping the core experience working when a part fails, e.g. showing bookings without recommendations when the recommendation service is down.Circuit breaker
Graceful shutdownDevOps: On a stop signal (SIGTERM), a process stops accepting new work, finishes in-flight requests, releases connections and exits, so deploys and scale-downs don't drop requests.12-factor app Readiness probe
Gradient descentAI foundations: The training procedure: compute how the loss changes if each weight moves slightly (the gradient), then nudge every weight a small step in the direction that lowers the loss. Repeat millions of times.Loss function Backpropagation
GraphProgramming: Nodes connected by edges, possibly with cycles: road networks, social follows, service dependencies, flight routes. Explored with BFS/DFS.Tree
Graph databaseDatabases: Stores nodes and relationships as first-class data so multi-hop questions (friends of friends, fraud rings) stay fast without chains of joins.Document database
GraphQLBackend: A query language and runtime where clients send one query describing exactly the fields they need, against a typed schema, usually via a single endpoint.REST Over-fetching / under-fetching N+1 query problem
Greedy decodingAI foundations: Always picking the single most likely next token (temperature 0). Consistent and good for extraction, but can be repetitive and is not guaranteed to be identical across runs on every provider.Temperature Top-k sampling
GroundednessRAG & embeddings: Whether every claim in an answer is supported by the retrieved sources.
Guardrail metricProduct engineering: A metric an experiment or launch must not harm (cancellations, refunds, latency, support tickets), even if the target metric improves.North star metric A/B test
Guardrails (AI)AI security: Checks that run around a model, outside it: input filters, tool allowlists, argument validation, policy rules, output validation. They constrain what the system can do whatever the model says.Least privilege Allowlist Prompt injection

H

Hallucinated packageBuilding with AI: A library or function name an AI invents because it sounds plausible. At best the build fails; at worst someone has published a malicious package under that name.Hallucination AI coding agent
HallucinationAI foundations: A fluent, confident model output that is false or unsupported by the provided sources.RAG Groundedness
Hash collisionProgramming: Two different keys hashing to the same slot. Hash maps handle it, but many collisions degrade lookups from O(1) toward O(n).Hash map
Hash mapProgramming: A key → value structure (a JS Map or object, a Python dict) that finds a key in O(1) on average by computing where it is stored instead of searching.Big O Index
Hash partitioningDatabases: Assigning rows to shards by hashing the shard key. Spreads keys evenly but destroys ordering, so range scans touch every shard.Range partitioning Consistent hashing
HCLHashiCorp Configuration LanguageDevOps: The declarative configuration language Terraform files are written in: blocks of resources, variables and outputs.Terraform
HDR histogramHigh Dynamic Range histogramObservability: A latency histogram with logarithmically sized buckets that records values from microseconds to minutes with bounded relative error in fixed memory, and can be merged across servers.p99 latency Tail latency
Head samplingObservability: Deciding whether to keep a trace when it starts (e.g. keep 5%). Cheap and simple, but blind: it drops most slow or failed requests too.Tail sampling
Head-of-line blockingNetworking: When one lost or slow item at the front of an ordered stream holds back everything behind it, even data that already arrived and is unrelated.TCP QUIC
Health checkReliability: An endpoint or probe that tells the platform whether an instance is alive and ready to receive traffic.
Heap (priority queue)Programming: A tree-shaped structure that always gives you the smallest (or largest) item in O(1) and inserts in O(log n). Used for schedulers, top-k and shortest paths.Message queue Tree
HeartbeatDistributed systems: A small periodic message that says 'I'm still alive'. Missing several in a row is how systems guess that a client or node is gone.
Hedged requestPerformance & scale: Sending a duplicate request to another replica if the first hasn't answered after, say, the p95 latency, and using whichever returns first. Cuts the tail for a few percent extra load.Tail latency Fan-out (requests)Idempotency
Held-out eval setLLM engineering: Eval cases the team never looks at or tunes against while iterating. Used to check that improvements on the development set are real and not overfitting.Golden dataset Overfitting
HelmDevOps: A package manager for Kubernetes: templated YAML bundles (charts) with configurable values, installed and upgraded as releases.kubectl GitOps
Hexagonal architecturePorts and adaptersArchitecture: The business core defines interfaces (ports) for what it needs; databases, APIs and UIs plug in as adapters. The core never depends on infrastructure.Layered architecture Coupling
High cardinalityObservability: A metric label with many possible values (user id, request id, full URL). Each value creates a new time series, which can explode metric storage cost.Structured logging RED method
Hill chartBuilding with AI: A progress picture from Basecamp's Shape Up: each piece of work sits on a hill. Uphill = still figuring it out (unknowns); downhill = known work being executed. Shows uncertainty that a task count hides.RAG status
HMAC signatureHash-based Message Authentication CodeSecurity: A keyed hash of a message computed with a shared secret. The receiver recomputes it to prove the message came from the sender and wasn't modified.Webhook TLS
HNSWHierarchical Navigable Small WorldRAG & embeddings: A popular ANN index: a layered graph of vectors where search starts on a sparse 'highway' layer and zooms into denser local layers.ANN Vector database pgvector
Hook (Claude Code)Building with AI: A shell command that Claude Code runs automatically at set moments, for example before a tool call; a hook can block the action, such as an edit to a protected file.Least privilege
Horizontal scalingPerformance & scale: Adding more machines and spreading work across them. Needs stateless services or partitioned data.Vertical scaling Load balancer
Hot shardDatabases: A shard receiving far more data or traffic than the others, because of a skewed key (a giant customer) or a sequential key (timestamps). It caps the whole system's throughput.Shard key Sharding
HPAHorizontal Pod AutoscalerCloud: A Kubernetes controller that changes a deployment's replica count based on metrics like CPU or requests per second.Autoscaling Pod
HSTSHTTP Strict Transport SecuritySecurity: A response header telling browsers to only ever use HTTPS for this domain for a given period, preventing downgrade to plain HTTP.HTTPS TLS
HTMLHyperText Markup LanguageFrontend: The text format that describes a page's structure and content: headings, paragraphs, links, forms. The browser parses it into the DOM.DOM CSS JavaScript
HTTPHyperText Transfer ProtocolNetworking: The request/response protocol of the web: methods (GET, POST), headers, bodies and status codes.HTTPS Status code
HTTP compressionPerformance & scale: Encoding response bodies with gzip, Brotli or zstd (negotiated via Accept-Encoding / Content-Encoding) so text like JSON and HTML travels 3 to 10 times smaller.Bandwidth
HTTP methodBackend: The verb of an HTTP request (GET, POST, PUT, PATCH, DELETE) that says what to do with the resource named by the URL.HTTP REST Idempotency
HTTP redirect (301 / 302)Networking: A response telling the browser to go to another URL. 301 is permanent and cached by browsers; 302 and 307 are temporary, so every click comes back to the server.HTTP Status code
HTTP/2Networking: The binary version of HTTP that multiplexes many requests as independent streams over one TCP connection and compresses headers. Same methods, headers and status codes as HTTP/1.1.HTTP HTTP/3 Head-of-line blocking
HTTP/3Networking: The version of HTTP that runs over QUIC instead of TCP. Same requests and headers; different transport underneath.QUIC HTTP
HTTPSHTTP SecureSecurity: HTTP inside an encrypted TLS connection, so nobody in between can read or modify traffic.TLS HTTP
Human-in-the-loopAgents & tools: Requiring a person to approve risky actions (payments, emails, deletions) before an agent executes them.
Hybrid searchRAG & embeddings: Combining keyword (BM25) and vector search so you catch exact terms and paraphrases.
HydrationFrontend: Running the page's JavaScript in the browser over server-rendered HTML to attach event handlers and state. Until it finishes, the page looks ready but doesn't respond.SSR CSR
HyperscalerCloud: One of the very large public cloud providers (AWS, Microsoft Azure, Google Cloud) that offer hundreds of services in many regions worldwide.Managed service

I

I/O-boundPerformance & scale: Work that spends most of its time waiting for a disk, database or network call. The CPU sits idle; concurrency and fewer round trips help, more cores rarely do.CPU-bound Latency
IaCInfrastructure as CodeDevOps: Describing servers, networks, databases and permissions in versioned files that a tool applies, instead of clicking in a console.Terraform GitOps
IAMIdentity and Access ManagementSecurity: The cloud service that decides which people and workloads may perform which actions on which resources.Least privilege
id_tokenSecurity: A signed JWT returned by an OpenID Connect provider that says who logged in (sub, email) and for which app (aud). Proves identity; it is not meant for calling APIs.OIDC JWT Access token
IdempotencyDistributed systems: Doing an operation twice has the same effect as doing it once. Essential when retries can duplicate requests.
Idempotency keyBackend: A unique ID the client sends with a non-idempotent request (like a payment) so the server can detect retries and return the first result instead of acting twice.Idempotency API
Identity-aware proxySecurity: A proxy in front of internal apps that checks the user's identity, device posture and policy on every request, replacing 'connect to the VPN and you're in'.Zero trust VPN
IDORInsecure Direct Object ReferenceSecurity: A bug where an API fetches an object by an id from the request without checking that the caller may access that specific object. Changing the id leaks other users' data.Authorization Tenant isolation
ImageContainers: A read-only template (code + runtime + dependencies + config) from which containers are started.Container Dockerfile
Image digestContainers: The content hash of an image (`sha256:…`). Unlike a tag, it can never point to different content, so deploying by digest is exact.Image tag Image
Image layerContainers: Each Dockerfile instruction produces a cached, read-only filesystem layer. Unchanged layers are reused on rebuild and on pull.Image Dockerfile
Image tagContainers: A human label for an image version, like myapp:1.4.2. Tags are mutable pointers; `latest` is just a default name, not 'the newest'.Image Registry
Image tokensAI infrastructure: The tokens an image is converted into before a model sees it. Cost and detail both scale with resolution: providers resize or tile images, so tiny details may be lost unless you crop.Token Vision-language model
Image vulnerability scanSecurity: Checking every package in an image against databases of known vulnerabilities (CVEs, Common Vulnerabilities and Exposures). Fewer packages means fewer findings.Distroless image
Immutable backupSecurity: A backup that cannot be modified or deleted until its retention expires, even by an administrator. Protects against ransomware and compromised credentials.3-2-1 backup rule
Immutable infrastructureDevOps: Never patching servers in place: to change something, build a new image or resource and replace the old one.IaC Build artifact
Incident commanderReliability: The person who coordinates an incident: sets priorities, assigns tasks and decides. They deliberately do not debug themselves.Postmortem On-call
IndexDatabases: A sorted lookup structure (usually a B-tree) that lets the database find rows without scanning the whole table.Database Big O
Indirect prompt injectionAI security: Malicious instructions hidden in content the model reads (web pages, emails, documents) rather than typed by the user.
InferenceAI foundations: Running a trained model to produce outputs, as opposed to training it.
Inference serverAI infrastructure: Software that loads model weights onto GPUs and serves them over an API, handling batching, KV-cache memory, streaming and scheduling. You run one when you self-host a model.Continuous batching KV cache
IngressContainers: A Kubernetes rule set (and the controller enforcing it) that routes external HTTP(S) traffic to services by host and path.Service (Kubernetes)Load balancer
Ingress controllerContainers: The component (e.g. NGINX, Traefik, a cloud controller) that actually implements Ingress rules. Without one installed, Ingress objects do nothing.Ingress LoadBalancer Service
Inline citationRAG & embeddings: A source reference attached to a specific claim in a generated answer, such as [doc-12], that a user or a checker can follow back to the exact retrieved passage.Groundedness RAG
INPInteraction to Next PaintPerformance & scale: How long the page takes to visually respond to user interactions (clicks, taps, keys), roughly the worst one in a visit. Measures responsiveness.Core Web Vitals Long task
Instruction tuningAI foundations: Further training a pretrained model on example conversations (instruction → good answer) so it follows requests instead of merely continuing text.Pretraining RLHF Fine-tuning
Integration testTesting: A test that runs your code against real dependencies such as a database or queue (often in containers) to check the wiring: SQL, migrations, serialization, transactions.Unit test End-to-end (e2e) test
Internet gatewayCloud: The VPC component that connects subnets to the internet in both directions, for resources that have a public IP. A subnet whose route table points 0.0.0.0/0 at it is a public subnet.Route table NAT gateway Subnet
Inventory holdSystem design: A temporary reservation of stock (a room, a seat) with an expiry time, so a customer can pay without someone else taking the unit meanwhile.Overbooking Transaction
Inverted indexDatabases: A map from each word to the documents containing it, the core of search engines. Enables full-text search, relevance ranking and typo tolerance.Index BM25
IOPSInput/Output Operations Per SecondPerformance & scale: How many separate read/write operations a disk or cloud volume can perform per second. Cloud volumes often cap it, which can silently throttle a database.SSD Bottleneck
IP addressInternet Protocol addressNetworking: A numeric address (e.g. 93.184.216.34) that identifies a machine on a network.DNS TCP
IPv6Internet Protocol version 6Networking: The newer IP version with 128-bit addresses (e.g. 2001:db8::1), created because IPv4's ~4.3 billion 32-bit addresses ran out.IP address NAT
Isolation levelDatabases: How much concurrent transactions can see of each other's work: Read Committed, Repeatable Read or Serializable. Stronger levels prevent more anomalies but cause more retries or waiting.Transaction ACID
ISRIncremental Static RegenerationFrontend: Static pages that are regenerated in the background after a revalidation window (or on demand), so you get CDN speed with bounded staleness.SSG Cache
IVFFlatInverted File index with flat (uncompressed) vectorsRAG & embeddings: An ANN index that clusters vectors into lists and searches only the lists nearest the query. Fast to build and small, but recall depends on how many lists you probe.HNSW ANN pgvector

J

JailbreakAI security: A user trying to talk the model out of its safety rules. Different from injection, where untrusted data hijacks an app.
JavaScriptFrontend: The programming language browsers run. It can read and change the DOM, react to events and call APIs. TypeScript compiles to it.DOM Event loop
JavaScript bundleFrontend: The JavaScript files a build tool produces and the browser must download, parse and execute before the app becomes interactive.Code splitting
JitterReliability: Randomness added to retry delays so thousands of clients that failed at the same moment don't all retry at the same moment too.Exponential backoff Retry storm
Jitter bufferNetworking: A small buffer that holds incoming audio packets for a few tens of milliseconds to smooth out uneven arrival times, trading a little latency for continuous playback.WebRTC Packet loss
Jobs to be doneJTBDProduct engineering: A framing that describes what progress a user is trying to make in a situation ("When…, I want to…, so I can…") instead of which features they ask for.
JTBD keeps the team focused on the underlying need. "When my flight is delayed, I want to tell the hotel I'll arrive late, so I don't lose my room" admits many solutions; "add a chatbot" admits one.
User interview MVP
JoinDatabases: A SQL operation that combines rows from two tables by matching columns, usually a foreign key to a primary key (bookings.room_id = rooms.id).Foreign key SQL
JSONJavaScript Object NotationBackend: A plain-text format for objects, lists, strings, numbers and booleans. The default data format of web APIs.API REST
JSON SchemaAgents & tools: A standard way to describe the shape of JSON data (types, required fields, enums). Tool definitions use it to describe their arguments.Tool calling
JSON-RPCJSON Remote Procedure CallBackend: A tiny message format for calling a function on another program: a JSON object with a method name, params and an id, answered by a result or an error with the same id.MCP API
Judge rubricLLM engineering: The written grading instructions an LLM judge follows: the criteria, a small score scale and an anchored example for each score. Vague rubrics produce lenient, noisy judges.LLM-as-judge Eval
JWKSJSON Web Key SetSecurity: A provider's published list of public keys, used to verify the signature on its JWTs. Keys are identified by 'kid' and rotate over time, so clients fetch and cache the set.JWT id_token
JWTJSON Web TokenSecurity: A signed token of the form `header.payload.signature` carrying claims (user id, roles, expiry). Anyone can read the payload; only the signer can produce a valid signature.
A JWT is signed, not encrypted. Servers verify it without a database lookup, which is why it scales easily and why it is hard to revoke before it expires.
Session (server-side)Access token Refresh token

K

k6Testing: An open-source load testing tool where scenarios are written in JavaScript and thresholds (like p95 < 500 ms) can fail a CI run.Load test
KafkaDistributed systems: A distributed, durable event log. Producers append events; many consumer groups read them independently and can replay.Message queue Event
Keep-aliveNetworking: Reusing one TCP (and TLS) connection for many HTTP requests instead of opening a new one each time, which saves the handshake round trips.HTTP TCP three-way handshake Connection pool
KernelFundamentals: The core of the operating system, running with full hardware privileges. Programs ask it to do privileged things (open a file, send a packet) through system calls.Operating system System call
Key-value storeDatabases: A database that maps exact keys to values, like a giant hash map. Extremely fast lookups by key (sessions, counters, caches) and nothing else. Redis is a common example.Redis Cache
Kill switchReliability: A flag whose only job is to turn a feature or dependency off instantly in production when it misbehaves.Feature flag Graceful degradation
KMSKey Management ServiceSecurity: A managed service that creates and stores master keys inside hardened hardware and performs encrypt/decrypt with them on request, with access control and an audit log. Keys never leave it.Envelope encryption Secrets manager
Knowledge cutoffAI foundations: The date after which a model saw no training data. It knows nothing newer unless you put it in the context.RAG LLM
kubectlContainers: The command-line client for the Kubernetes API: apply manifests, inspect objects, read logs, roll out and roll back.Kubernetes Control plane
KubernetesContainers: A container orchestrator: you declare the desired state, and it keeps reality matching it (restarts, scaling, rollouts).Pod
KV cacheAI infrastructure: Stored attention keys and values for tokens already processed, so generating each new token doesn't recompute the whole prompt. It is why long contexts use lots of GPU memory.Self-attention Prefill and decode

L

L2 normalizationRAG & embeddings: Dividing a vector by its length so it has length 1. After normalization, cosine similarity, dot product and Euclidean distance all produce the same ranking.Dot product Cosine similarity
L4 load balancerNetworking: Balances TCP/UDP connections using IPs and ports only. It cannot read URLs or headers, but it is very fast and protocol-agnostic.L7 load balancer Load balancer OSI layers (L4, L7)
L7 load balancerNetworking: Terminates HTTP (and usually TLS) and routes each request by host, path, headers or cookies. Smarter than L4 but must decrypt and parse every request.L4 load balancer Reverse proxy API gateway
Labels and selectorsContainers: Labels are key/value tags on objects (app: booking-api); selectors are queries over them. Services, ReplicaSets and policies find pods by selector, not by name, so a typo silently matches nothing.Service (Kubernetes)ReplicaSet Pod
LatencyPerformance & scale: How long one operation takes, e.g. 120 ms for a request. Lower is better.Throughput p99 latency
Latency budgetPerformance & scale: A target end-to-end time (say 300 ms at p95) split into allowances for each hop (DNS, network, API, database, dependencies), so every team knows how much it may spend.Critical path p99 latency
Latency ladderPerformance & scale: The orders-of-magnitude gap between CPU cache (~1 ns), RAM (~100 ns), SSD (~100 µs), same-region network (~0.5 ms) and cross-continent network (~100 ms).Latency CPU cache SSD
Layer cache keyContainers: What Docker compares to decide if a layer can be reused: the parent layer, the instruction text and, for COPY/ADD, a checksum of the copied files.Image layer Dockerfile
Layered architectureArchitecture: Code organised in horizontal layers (presentation → business logic → data access), where each layer only calls the one below it.Hexagonal architecture Software architecture
Layout thrashingFrontend: Alternating DOM writes and layout reads (like offsetHeight) in a loop, forcing the browser to recompute layout again and again within one frame.Reflow (layout)DOM
Lazy loadingPerformance & scale: Deferring the download of images, components or data until they are actually needed, for example when scrolled into view.Code splitting
LCPLargest Contentful PaintPerformance & scale: Time until the largest visible element (often a hero image or headline) is painted. Measures perceived loading speed.Core Web Vitals
Leader electionDistributed systems: Choosing exactly one node to coordinate (accept writes, run the scheduler) and replacing it automatically when it dies.Raft Lease
Leader/follower replicationDatabases: One node (the leader, or primary) accepts writes and streams changes to followers (replicas), which serve reads and can be promoted if the leader dies.Replication Read replica Failover
LeaseDistributed systems: A lock or leadership that expires automatically after a time unless renewed, so a crashed holder can't block everyone forever.Distributed lock Leader election
Least privilegeSecurity: Give each component (or agent) only the permissions it needs for its task, nothing more.
Legacy codeBuilding with AI: Code people are afraid to change because they can't tell what a change will break: usually few tests, no author to ask, and rules nobody wrote down. Age alone doesn't make code legacy.Characterization test Technical debt
Lethal trifectaAI security: An AI agent that combines access to private data, exposure to untrusted content and a channel that can send data out. Any agent with all three can be steered into leaking data; removing one leg breaks the chain.Indirect prompt injection Data exfiltration
Linear searchProgramming: Checking items one by one until you find the target. O(n): twice the data, twice the work. Works on unsorted data.Binary search Big O Full table scan
Little's lawPerformance & scale: Items in a system = arrival rate × time each spends inside. For pools: busy connections ≈ queries per second × seconds each holds a connection.Connection pool Throughput
Liveness probeReliability: A check that answers 'is this process stuck?'. Failing it makes Kubernetes restart the container.Readiness probe Health check
LLMLarge Language ModelAI foundations: A neural network trained on huge amounts of text to predict the next token. Prompted well, it can write, reason and call tools.Token Context window
LLM observabilityObservability: Recording what an AI system actually did per request: prompts, model calls, retrievals, tool calls, tokens, cost, latency, errors and quality scores, linked in one trace.Distributed tracing Agent trajectory Span
LLM-as-judgeLLM engineering: Using a model with a rubric to grade another model's outputs. Fast and scalable; must itself be validated against humans.
Load balancerSystem design: Spreads incoming requests across several servers and stops sending traffic to unhealthy ones.Horizontal scaling
Load sheddingReliability: Deliberately rejecting some requests early (cheaply) when overloaded, so the requests you do accept still finish in time.Backpressure Rate limiting
Load testPerformance & scale: Sending realistic, controlled traffic at a system (often with tools like k6, Gatling or Locust) to measure latency and errors as load grows, and find where it breaks.Throughput Capacity planning
LoadBalancer ServiceContainers: A Service type that asks the cloud provider to create a load balancer with its own IP in front of the Service. One cloud LB (and its bill) per Service.NodePort Service Ingress controller Load balancer
Lock timeoutDatabases: A limit on how long a statement may wait for a lock before failing. Essential for migrations so a waiting ALTER TABLE can't block all traffic behind it.Deadlock Transaction
LockfileSecurity: A file (package-lock.json, pnpm-lock.yaml, poetry.lock…) that pins the exact version and checksum of every dependency, so installs are repeatable and a new or changed package shows up in the diff.Slopsquatting SCA
Log retention policySecurity: Rules for how long each kind of log or trace data is kept, who may read it and when it is deleted. Prompt logs often contain personal data, so they need short, explicit retention.PII GDPR
LogitAI foundations: The raw, unnormalised score a model outputs for each token in its vocabulary at every step. Higher means more likely; softmax turns logits into probabilities.Softmax Temperature
Long taskPerformance & scale: A chunk of JavaScript that blocks the browser's main thread for more than 50 ms, during which the page cannot respond to input.INP
Long-term memory (AI)Agents & tools: Facts, preferences and outcomes an assistant stores outside the model and retrieves in later conversations, such as "travels with a dog". It lives in a database, not in the model's weights.Short-term memory (AI)Vector database
Loss functionAI foundations: A single number that measures how wrong the model's predictions are on training examples. Training means changing the weights to make this number smaller.Gradient descent
Lost in the middleLLM engineering: The observed tendency of LLMs to use information at the start and end of a long prompt more reliably than information buried in the middle.Context window Context engineering
Lost updateDatabases: Two transactions read the same value, both modify it and write it back; the second write silently overwrites the first.Isolation level SELECT … FOR UPDATE

M

Machine learningMLAI foundations: Programs that learn patterns from examples instead of following hand-written rules.Deep learning
Managed container serviceCloud: A cloud service that runs your container images without you operating a cluster (e.g. serverless container platforms). You give it an image, CPU/memory and scaling rules.PaaS Kubernetes Serverless
Managed databaseCloud: A database the cloud provider runs for you: provisioning, patching, backups, replicas and failover are configuration options, not your team's on-call work.Managed service Database
Managed serviceCloud: Infrastructure a provider operates for you (database, queue, search) for a premium, so your team doesn't run upgrades, backups and failover.TCO Vendor lock-in
Markdown image exfiltrationAI security: A leak channel where a model outputs an image or link whose URL contains private data; the client fetching the image sends that data to an outside server without any click. Blocked by not rendering untrusted URLs or by an image-domain allowlist.Data exfiltration CSP
max_tokensLLM engineering: The API parameter that caps how many tokens the model may generate. Hitting it cuts the answer off mid-sentence; it does not make the model write more concisely.Stop sequence Token
maxSurgeDevOps: Rolling-update setting: how many pods above the desired count may exist during a rollout. Higher = faster rollouts, more temporary capacity cost.maxUnavailable Rolling update
maxUnavailableDevOps: Rolling-update setting: how many pods below the desired count may be unavailable during a rollout. 0 = never lose capacity, but you need surge room.maxSurge Rolling update
MCPModel Context ProtocolAgents & tools: An open protocol that standardises how AI applications connect to tools and data sources through MCP servers.Tool calling
MCP clientAgents & tools: The connector inside the host that keeps one session with one MCP server: it negotiates capabilities, lists tools and forwards calls.MCP host MCP server
MCP hostAgents & tools: The AI application the user interacts with (a chat app, an IDE, an agent). It owns the model, the user's consent and one MCP client per connected server.MCP MCP client MCP server
MCP InspectorAgents & tools: A developer tool that connects to an MCP server like a client would, lists its tools, resources and prompts, and lets you call them by hand to test schemas and errors.MCP server
MCP promptAgents & tools: A reusable, parameterised message template an MCP server offers, typically surfaced to the user as a command (e.g. "draft guest reply"). User-controlled, unlike tools which are model-controlled.MCP server MCP resource
MCP resourceAgents & tools: Read-only data an MCP server exposes under a URI (a policy document, a room-type list). The host application decides when to load it into context; the model does not call it like a tool.MCP server MCP prompt
MCP serverAgents & tools: A program that exposes tools, resources and prompts over the Model Context Protocol, usually wrapping an existing system such as a database, an API or a file system.MCP MCP client
Memory poisoningAI security: Getting false or malicious content written into an assistant's long-term memory (often via injected text) so it influences every future conversation, not just the current one.Prompt injection RAG poisoning
MergeDevOps: Combining two branches by creating a commit with two parents. History is preserved exactly as it happened.Rebase Merge conflict
Merge conflictDevOps: When two branches changed the same lines differently and Git can't decide which wins, so a human must resolve it.Merge Rebase
Merge queueDevOps: A queue that tests each pull request together with the ones merging ahead of it, and merges only if that combination passes, so main stays green even when many changes land at once.Pipeline Branch protection
Message queueDistributed systems: A buffer of jobs; each message is taken by one worker and removed once processed. Most queues deliver at least once, so a message can arrive twice and handlers must be idempotent.Kafka At-least-once delivery Idempotency
Message rolesLLM engineering: Chat APIs label each message as system (or developer), user or assistant. Models are trained to give system instructions the most authority, follow user requests within them, and continue as the assistant.System prompt Prompt injection
Metadata filteringRAG & embeddings: Restricting retrieval to chunks whose attributes match (hotel, language, date, access level) before or while ranking by similarity.RAG Vector database
MicroservicesArchitecture: An architecture of small services, each owning one capability and its data, deployed independently.Monolith
Minimal reproductionBuilding with AI: The smallest set of steps or data that makes a bug happen every time. It turns a vague report into something you, or an agent, can test a fix against.Regression test Root cause
Minimum detectable effectMDEProduct engineering: The smallest true effect an experiment is designed to detect reliably. Smaller MDEs need far more traffic: halving the MDE roughly quadruples the sample size.Statistical significance A/B test
MIPSMaximum Inner Product SearchRAG & embeddings: Finding the stored vectors with the largest dot product with the query. Used when vector length carries meaning, e.g. some recommendation and asymmetric retrieval models.Dot product ANN
MockTesting: A test double that records calls and lets the test assert on them, for example 'sendEmail was called once with this address'. Useful for side effects; brittle when overused.Test double (mock, stub, fake)Stub Spy
Model cascadeAI infrastructure: A routing pattern that sends every request to a cheap model first and escalates to a stronger model only when the cheap answer fails a check (low confidence, invalid output, failed validation).
Cascades need no up-front difficulty prediction, but escalated requests pay twice (both models) and wait longer. They work when most requests are easy and the check that triggers escalation is reliable.
Model routing Routing classifier Fallback chain (LLM)
Model routingAI infrastructure: Sending each request to the cheapest model that can handle it well, and escalating harder ones to stronger models.
Modular monolithArchitecture: One deployable unit, but internally split into modules with strict boundaries. Often the best of both worlds.Monolith
MonolithArchitecture: An application built and deployed as a single unit, usually with one database.Microservices Modular monolith
MRRMean Reciprocal RankRAG & embeddings: The average of 1 / (rank of the first relevant result) over a set of queries. 1.0 means the right answer is always first; 0.5 means it is typically second.Recall@k nDCG
MTBFMean Time Between FailuresReliability: Average time a component runs between failures. Availability ≈ MTBF / (MTBF + MTTR).MTTR
mTLSMutual TLSSecurity: TLS where the client also presents a certificate, so both sides prove their identity. Common between internal services and for B2B APIs.TLS TLS certificate
MTTRMean Time To RecoveryReliability: Average time from a failure starting to service being restored. Detection, diagnosis and the fix all count.MTBF Nines (availability)
Multi-AZReliability: Running copies of a service in two or more availability zones of the same region, so losing one data centre doesn't take you down.Availability zone (AZ)Multi-region
Multi-regionReliability: Running a system in two or more regions, for disaster recovery, lower latency for distant users, or legal reasons. Much harder than multi-AZ because data must cross long distances.Multi-AZ Region RTO / RPO
Multi-stage buildContainers: A Dockerfile with several FROM stages: build tools live in early stages, and only the runtime output is copied into the small final image.Dockerfile Image
Mutation testingTesting: Checking tests by breaking the code on purpose (a changed number, a flipped comparison) and seeing whether any test fails. A test suite that stays green on broken code proves little.Regression test
MVCCMulti-Version Concurrency ControlDatabases: Keeping several versions of a row so readers see a consistent snapshot without blocking writers. How PostgreSQL implements isolation.Isolation level Transaction
MVPMinimum Viable ProductProduct engineering: The smallest product that lets you test your riskiest assumption with real users. Minimal in scope, not in quality of what it does.
An MVP is a learning tool. A manual "concierge" process behind a simple form can be a valid MVP if it answers the question "do users want this?" before you build the automated version.
Jobs to be done Technical debt Debt register

N

N+1 query problemDatabases: Loading a list with 1 query, then running 1 more query per item (N), so 50 hotels cost 51 database round trips. Common in naive GraphQL resolvers and ORMs.GraphQL
N+1 redundancyReliability: Running one more instance than peak load needs (N), so losing any one still leaves enough capacity. N+2 also covers a failure during maintenance.Single point of failure Failover
Namespace (Kubernetes)Containers: A named scope inside a cluster for object names, DNS, quotas and RBAC permissions. It is not a network or security boundary on its own.ResourceQuota NetworkPolicy RBAC
NATNetwork Address TranslationNetworking: A router rewriting private addresses (like 192.168.1.20) to one shared public IP, so many devices share one address. It is why your laptop's IP differs from the IP websites see.IP address IPv6
NAT gatewayCloud: Lets resources in private subnets make outbound connections (package downloads, payment APIs) while staying unreachable from the internet. Billed per hour and per GB processed.NAT Internet gateway Route table
nDCGnormalized Discounted Cumulative GainRAG & embeddings: A ranking metric that rewards relevant results more the higher they appear, normalized so a perfect ranking scores 1.0. Supports graded relevance (very relevant, somewhat, not).MRR Recall@k
Negative caching (DNS)Networking: Resolvers also cache 'this name does not exist' (NXDOMAIN) answers, for a duration set in the zone's SOA record. A lookup made before a record exists can keep failing after you create it.TTL (DNS)DNS resolver
Network ACLAccess Control ListSecurity: A stateless allow/deny rule list applied at the subnet boundary, evaluated in order. Because it is stateless, return traffic must be allowed explicitly.Security group Subnet
Network partitionDistributed systems: A failure where nodes are running but cannot talk to each other, splitting the system into groups that each think the others are down.CAP theorem Split brain
NetworkPolicySecurity: A Kubernetes rule that allows or denies pod-to-pod traffic by label and namespace. Without policies (and a network plugin that enforces them), all pods can reach each other.Namespace (Kubernetes)Least privilege
Neural networkAI foundations: A function built from layers of simple units (neurons). Each unit multiplies its inputs by learned weights, adds them up and applies a non-linearity. Stacking many layers lets it model very complex patterns.Deep learning Weights (parameters)
Next.jsFrontend: A React framework that lets each route choose static generation, server rendering, revalidation or client rendering, and handles hydration and routing.SSR SSG ISR Hydration
Nines (availability)Reliability: Shorthand for availability: two nines = 99%, three = 99.9%, four = 99.99%, five = 99.999%. Each extra nine cuts allowed downtime by 10×.SLA SLO
NodeContainers: A machine (VM or physical) in a Kubernetes cluster that runs pods.Pod
NodePort ServiceContainers: A Service type that also opens the same port (30000–32767 by default) on every node, so something outside the cluster can reach it via any node's IP.ClusterIP Service LoadBalancer Service
Non-functional requirementSystem design: How well the system must do it: latency, availability, durability, consistency, security, cost. Usually what drives the architecture.Functional requirement SLO
Non-goalsBuilding with AI: The part of a spec that says what this change will NOT do. It stops an agent (or a person) from 'helpfully' growing the scope.Spec (feature specification)Scope creep
Non-repeatable readDatabases: Reading the same row twice in one transaction and getting different values because another transaction committed in between.Isolation level
NormalizationDatabases: Designing tables so each fact is stored exactly once, with relations linking them. Prevents update anomalies at the cost of more joins.Denormalization Foreign key
North star metricProduct engineering: The single metric that best captures the value users get from the product and that predicts long-term business success, e.g. nights booked by returning guests.
It is supported by a few input metrics teams can move directly, and protected by guardrail metrics that must not get worse.
Guardrail metric A/B test

O

OAuthSecurity: A standard for delegated authorization: a user grants an app a scoped, revocable token to act on their behalf, without sharing their password.Least privilege
OAuth scopeSecurity: A named permission an app requests, such as 'email' or 'calendar.readonly'. The user consents to the scopes, and the access token is limited to them.OAuth Least privilege
OAuth state parameterSecurity: A random value the app stores in the user's session and sends with the login redirect. The provider echoes it back; a missing or different value means the callback was forged (login CSRF).OAuth CSRF
Object storageCloud: Stores whole files (objects) by key over an HTTP API, with near-unlimited capacity and very high durability. No in-place edits; you replace the whole object. Ideal for images, backups and logs.Block storage File storage CDN
ObservabilityObservability: How well you can understand what a system is doing from its outputs: logs, metrics and traces.
OCROptical Character RecognitionAI infrastructure: Turning pixels of text into machine-readable characters, usually with positions. Classic OCR reads text well but doesn't know which number is the 'total' or which name is the 'guest'.Document understanding Bounding box
OffsetDistributed systems: The position of an event inside a partition. Each consumer group stores how far it has read.Kafka Consumer group Partition
OIDCOpenID ConnectSecurity: An identity layer on top of OAuth 2.0. Adding the 'openid' scope makes the provider also return an id_token, a signed statement of who the user is.OAuth id_token
On-callReliability: A rotation where one engineer at a time is responsible for responding to production alerts, usually with a defined response time and a secondary as backup.Runbook Alert fatigue
One-way doorTrade-offs: A decision or change that is expensive or impossible to undo: deleting data, charging cards, emailing every customer, changing a public API. Two-way doors can be reversed cheaply.Two-way door Blast radius
Online evaluationAI infrastructure: Scoring a sample of real production traces (with automated graders, LLM judges or user feedback) to measure quality continuously, as opposed to offline evals on a fixed test set.LLM-as-judge Golden dataset
OOM killerOut-Of-Memory killerFundamentals: The Linux mechanism that kills a process when the machine (or container) runs out of memory. Shows up as a sudden restart with exit code 137.RAM Process
Open-weight modelAI infrastructure: A model whose trained weights are published so you can download and run it on your own hardware, under the publisher's licence. 'Open weights' does not necessarily mean open training data or code.Weights (parameters)Inference
OpenTelemetryOTelObservability: A vendor-neutral open standard plus SDKs for producing traces, metrics and logs, and a protocol (OTLP) for sending them to any backend.OpenTelemetry Collector Distributed tracing
OpenTelemetry CollectorObservability: A standalone service that receives telemetry from apps, processes it (batching, filtering, sampling, redaction) and exports it to one or more backends.OpenTelemetry Tail sampling
Operating systemFundamentals: The software (Linux, Windows, macOS) that shares the hardware between programs: it schedules CPU time, hands out memory, and mediates access to disks and the network.Kernel Process Thread
Operator (Kubernetes)Containers: A custom controller that encodes operational knowledge for one kind of software (e.g. a PostgreSQL cluster): you declare a custom resource, it handles setup, failover, backups and upgrades.CRD Reconciliation loop
Optimistic lockingDatabases: Read without locking, then write only if the data is unchanged (e.g. WHERE version = 7). If someone else wrote first, the update affects 0 rows and you retry or report a conflict.Pessimistic locking Lost update
Optimistic updateFrontend: Updating the UI immediately as if a request succeeded, then rolling back if the server rejects it.Server-state cache
OSI layers (L4, L7)Open Systems Interconnection modelNetworking: A layering model of networking. In practice engineers mostly say L3 (IP), L4 (TCP/UDP, ports) and L7 (application: HTTP, gRPC) to describe what a device can see and act on.TCP HTTP
Output encodingSecurity: Escaping data for the exact context it is written into (HTML body, attribute, URL, JavaScript), so user input is displayed as text instead of being interpreted as markup or code.XSS CSP
Over-fetching / under-fetchingBackend: Over-fetching: an endpoint returns more data than the client needs. Under-fetching: it returns too little, forcing extra round trips.GraphQL REST
OverbookingSystem design: Selling more units than exist, either by accident (stale availability across channels) or deliberately (expecting some no-shows).Channel manager Inventory hold
OverfittingAI foundations: When a model memorises its training examples (including their noise) instead of learning the general pattern, so it scores well on training data and badly on new data.Validation / test set
OWASP Top 10Open Worldwide Application Security Project Top 10Security: A periodically updated list of the most critical web application security risk categories, such as broken access control and injection. A checklist for reviews, not a complete standard.SQL injection XSS

P

p-valueProduct engineering: The probability of seeing a difference at least as large as the one observed if there were truly no effect. It is not the probability that the change works.Statistical significance Confidence interval
p50 latency (median)Performance & scale: Half of requests are faster, half slower. Describes the typical experience and says nothing about the slowest users.p95 latency p99 latency Latency
p95 latencyPerformance & scale: The latency that 95% of requests beat; 1 in 20 is slower. A common SLO and alerting percentile for user-facing endpoints.p50 latency (median)p99 latency SLO
p99 latencyPerformance & scale: The latency that 99% of requests beat. The slowest 1% (often your most valuable users) wait longer.Latency
PaaSPlatform as a ServiceCloud: A hosting platform (Vercel, Railway, Render, Cloud Run, Heroku) where you hand over code or an image and it handles servers, scaling and deploys.Kubernetes
PACELCDistributed systems: Extension of CAP: if Partitioned, choose Availability or Consistency; Else, even with no failure, choose lower Latency or stronger Consistency.CAP theorem
PacketNetworking: A small chunk of data (typically up to ~1,500 bytes on the internet) with a header holding source and destination IP addresses. Big messages are split into many packets.IP address Router TCP
Packet lossNetworking: Packets dropped on the way, usually by a congested router queue or a weak Wi-Fi/mobile link. 1–2% loss can cut TCP throughput dramatically.Retransmission Congestion window
PactTesting: A widely used open-source tool for consumer-driven contract testing. Consumers generate pact files; providers verify them, often via a shared broker that tracks which versions are compatible.Consumer-driven contract Contract test
Page faultFundamentals: A process touching memory that isn't currently mapped in RAM, so the OS must fetch or create the page. Major faults that read from disk are thousands of times slower than a RAM access.Virtual memory RAM
Pairwise evaluationLLM engineering: A judge sees two outputs for the same input and picks the better one (or a tie). More sensitive to small differences than pointwise scoring, but only gives relative results and is exposed to position bias.Pointwise evaluation Position bias
ParallelismProgramming: Doing several computations at the same instant on different CPU cores or machines. Speeds up CPU-bound work; needs multiple cores.Concurrency Thread CPU
Parameterized querySecurity: A query sent with placeholders ($1, ?) and values passed separately, so the database never parses user input as SQL. The real fix for SQL injection.SQL injection SQL
Parent-document retrievalRAG & embeddings: Search over small, precise chunks but send the larger section they belong to (the parent) to the model, getting precise matching and enough surrounding context.Chunking RAG
PartitionDistributed systems: A slice of a Kafka topic. Order is guaranteed within a partition, and partitions let consumers work in parallel.Kafka
Partition keyDatabases: The field a distributed database hashes or ranges on to decide which node stores a row. A good key has many values and matches your main query; a bad one creates hot partitions.Sharding Partition
Password hashingSecurity: Storing passwords only as slow, salted one-way hashes (bcrypt, scrypt, Argon2) so a database leak doesn't reveal them.Authentication
PCI DSSPayment Card Industry Data Security StandardSecurity: The security standard for anyone who stores, processes or transmits card data. Touching raw card numbers brings heavy audit scope; payment providers' hosted fields keep you out of most of it.
Peak factorSystem design: Ratio of peak traffic to average traffic. 2-3x is common for daily cycles; flash sales or events can reach 10x or more. Design for the peak.QPS Capacity planning
PeekingProduct engineering: Checking an A/B test repeatedly and stopping as soon as it looks significant. It inflates false positives far above the nominal 5%.
Fix it by fixing the sample size and duration up front, or by using sequential testing methods designed for continuous monitoring.
Statistical significance p-value
PerformancePerformance & scale: How fast the system is for a single request at the current load.Scalability
Pessimistic lockingDatabases: Lock rows as you read them (SELECT … FOR UPDATE) so other writers wait until you commit. Suits frequent conflicts and short transactions.Optimistic locking SELECT … FOR UPDATE
PgBouncerDatabases: A lightweight connection pooler for PostgreSQL. Accepts many client connections and multiplexes them over a small pool of real database connections, per session, transaction or statement.Connection pool PostgreSQL
pgvectorRAG & embeddings: A PostgreSQL extension that adds a vector column type and similarity search: a vector DB inside your existing database.Vector database PostgreSQL
Phantom readDatabases: Re-running a query in one transaction and getting new rows that another transaction inserted and committed in between.Isolation level
PID 1 in a containerContainers: The container's main process. It receives SIGTERM on `docker stop`; if it ignores the signal (common with shell-form CMD), the container is killed after a timeout without a graceful shutdown.Container
PIIPersonally Identifiable InformationSecurity: Data that identifies a person: names, passport numbers, faces, addresses, payment details. Its handling is regulated (e.g. GDPR) and drives retention, access and vendor choices.GDPR Data residency
PII redactionAI security: Detecting personal data (names, emails, card numbers, passport numbers) in text and masking or tokenising it before it is sent to a model, stored in logs or shown to someone who should not see it.PII Data minimisation
Pilot lightReliability: A DR strategy where the data is continuously replicated to a second region but compute is off or minimal. Recovery means starting and scaling the app tier there: tens of minutes.Warm standby RTO / RPO
PipelineDevOps: An automated sequence of stages (build, test, scan, package, deploy) that every change goes through, defined as code in the repository.CI Build artifact
PKCEProof Key for Code ExchangeSecurity: The client sends a hash (code_challenge) when starting an OAuth login and the original secret (code_verifier) when redeeming the code, so a stolen authorization code is useless on its own.OAuth Authorization code
Plan modeBuilding with AI: A Claude Code mode where the agent reads the code and proposes a step-by-step plan without editing anything, so you can review and correct the approach first.Claude Code Spec (feature specification)
Plan-and-executeAgents & tools: An agent pattern that first writes an explicit multi-step plan, then executes the steps (often with a cheaper model or plain code), re-planning only when a step fails or reveals something new.ReAct Workflow (AI)
PMSProperty Management SystemProduct engineering: The hotel's core operational software: reservations, room status, check-in/out, folios and housekeeping.
PodContainers: The smallest deployable unit in Kubernetes: one or more containers that share a network address.Kubernetes
PodDisruptionBudgetPDBReliability: A rule like "at least 2 booking-api pods must stay available" that voluntary disruptions (node drains, cluster upgrades) must respect. It doesn't apply to crashes or rollouts.maxUnavailable Node
Point-in-time recoveryPITRDatabases: Restoring a database to any chosen second by replaying its write-ahead log on top of a base backup. Lets you rewind to just before a bad migration or deletion.Write-ahead log (WAL)RTO / RPO
Pointwise evaluationLLM engineering: A judge scores one output at a time against a rubric (for example 1–4). Gives absolute numbers you can track over time, but scores drift and cluster.Pairwise evaluation LLM-as-judge
Poison messageReliability: A job that fails every time it is processed (bad data, a bug). Without a retry limit it blocks or burns workers forever; it belongs in a dead-letter queue.Dead-letter queue Message queue
Policy as codeAI security: Writing authorization and business rules (who may do what, up to which amount) as versioned, testable code or rules evaluated by an engine, instead of scattering them through prompts and handlers.Policy engine Guardrails (AI)
Policy engineSecurity: A component (a library or a service such as Open Policy Agent, Cedar or OpenFGA) that evaluates authorization rules written as data or code, separate from business logic.ABAC ReBAC
Polling / long pollingNetworking: Polling: the client asks "anything new?" every N seconds. Long polling: the server holds the request open until there is news or a timeout, then the client asks again.WebSocket SSE
Port (hexagonal architecture)Architecture: An interface owned by the application core that describes what it needs (PaymentPort, BookingRepository) or offers (BookRoom use case), with no technology in it.Adapter Hexagonal architecture
Port (network)Networking: A number (0–65535) that identifies which program on a machine should receive a network connection, e.g. 443 for HTTPS or 5432 for PostgreSQL.IP address Server Process
Port publishingNetworking: Forwarding a host port to a container port (`-p 8080:3000`). Only published ports are reachable from outside the Docker network.Port (network)Bridge network
Position biasLLM engineering: An LLM judge's tendency to prefer whichever answer appears first (or second) in a pairwise comparison, regardless of quality. Mitigated by judging both orders and only counting consistent verdicts.Pairwise evaluation LLM-as-judge
Positional encodingAI foundations: Extra information added to token vectors so the model knows word order. Without it, attention would treat a sentence as an unordered bag of tokens.Self-attention
PostgreSQLDatabases: A popular open-source relational database known for correctness, extensions (like pgvector) and a mature ecosystem.SQL
PostmortemReliability: A written review after an incident: timeline, impact, contributing factors and owned follow-up actions. Blameless: it asks how the system allowed the failure, not who to blame.Incident commander MTTR
Prefill and decodeAI foundations: The two phases of generation. Prefill processes the whole prompt in parallel (drives time to first token); decode produces output tokens one at a time (drives total time).KV cache Streaming
PresenceSystem design: Whether a user is online, offline or last seen at a given time, usually derived from open connections and periodic heartbeats.Heartbeat
preStop hookReliability: A command or HTTP call Kubernetes runs before sending SIGTERM to a container, often a short sleep so load balancers stop routing to the pod first.SIGTERM Graceful shutdown
PretrainingAI foundations: The first and most expensive training stage: predicting the next token over a huge corpus of text and code. Produces a model that knows language and facts but is not yet a helpful assistant.Instruction tuning Foundation model
Primary keyDatabases: A column (or set of columns) whose value uniquely identifies each row of a table, like bookings.id. Indexed automatically.Foreign key Index
Privilege escalationSecurity: Gaining more access than intended, e.g. a guest-facing agent triggering staff-only actions through a tool that runs with admin rights.Least privilege
ProcessFundamentals: A running program with its own memory space, managed by the operating system.Thread
PromiseProgramming: An object representing a value that will be available later (or an error). It is pending, then fulfilled or rejected, and lets you chain or await async work.async/await Callback Event loop
Prompt cachingAI infrastructure: A provider feature that stores the processed form of a repeated prompt prefix (system prompt, tool definitions, documents) so later requests reading that prefix are billed at a reduced input rate and start faster.Token Context window
Prompt injectionAI security: Text crafted to override the application's instructions, e.g. 'ignore previous instructions and…'.Indirect prompt injection Jailbreak
Prompt templateLLM engineering: A prompt stored with placeholders (guest name, retrieved docs, question) that code fills at runtime. Templates are versioned and tested like any other code.System prompt Prompt versioning
Prompt versioningLLM engineering: Giving every prompt change an identifier, storing it in version control, logging which version produced each answer, and running evals before rollout.Prompt template Regression eval
Prop drillingFrontend: Passing a value through many intermediate components that don't use it, only so a deeply nested child can.Global store
Provisioned concurrencyCloud: Paying to keep a number of serverless instances warm at all times, trading part of the pay-per-use saving for predictable latency.Cold start FaaS
PSTNPublic Switched Telephone NetworkNetworking: The ordinary phone network. Calls reach a voice agent through a telephony provider that bridges PSTN audio (typically 8 kHz, narrowband) to your servers.SIP trunk
Publish/subscribe (pub/sub)Architecture: A messaging pattern where producers publish messages to a topic without knowing who receives them, and every subscriber gets its own copy.Event Topic (Kafka)
Pull request (PR)DevOps: A proposal to merge a branch, where teammates review the diff, discuss it and CI checks it before it lands. GitLab calls it a merge request.Code review CI
Pure functionProgramming: A function whose output depends only on its inputs and that changes nothing outside itself. Easy to test, cache and reason about.Side effect
Push notificationSystem design: A message delivered to a phone through the platform's push service (APNs for iOS, FCM for Android) when the app is not running or connected.
PydanticProgramming: A Python library for data models with runtime validation. Plays the same role as Zod in Python LLM code: define the model, export JSON Schema, validate the response.JSON Schema Zod

Q

QPSQueries per secondSystem design: Requests (or queries) handled per second. Often used interchangeably with RPS (requests per second). Always ask: average or peak?Throughput DAU
Quantization (model)AI infrastructure: Storing model weights with fewer bits (e.g. 8 or 4 instead of 16), cutting GPU memory and often raising throughput, at the price of some quality loss that must be measured on your own evals.VRAM Weights (parameters)
QUICNetworking: A transport protocol over UDP with built-in TLS 1.3, independent streams (no cross-stream head-of-line blocking), faster handshakes and connection migration. HTTP/3 runs on it.UDP HTTP/3 TLS
QuorumDistributed systems: The minimum number of nodes that must agree for a decision to count, usually a majority (3 of 5). Any two majorities overlap, so two conflicting decisions can't both win.Consensus Raft

R

Race conditionProgramming: A bug where the result depends on the timing of concurrent operations, e.g. two requests both see 1 room left and both book it.Concurrency Transaction
RaftDistributed systems: A consensus algorithm built around a single elected leader that appends entries to a replicated log and commits them once a majority has stored them. Used by etcd and many others.Consensus Quorum Leader election
RAGRetrieval-Augmented GenerationRAG & embeddings: Retrieve relevant documents first, put them in the prompt, then let the model answer grounded in them.Embedding Chunking
RAG poisoningAI security: Planting malicious or false content in the documents a RAG system retrieves, so it ends up in the model's context and steers answers or actions.RAG Indirect prompt injection
RAG statusRed / Amber / GreenBuilding with AI: A one-word project health signal: green (on track), amber (at risk, with a plan), red (off track, needs a decision). Useful only if it's honest and comes with the reason.Risk register Watermelon status
RAMRandom Access MemoryFundamentals: Fast, temporary working memory for running programs. Much faster than disk, but limited and wiped on restart; running out gets processes killed (OOM, out of memory).CPU Process
Range partitioningDatabases: Assigning contiguous key ranges to shards (A–F, G–M…, or by date). Range scans stay on one shard, but sequential keys pile new writes onto the last shard.Hash partitioning Hot shard
Rate limitingSecurity: Capping how many requests a client may make per time window, to protect capacity and stop abuse.
RBACRole-Based Access ControlSecurity: Authorization by role: permissions are attached to roles (guest, front-desk, hotel-admin) and users get roles.Authorization
ReActReason + ActAgents & tools: An agent pattern where the model alternates a short reasoning step, a tool call (action) and the tool's result (observation), repeating until it can answer.AI agent Tool calling
Read replicaDatabases: A copy of a database that receives changes from the primary and serves read queries to spread load.Replication
Read-through cachePerformance & scale: Like cache-aside, but the cache layer (a library or proxy) loads missing entries from the database itself, so application code only ever talks to the cache.Cache-aside
Read-your-writesDistributed systems: A guarantee that after you write something, your own subsequent reads see it, even if other users may still see the old value.Eventual consistency Read replica
Read/write quorum (R + W > N)Distributed systems: With N replicas, a write waits for W acknowledgements and a read asks R replicas. If R + W > N, every read overlaps at least one replica with the latest write.Replication Quorum
Readiness probeReliability: A check that answers 'can this pod take traffic right now?'. Failing it removes the pod from the service without restarting it.Liveness probe Health check
ReBACRelationship-Based Access ControlSecurity: Permissions derived from relationships in a graph: you can edit a booking because you manage the hotel that owns it. Popularised by Google's Zanzibar design.RBAC ABAC
RebaseDevOps: Replaying your commits on top of another branch, producing new commits with new ids and a linear history. Never rebase commits others have already pulled.Merge
Recall@kRAG & embeddings: The share of the truly relevant items (or true nearest neighbours) that appear in the top k results. The main quality metric for retrieval and for ANN index tuning.ANN Reranking
Reciprocal rank fusionRRFRAG & embeddings: A way to merge several ranked lists by summing 1 / (k + rank) for each document across lists. It uses only ranks, so it needs no score calibration between keyword and vector search.Hybrid search BM25
Reconciliation loopContainers: A controller repeatedly compares desired state with actual state and takes small actions to close the gap.Kubernetes Control plane
Recreate deploymentDevOps: Stop every instance of the old version, then start the new one. Simple and never runs two versions at once, but users see downtime in between.Rolling update Blue-green deployment
Recursive chunkingRAG & embeddings: Splitting text on the largest natural separator that keeps pieces under a size limit (sections, then paragraphs, then sentences, then words), so chunks rarely cut mid-thought.Chunking Semantic chunking
RED methodRate, Errors, DurationObservability: For every request-serving service, chart request rate, error rate and latency distribution. Describes what users experience.USE method SLI
Red-teamingAI security: Deliberately attacking your own system (prompt injection, jailbreaks, tool abuse, data extraction) to find failures before real attackers or users do, then turning findings into regression tests.Prompt injection Jailbreak Regression eval
RedisDatabases: An in-memory data store often used as a cache, session store, rate limiter or lightweight queue.Cache
Reflow (layout)Frontend: Recomputing the size and position of elements. Triggered by changes to geometry (width, font size, adding nodes) and can cascade to the whole page.Repaint Layout thrashing Render tree
Refresh tokenSecurity: A longer-lived credential used only to obtain new access tokens. Stored carefully and checked against the server, so it can be revoked.Access token Token revocation
RegionCloud: A geographic area (e.g. Frankfurt, Northern Virginia) where a cloud provider runs several isolated data centres. You choose regions for latency, law and price.Availability zone (AZ)Data residency
RegistryContainers: A server that stores and distributes container images (Docker Hub, GitHub Container Registry, ECR).
Regression evalLLM engineering: An eval run automatically on every change (prompt, model, retrieval) that fails the build if quality drops below a threshold.Eval CI
Regression testTesting: A test added after a bug, reproducing exactly that bug, so the same mistake can never ship silently again.Acceptance test Unit test
Reinforcement learning (RL)AI foundations: Learning by trial and error: an agent takes actions, receives a reward signal, and adjusts its behaviour to earn more reward over time.RLHF Supervised learning
Render treeFrontend: The visible elements (DOM minus hidden nodes) with their computed styles. The input to layout and paint.DOM CSSOM Reflow (layout)
RepaintFrontend: Redrawing the pixels of elements whose appearance changed (colour, shadow) without changing geometry. Cheaper than reflow, still not free.Reflow (layout)Compositing
Replay attackSecurity: Re-sending a captured, validly signed message later to trigger the action again. Blocked with timestamps, short tolerance windows and remembering processed ids.HMAC signature Idempotency
Replica promotionDatabases: Turning a follower into the new leader during failover: stop replication, make it writable, and repoint clients to it.Leader/follower replication Failover Split brain
ReplicaSetContainers: The Kubernetes controller that keeps exactly N pods matching its selector running. Deployments create one ReplicaSet per pod-template version and shift replicas between them during rollouts.Deployment (Kubernetes)Pod Labels and selectors
ReplicationDistributed systems: Keeping copies of the same data on several machines, for read scaling and to survive failures.Read replica Sharding
Replication lagDatabases: How far a follower is behind the leader, in seconds or bytes of log. Usually milliseconds; under load or after a big migration it can reach minutes.Asynchronous replication Read-your-writes
RequestFundamentals: A message from a client asking a server to do something, e.g. 'GET /hotels'.Response HTTP
Request coalescingPerformance & scale: Letting only one request recompute a missing cache entry while others wait for its result. Also called single-flight or a per-key lock.Cache stampede
RerankingRAG & embeddings: A second, more precise model reorders retrieved candidates by true relevance to the question.
Reserved capacityCost engineering: Committing to a fixed amount of a resource for one or three years in exchange for a large discount. Cheap if you use it, wasted money if you don't.Savings plan Spot / preemptible instance
ReshardingDatabases: Changing the number or layout of shards and moving data accordingly, ideally online while traffic keeps flowing.Consistent hashing Sharding
ResourceQuotaContainers: A per-namespace cap on total CPU/memory requests, pod count or other objects, so one team or job can't consume the whole cluster.Namespace (Kubernetes)
ResponseFundamentals: The server's reply to a request: a status code, headers and usually a body.Request Status code
RESTRepresentational State TransferBackend: An API style where URLs name resources (/hotels/42) and HTTP verbs (GET, POST…) say what to do with them.API HTTP
Restore drillReliability: A scheduled exercise where you actually restore a backup into a fresh environment, verify the data and time the whole process. The only proof a backup works.RTO / RPO Point-in-time recovery
Result typeProgramming: Returning success or failure as a value (e.g. `{ ok: true, value }` or `{ ok: false, error }`, Rust's Result, Go's `value, err`) so the caller must handle both.Exception
RetentionDistributed systems: How long an event log keeps events (e.g. 7 days or forever). Events stay after being read, so consumers can replay them.Kafka Offset
RetransmissionNetworking: Re-sending data that was not acknowledged in time (timeout) or that the receiver signalled as missing (duplicate ACKs). TCP does it automatically; UDP never does.TCP Packet loss
RetrospectiveBuilding with AI: A meeting at the end of a project or phase where the team looks at what happened, without blame, and agrees a few concrete changes to how it works next time, each with an owner.Postmortem
Retry budgetReliability: A cap on retries as a share of normal traffic (e.g. at most 10% extra), so retries can never multiply load during an outage.Retry storm Exponential backoff
Retry stormReliability: When retries from many clients (and many layers) multiply the load on an already struggling service, turning a slowdown into a full outage.Exponential backoff Circuit breaker Retry budget
Reverse proxyNetworking: A proxy that acts on behalf of servers: clients connect to it thinking it is the site, and it forwards to backends. Load balancers, CDNs and API gateways are reverse proxies.Forward proxy Load balancer CDN
RICEReach, Impact, Confidence, EffortProduct engineering: A prioritization score: (Reach × Impact × Confidence) ÷ Effort. It makes assumptions explicit so a team can argue about inputs instead of opinions.North star metric
Right to erasureSecurity: The GDPR right of a person to have their personal data deleted without undue delay when there is no longer a valid reason to keep it. For AI memory it covers stored facts, embeddings, summaries, logs and backups.GDPR Data minimisation
RightsizingCost engineering: Matching instance and database sizes to measured usage, instead of the guess made at launch. Often the cheapest saving available.Vertical scaling
Risk registerBuilding with AI: A short, living list of what could go wrong on a project: each risk with likelihood, impact, an owner, a trigger to watch and the planned response. Reviewed weekly.RAG status One-way door
RLHFReinforcement Learning from Human FeedbackAI foundations: A training stage where humans (or a model trained on their preferences) rank candidate answers, and the model is optimised toward the preferred ones: more helpful, honest and safe.Instruction tuning Reinforcement learning (RL)
Roll forwardDevOps: Fixing a bad release by shipping a new fix quickly instead of reverting. Needed when a rollback is impossible, for example after a destructive migration.Rollback
RollbackDevOps: Returning production to the previous known-good version. Fast when the old artifact is still running or tagged; dangerous when the database schema has already changed.Roll forward Expand/contract migration
Rollback planDevOps: A written answer, before deploying, to: how do we undo this, how long does it take, and what about data the new version already wrote?Rollback Runbook
Rolling updateDevOps: Replacing old instances with new ones a few at a time, only continuing while new ones pass health checks. No downtime, easy to halt.Deployment (Kubernetes)Health check
Root causeReliability: The underlying reason a failure happened, as opposed to the symptom you saw. Fixing only the symptom (hiding an error, adding a retry) lets the cause strike again elsewhere.Postmortem Minimal reproduction
Route tableCloud: Rules attached to subnets saying where packets for each destination range go: stay local, go to the internet gateway, to a NAT gateway, to a peered network or to a VPN.Subnet Internet gateway NAT gateway
RouterNetworking: A device that forwards packets one hop closer to their destination by looking up the destination IP address in its routing table.Packet IP address BGP
Routing classifierAI infrastructure: A small model or rules engine that predicts which model tier a request needs (for example easy vs hard) before any answer is generated.
It can be a fine-tuned small classifier, an embedding plus nearest-neighbour lookup, or a cheap LLM call that returns a label. Its own cost and latency are added to every request, and its mistakes show up as quality drops on misrouted hard requests.
Model routing Model cascade AI gateway
Row-level securityRLSSecurity: A database feature (e.g. in PostgreSQL) that filters rows by a policy for the current user or tenant, as a safety net under application checks.Tenant isolation IDOR
RTO / RPORecovery Time Objective / Recovery Point ObjectiveReliability: RTO: how long you may be down after a disaster. RPO: how much recent data you may lose. Lower targets cost more.SLA SLO
RTTRound-trip timeNetworking: Time for a packet to go to the other side and the reply to come back. Same data centre: under 1 ms; Paris ↔ Frankfurt: ~15 ms; Paris ↔ New York: ~75 ms; Tokyo ↔ Frankfurt: ~230 ms. Handshakes cost whole RTTs.Latency TCP
RunbookReliability: A short, tested document linked from an alert: what it means, how to check impact, and the safe first actions to mitigate.On-call

S

SagaDistributed systems: A long business transaction split into local steps, each in its own service and database, with a compensating action to undo each step if a later one fails.Compensating action 2PC Transactional outbox
Saga choreographyDistributed systems: No coordinator: each service reacts to other services' events and emits its own. Loosely coupled, but the overall flow lives nowhere in code.Saga Saga orchestration Event
Saga orchestrationDistributed systems: One coordinator service (the orchestrator) tells each participant what to do next and tracks the saga's state.Saga Saga choreography
Salt (password hashing)Security: A random value stored with each password hash and mixed into it, so identical passwords produce different hashes and precomputed lookup tables are useless.Password hashing Argon2
SameSite cookie attributeSecurity: A cookie attribute (Strict, Lax, None) that controls whether the browser sends the cookie on requests started by other sites. Lax blocks most cross-site POSTs, the core of CSRF.Cookie CSRF
Sample ratio mismatchSRMProduct engineering: When the observed split of users between variants differs significantly from the intended split (e.g. 52/48 instead of 50/50). It signals a bug in assignment or logging and invalidates the results.A/B test Sticky bucketing
SandboxSecurity: An isolated environment (container, VM, restricted process) where untrusted code or actions run with no access to what they don't need.Least privilege
SASTStatic Application Security TestingSecurity: Scanning source code without running it to find risky patterns such as string-built SQL or hard-coded secrets. Fast, runs in CI, has false positives.DAST SCA
Savings planCost engineering: A commitment to spend a fixed amount per hour on compute for a term, in exchange for a discount that applies flexibly across instance types or services.Reserved capacity
SCASoftware Composition AnalysisSecurity: Scanning your dependencies (npm, pip, container images) against vulnerability databases, so you learn when a library you ship has a known CVE.SAST Image vulnerability scan
ScalabilityPerformance & scale: How well the system keeps its performance as load grows, and how cheaply you can add capacity.Performance Horizontal scaling
Scale to zeroCloud: When there is no traffic, no instances run and you pay (almost) nothing. The price is a cold start on the next request.Serverless Cold start
Scatter-gather queryDistributed systems: A query sent to every shard in parallel whose results are merged. Its latency is set by the slowest shard and its cost grows with the shard count.Sharding Shard key
SchedulerFundamentals: The part of the kernel that decides which runnable thread gets each CPU core next, and for how long (a time slice of a few milliseconds).Context switch Thread CPU
Schema compatibilityTesting: Whether data or API messages written with one schema version can be read by another. Backward compatible: new readers handle old data. Forward compatible: old readers tolerate new data.API versioning Expand/contract migration
Scope creepBuilding with AI: A change growing beyond what was asked: extra refactors, renamed files, upgraded dependencies. Each extra line is extra risk and extra review.Non-goals Diff
Scoped credentialAI security: A token that only allows specific actions on specific resources, for a short time, ideally on behalf of a specific user. If an agent leaks or misuses it, the damage is bounded by the scope.Least privilege OAuth scope
Screen readerFrontend: Assistive software (VoiceOver, NVDA, JAWS, TalkBack) that reads the accessibility tree aloud or to a braille display and lets users navigate by headings, links and landmarks.Accessibility tree ARIA
Seam (in code)Building with AI: A place where you can change which code runs without editing the code around it: a function everything calls, a router, a config switch. Seams let new code take over gradually.Strangler fig pattern Feature flag
Secret (Kubernetes)Security: A Kubernetes object for sensitive values. Only base64-encoded by default; encryption at rest and access control must be configured.ConfigMap
Secret rotationSecurity: Replacing a credential (API key, DB password, signing key) with a new one on a schedule or after a leak, usually with an overlap window where both work so nothing breaks.Secrets manager KMS
Secret scanningSecurity: Automatically searching commits, pull requests and logs for credential patterns (API keys, private keys) so leaks are blocked or detected before attackers find them.Secret rotation Pipeline
Secrets managerSecurity: A service (cloud secret store or Vault-style tool) that stores credentials encrypted, controls who can read them, audits access and supports rotation.Secret (Kubernetes)Least privilege Secret rotation External Secrets Operator
Security groupSecurity: A stateful, allow-only firewall attached to individual instances or network interfaces. Rules can reference other security groups, e.g. 'allow 5432 from the app tier'.Network ACL Firewall VPC
SeedAI foundations: A number that initialises the random generator used for sampling. Same seed plus same inputs gives the same draws, where the provider supports it; it improves reproducibility but rarely guarantees it.Temperature
SELECT … FOR UPDATEDatabases: A SQL read that also locks the selected rows until the transaction ends, so concurrent writers on those rows wait their turn.Transaction Lost update
SelectivityDatabases: The fraction of rows a filter matches. A filter matching 1 row in 5 million is highly selective (index helps); one matching 60% is not (a full scan is cheaper).Index Full table scan
Self-attentionAI foundations: The transformer operation where each token computes how relevant every earlier token is to it and mixes in their information accordingly. It is how 'it' gets linked to 'the room' three sentences back.Transformer KV cache
Self-critique (reflection)Agents & tools: An extra model step that reviews a draft answer or plan against criteria and proposes fixes before acting. Helps when there is a checkable criterion; adds tokens and latency.AI agent LLM-as-judge
Self-preference biasLLM engineering: An LLM judge's tendency to favour outputs produced by its own model or model family, whose style it finds familiar.LLM-as-judge
Semantic cacheAI infrastructure: A cache keyed by the meaning of a question (via embeddings) rather than exact text, so a near-duplicate question can reuse a stored answer without calling the LLM. Risky when answers depend on user or time.Embedding Cache
Semantic chunkingRAG & embeddings: Placing chunk boundaries where the topic changes, detected by a drop in embedding similarity between consecutive sentences. Costs an embedding pass at ingest time.Chunking Recursive chunking
Semantic HTMLFrontend: Using elements for their meaning (`button`, `nav`, `label`, `h1`–`h6`) so browsers and assistive technology get roles, focus and keyboard behaviour for free.ARIA Accessibility tree
Semantic searchRAG & embeddings: Search by meaning rather than exact keywords, usually via embeddings.
Semi-synchronous replicationDistributed systems: The leader waits for at least one of several followers (or a quorum) before acknowledging. A compromise between durability and write latency.Synchronous replication Read/write quorum (R + W > N)
SEOSearch Engine OptimizationFrontend: Making pages discoverable and well ranked by search engines. Crawlers do best when the meaningful content is in the initial HTML.SSR SSG
Sequence numberNetworking: TCP numbers every byte it sends. The receiver uses the numbers to reorder segments, detect gaps and acknowledge what arrived.TCP Retransmission
ServerFundamentals: A program (and by extension, the machine running it) that listens for requests and sends back responses.Client Process
Server stateFrontend: Data whose source of truth lives on the server (hotels, bookings, prices). The frontend only holds a possibly stale copy of it.
Server state is owned remotely, shared with other users, and can change without the frontend knowing. Treat it as a cache with freshness, refetching and invalidation, not as variables you own.
Client (UI) state Server-state cache
Server-state cacheFrontend: A client library (TanStack Query, SWR, Apollo) that caches API responses by key and handles loading, refetching, deduplication and invalidation.Server state Optimistic update
ServerlessCloud: A cloud model where you deploy code or use managed services without managing servers; the provider scales capacity automatically and bills per use. Servers still exist, you just don't operate them.FaaS Cold start Scale to zero
Service (Kubernetes)Containers: A stable virtual address that load-balances traffic across the ready pods matching a label, even as pods come and go.Pod Load balancer
Service meshSecurity: A layer of sidecar or node proxies that handles service-to-service traffic: mTLS with automatic certificates, retries, and identity-based authorization policies, without changing app code.mTLS Microservices
Session (server-side)Security: Login state kept on the server (in a database or Redis), referenced by a random session id stored in a cookie. Deleting the row logs the user out instantly.Cookie JWT
SetProgramming: A collection of unique values with O(1) average membership checks (`set.has(x)`), built like a hash map without values.Hash map
Shadow trafficalso called traffic mirroring or dark trafficDevOps: Copy real production requests to the new version while users only ever get the old version's responses. Tests behaviour and load with zero user impact, but side effects must be disabled.Canary deployment
Shard keyDatabases: The column used to decide which shard stores a row (e.g. hotel_id). It determines balance, which queries hit one shard, and how painful growth is.Sharding Partition key Hot shard
ShardingSystem design: Splitting one dataset across several databases by a key (e.g. user id) so each holds only part of it.Replication
Shared responsibility modelCloud: The split of security and operations duties between a cloud provider and you. The more managed the service, the more the provider owns, but data, access and configuration always stay yours.Managed service
Shared-nothingArchitecture: An architecture where instances share no memory or local disk; any coordination goes through an external store. It is what makes adding instances nearly linear.Stateless Horizontal scaling
Short-term memory (AI)Agents & tools: What an assistant knows within one conversation or task: the messages and tool results currently sent in the context window, often trimmed or summarised.Context window Long-term memory (AI)
Side effectProgramming: Anything a function does beyond returning a value: writing to a database, sending an email, mutating a shared object, reading the clock.Pure function
Sidecar containerContainers: A helper container running in the same pod as the app (sharing its network), e.g. a mesh proxy or log shipper. Adds CPU, memory and startup ordering concerns to every pod.Pod Service mesh
SIGTERMReliability: The polite stop signal sent to a process. Kubernetes sends it first, waits the grace period (30 s by default), then sends SIGKILL, which can't be caught.Graceful shutdown preStop hook
Similarity thresholdRAG & embeddings: A cut-off score below which a retrieved result is treated as 'no match'. Only meaningful for one specific embedding model and must be calibrated on labelled examples.Cosine similarity Recall@k
Single point of failureReliability: A component whose failure alone takes the whole service down because nothing else can do its job. Often abbreviated SPOF.N+1 redundancy Failover
SIP trunkSIP: Session Initiation ProtocolNetworking: A virtual phone line that connects a phone number to your systems over the internet using SIP for call setup and RTP for the audio.PSTN WebRTC
SLAService Level AgreementReliability: A contractual promise about availability or performance, usually with penalties.SLO
SLIService Level IndicatorReliability: A measured number describing service health from the user's point of view, e.g. the share of checkout requests that succeed in under 500 ms.SLO SLA
Sliding window (conversation)Agents & tools: Keeping only the last N turns or tokens of a conversation in context and dropping older ones. Cheap and predictable, but the assistant forgets anything outside the window.Context window Context compaction
SLOService Level ObjectiveReliability: An internal target for a service level, e.g. 99.9% of requests succeed within 300 ms.SLA
SlopsquattingSecurity: Registering a package under a name that AI coding tools tend to invent, so that code which installs the hallucinated package pulls in the attacker's version.Lockfile SCA
Smoke testTesting: A tiny, fast check right after a deploy (does it start, does /health answer, can I log in) that catches catastrophic breakage.Staging environment Health check
SNIServer Name IndicationNetworking: A TLS extension where the client says which hostname it wants during the handshake, so one IP address can serve certificates for many domains.TLS handshake TLS certificate
Snowflake IDDistributed systems: A 64-bit id built from a timestamp, a machine id and a per-machine sequence, so many servers can generate unique, roughly time-ordered ids without coordinating.
Soak testTesting: A test that holds realistic load for hours to find slow problems: memory leaks, connection leaks, growing queues, disks filling up.Load test Stress test
SOC 2System and Organization Controls 2Security: An independent audit report on a company's security, availability and confidentiality controls. Enterprise customers often ask vendors (and you) for one.
SoftmaxAI foundations: The function that turns a list of scores into probabilities that add up to 1: exponentiate each score, divide by the total. Larger gaps between scores give a more peaked distribution.Logit Temperature
Software architectureArchitecture: The important, hard-to-change decisions about how a system is split into parts and how those parts communicate.Monolith Microservices
Source trust tierAI security: A label on every indexed document saying how much the system trusts its source (for example official policy, internal staff, partner, public user content). Retrieval and prompting treat tiers differently.Data provenance Metadata filtering
SpanObservability: One timed operation inside a trace (an HTTP handler, a SQL query, a call to a payment API), with a start time, duration, parent span and attributes.Distributed tracing
Sparse retrievalRAG & embeddings: Search by matching terms, typically with BM25 over an inverted index. Each document is a sparse vector of word weights. Strong on exact tokens like error codes and SKUs, blind to synonyms.BM25 Dense retrieval Inverted index
Spec (feature specification)Building with AI: A short written description of a change before anyone builds it: the problem, who it is for, the rules, acceptance criteria, non-goals and open questions.Acceptance criteria Non-goals
Speech-to-speech modelAI infrastructure: A realtime model that takes audio in and produces audio out directly, without a separate text transcription and synthesis step. Lower latency and more natural prosody, less control.ASR TTS WebRTC
Spend limitAgents & tools: A hard cap on money an agent or user can consume or move: token spend per run or per day, refund amount per action, total payments per session. Enforced by the runtime, not requested in the prompt.Step budget Rate limiting
Spike (architecture)Building with AI: A short, time-boxed experiment that answers one risky question ("can the database take this load?") with a measurement. The code is thrown away; the answer is kept.ADR Decision driver
Spike testTesting: A test that jumps traffic suddenly (for example 10× in seconds) to check autoscaling, queues and rate limits react before users see errors.Load test Autoscaling
Split brainDistributed systems: Two nodes both believing they are the leader (often after a network partition) and both accepting writes, which corrupts or forks data.Quorum Fencing token
Spot / preemptible instanceCost engineering: Spare cloud capacity sold at a deep discount that the provider can reclaim with little notice. Good for interruptible work like batch jobs and CI; bad for a single database.Reserved capacity
SpotlightingAI security: Marking untrusted content so the model can tell it apart from instructions: delimiters, data-marking every line, or encoding. Lowers injection success rates; does not eliminate them.Indirect prompt injection Prompt injection
SpyTesting: A wrapper that lets the real function (or a stub) run while recording its calls, so a test can check what happened without replacing behaviour.Mock
SQLStructured Query LanguageDatabases: The language for querying relational databases: SELECT, INSERT, UPDATE, DELETE, JOIN.Database PostgreSQL
SQL injectionSecurity: An attack where input is concatenated into SQL text, so characters like a quote end the string and the rest runs as code. Prevented by parameterized queries.Parameterized query OWASP Top 10
SSDSolid-State DrivePerformance & scale: Flash-based storage with no moving parts. A random read takes tens to ~100 microseconds, roughly 100× faster than a spinning hard disk seek.RAM IOPS
SSEServer-Sent EventsNetworking: A simple standard for a server to stream events to the browser over one long-lived HTTP response. One-way (server → client), with automatic reconnection.WebSocket Polling / long polling
SSGStatic Site GenerationFrontend: Pages are rendered to HTML at build time and served from a CDN. Fastest and cheapest, but only as fresh as the last build.ISR SSR CDN
SSRServer-Side RenderingFrontend: The server fetches data and renders full HTML for each request. Fast first content and fresh data, at the cost of server work per request and a slower TTFB.CSR SSG Hydration TTFB
SSRFServer-Side Request ForgerySecurity: An attack that makes your server fetch a URL the attacker chooses, often an internal address like a cloud metadata endpoint, using the server's network position and credentials.OWASP Top 10 Allowlist
StackProgramming: Last in, first out (LIFO): push and pop at the same end, both O(1). Function calls, undo history and depth-first search use one.Message queue
Stack traceProgramming: The list of function calls that were active when an error was created, with file and line numbers. The first thing you need to debug a crash.Exception Structured logging
Staging environmentDevOps: A production-like environment where a release is deployed and tested before it reaches real users.Smoke test
StakeholderBuilding with AI: Anyone who is affected by a project or can affect it: the CTO who owns the budget and risk, the PM who owns the outcome, support, finance, partner hotels.Risk register
Stale indexRAG & embeddings: A retrieval index that still holds old versions of documents (or misses new ones) because re-ingestion lags behind the source. Produces confident, well-cited, outdated answers.RAG Vector database
Startup probeReliability: A Kubernetes probe for slow-booting containers: liveness and readiness checks are held off until it succeeds, so a 90-second startup isn't mistaken for a hang.Liveness probe Readiness probe
StatelessSystem design: A service that keeps no per-user data in memory between requests, so any instance can handle any request.Horizontal scaling
Static typingProgramming: Types are checked before the program runs (TypeScript, Java, Go, Rust), so many mistakes fail at compile time instead of in production.Dynamic typing TypeScript
Statistical significanceProduct engineering: A result is statistically significant when a difference that large would be unlikely (below a chosen threshold, often 5%) if the change had no real effect.
Significance says the effect is probably not noise. It does not say the effect is large, important, or that the causal story you tell about it is right.
p-value Confidence interval Minimum detectable effect
Status codeFundamentals: Three-digit result of an HTTP request: 2xx success, 3xx redirect, 4xx client error, 5xx server error.HTTP
stdiostandard input/outputFundamentals: The text streams every process has. The MCP stdio transport launches the server as a local child process and exchanges messages over its stdin/stdout.Streamable HTTP
Step budgetAgents & tools: A hard cap enforced by the runtime on an agent run: maximum iterations, tool calls, tokens, wall-clock time or money. When it is hit, the run stops or escalates.AI agent ReAct
Sticky bucketingDevOps: Assigning a user to a rollout bucket with a stable hash of their id, so they see the same variant on every request and device.Flag targeting A/B test
Sticky sessionArchitecture: A load balancer setting that sends all requests from one client to the same server, usually via a cookie. Lets servers keep per-user state in memory, at the cost of uneven load and lost state on crash.Stateless Load balancer Session (server-side)
Stop sequenceLLM engineering: A string that ends generation as soon as the model produces it, e.g. a closing tag. Useful to stop the model running past the part you need.max_tokens
Straight-through processingProduct engineering: The share of documents processed end to end with no human touch. The business metric for extraction systems, always read alongside the error rate of what went straight through.Field-level confidence Human-in-the-loop
Strangler fig patternBuilding with AI: Replacing an old system gradually: new code takes over one slice of behaviour at a time through a seam, until the old code serves nothing and can be removed. Named by Martin Fowler after a fig that grows around a tree.Seam (in code)Legacy code Expand/contract migration
Streamable HTTPAgents & tools: The MCP transport for remote servers: the client POSTs JSON-RPC messages to one HTTP endpoint and the server may stream responses back. Needs real authentication.stdio HTTP OAuth
StreamingLLM engineering: Sending generated tokens to the client as they are produced instead of waiting for the full answer. Improves perceived latency, not total cost.Token Latency
Stress testTesting: A test that pushes load beyond expected peak until something breaks, to learn the breaking point and how the system fails (gracefully or catastrophically).Load test Soak test Spike test
Strict tool schemaAgents & tools: A tool definition whose JSON Schema forbids extra properties and lists every required field, often combined with a provider's strict or constrained mode so the model's arguments always parse. It guarantees shape, not correctness.JSON Schema Constrained decoding
Strong consistencyDistributed systems: Every read returns the most recent committed write, as if there were a single copy of the data. Also called linearizability in its strictest form.Eventual consistency
Structured loggingObservability: Writing logs as fields (usually JSON) such as requestId, userId and error, instead of free text, so they can be searched, filtered and aggregated.Observability Stack trace
Structured outputsLLM engineering: An API mode where you pass a JSON Schema and the provider guarantees the response parses and matches it, usually by constraining which tokens the model may generate.Constrained decoding JSON Schema
StubTesting: A test double that returns canned answers so the code under test can run. It does not check how it was called.Test double (mock, stub, fake)Mock
Sub-agentBuilding with AI: A helper agent that the main agent starts for one job (search the code, research a library), with its own fresh context. It returns a short report, keeping the main session's context clean.Claude Code Context window
SubnetCloud: A slice of a VPC's IP range that lives in one availability zone. Whether it is 'public' or 'private' depends only on its route table.VPC Route table CIDR block
Superseded ADRArchitecture: An ADR replaced by a newer one. It is not edited or deleted; its status changes to 'Superseded by ADR-00NN' so the history of reasoning stays intact.ADR
Supervised learningAI foundations: Learning from examples that come with the right answer (a label), e.g. past bookings labelled 'no-show' or 'showed up'.Unsupervised learning Reinforcement learning (RL)
Synchronous replicationDistributed systems: The leader waits for a follower to confirm a write before acknowledging the client. No acknowledged write is lost if the leader dies, but every write pays an extra round trip.Asynchronous replication Replication lag
System callFundamentals: A request from a program to the kernel, such as read(), write(), open() or socket(). Crossing into the kernel costs time, which is why batching I/O helps.Kernel Operating system
System promptLLM engineering: Instructions from the application developer that set the model's role, rules and output format.

T

Tail latencyPerformance & scale: The slow end of the latency distribution (p99, p99.9, max). Caused by GC pauses, cold caches, queueing, retries and noisy neighbours, and amplified when requests fan out.p99 latency Fan-out (requests)
Tail samplingObservability: Deciding whether to keep a trace after it finishes, so you can keep every error and slow request and only a few healthy ones. Needs a collector that buffers whole traces.Head sampling OpenTelemetry Collector
TCOTotal Cost of OwnershipCost engineering: The full cost of a choice over its life: infrastructure plus engineering time, on-call, licences, migrations and the cost of failures.Managed service
TCPTransmission Control ProtocolNetworking: Delivers a reliable, ordered stream of bytes between two machines, retransmitting lost packets.UDP IP address
TCP three-way handshakeNetworking: SYN, SYN-ACK, ACK: the client and server agree on starting sequence numbers before any data flows. Costs one RTT before the first request can be sent.TCP RTT TLS
Technical debtProduct engineering: The future cost of shortcuts taken now. Like financial debt, it can be smart if taken deliberately and repaid.
TemperatureAI foundations: A sampling setting: low means predictable, high-probability tokens; high means more varied, riskier choices.
Tenant isolationSecurity: Guaranteeing that one customer organisation in a multi-tenant SaaS can never read or change another's data, enforced at every layer.Row-level security IDOR
TerraformDevOps: A widely used declarative IaC tool: you describe the desired resources in HCL, it computes a plan of changes and applies them through provider APIs. OpenTofu is an open-source fork.IaC Terraform state
Terraform moduleDevOps: A reusable, parameterised group of resources (e.g. 'a VPC with three private subnets') called from other configurations.Terraform
terraform planDevOps: The dry run that shows what Terraform would create, change or destroy to make reality match the code. Review it before apply.Terraform state
Terraform stateDevOps: The file mapping each resource in your code to the real object in the cloud (its id and attributes). Terraform diffs code against it to plan changes. Store it remotely, locked and encrypted.Terraform Drift
Test data factoryTesting: A function that builds valid test objects with sensible defaults, letting each test override only the fields it cares about, e.g. buildBooking({ nights: 0 }).Test fixture
Test double (mock, stub, fake)Testing: A stand-in for a real dependency in a test. Stubs return canned answers, mocks verify calls, fakes are simple working versions (an in-memory repository).Unit test
Test fixtureTesting: The known state a test starts from: seed rows in a database, a sample file, a configured object. Shared fixtures are convenient but couple tests together.Test data factory
Test weakeningBuilding with AI: Making a failing test pass by changing the test instead of the code: editing the expected value, skipping it, or loosening the check. The bug stays; the alarm goes quiet.Unit test Flaky test
TestcontainersTesting: A library family that starts real dependencies (Postgres, Redis, Kafka) in throwaway Docker containers during tests, so integration tests run against the real engine instead of a mock.Integration test Container
Testing pyramidTesting: A guideline for test suite shape: many fast unit tests at the base, fewer integration and contract tests in the middle, and a thin layer of end-to-end tests on top.Unit test End-to-end (e2e) test
ThreadFundamentals: A unit of execution inside a process; threads share the process's memory.Process
Three-point estimateBuilding with AI: An estimate given as best case, likely case and worst case instead of one number, so the uncertainty is visible and can be planned for.Critical path
ThroughputPerformance & scale: How many operations a system completes per unit of time, e.g. 5,000 requests per second.Latency
Time to first audioAI infrastructure: The voice equivalent of TTFT: milliseconds from the moment the caller stops speaking to the moment they hear the agent's first sound. Around 800 ms or less feels conversational.TTFT Latency budget
TimeoutDistributed systems: A maximum time to wait for another system. Without one, a slow dependency ties up your threads and connections until you fail too.Circuit breaker
TLSTransport Layer SecuritySecurity: The encryption protocol behind HTTPS; it also proves the server is who it claims to be via certificates.HTTPS
TLS certificateSecurity: A signed document binding a domain name to a public key. Browsers trust it only if it chains up to a certificate authority they already trust, and only until it expires.Certificate authority TLS TLS handshake
TLS handshakeSecurity: The exchange at the start of a TLS connection where client and server agree on a cipher, the server proves its identity with a certificate, and both derive shared encryption keys. TLS 1.3 needs one round trip.TLS TLS certificate TCP three-way handshake
tmpfs mountContainers: An in-memory filesystem mounted into a container. Fast and never written to disk; contents vanish when the container stops.Bind mount Volume
ToilReliability: Manual, repetitive operational work that scales with the system and adds no lasting value: patching, resizing disks, restarting stuck nodes. A hidden cost of self-hosting.On-call Runbook
TokenAI foundations: The unit an LLM reads and writes: a word or word-piece. Roughly 4 characters of English text.LLM Context window
Token embeddingAI foundations: The vector a model looks up for each token id before processing it. Similar tokens end up with similar vectors; the layers then refine these vectors using context.Embedding Transformer
Token passthroughAI security: An anti-pattern where a server forwards the access token it received from a client to a downstream API. It breaks audience checks and auditing; a server should use its own credential for downstream calls.OAuth Least privilege
Token revocationSecurity: Invalidating a credential before it naturally expires (logout, stolen device, fired employee). Trivial for server sessions, hard for self-contained tokens.JWT Refresh token
TokenizerAI foundations: The component that splits text into tokens (and maps them to integer ids) before the model sees it, and turns ids back into text afterwards.Token LLM
Tool callingAgents & tools: The model outputs a structured request (name + JSON arguments) for your code to run a function, then reads the result.AI agent MCP
Tool descriptionAgents & tools: The natural-language text attached to a tool definition. The model reads it to decide when to call the tool and how to fill its arguments, so it is effectively the tool's only documentation.Tool calling JSON Schema
Tool error resultAgents & tools: A tool result flagged as an error (for example is_error: true) with a short, actionable message the model can use to correct its arguments, try another path, or tell the user.Tool result Transient error
Tool permissions (coding agent)Building with AI: The rules for which actions a coding agent may take without asking: editing files, running commands, using the network. Anything not allowed pauses for your approval.Least privilege Approval gate
Tool poisoningAI security: Hiding malicious instructions in a tool's name, description or results, so the model follows them when it reads the tool list.Prompt injection MCP server
Tool resultAgents & tools: The message your code sends back to the model after running a tool: the output, or an error, tied to the tool call's id.Tool calling
Top-k samplingAI foundations: Keep only the k most likely tokens at each step, renormalise, and sample among them. Simple, but a fixed k is too loose when the model is sure and too tight when it isn't.Top-p (nucleus) sampling Temperature
Top-p (nucleus) samplingAI foundations: A sampling setting that only considers the smallest set of tokens whose probabilities add up to p (e.g. 0.9), cutting off the unlikely tail.Temperature
Topic (Kafka)Distributed systems: A named, append-only stream of events, such as `bookings`, split into partitions.Kafka Partition
TPM limitTokens Per MinuteAI infrastructure: A rate limit counted in tokens rather than requests. Providers enforce TPM and RPM (requests per minute) per account; gateways enforce their own per tenant so one noisy customer can't exhaust the shared quota.Rate limiting Token
Trade-offTrade-offs: Gaining one property by giving up another. Every architecture decision is one.
Trajectory evalAgents & tools: An evaluation that scores the path an agent took (right tools, right order, no forbidden actions, step count) in addition to the final outcome.Eval Agent trajectory
TransactionDatabases: A group of database operations that succeed or fail together.ACID
Transactional outboxDistributed systems: Write the business change and an 'event to publish' row in the same database transaction; a relay publishes the row later. No lost or phantom events.Transaction Event Message queue
TransformerAI foundations: The neural-network architecture behind modern LLMs. Its attention mechanism lets every token look at every other token in the context.LLM Deep learning
Transient errorReliability: A failure likely to succeed if retried later: a timeout, a dropped connection, HTTP 503 or 429. Contrast with validation errors and bugs, which fail the same way every time.Timeout Circuit breaker Idempotency
TreeProgramming: A hierarchy of nodes with one root and no cycles (file systems, the DOM, org charts). Balanced search trees keep data sorted with O(log n) operations.B-tree Graph
Trunk-based developmentDevOps: A branching style where everyone integrates small changes into one main branch (the trunk) at least daily, using short-lived branches and feature flags.GitFlow Feature flag
TTFBTime To First BytePerformance & scale: Time from sending a request until the first byte of the response arrives. Includes network round trips and any server work done before responding.Latency SSR
TTFTTime To First TokenAI infrastructure: How long until the first output token arrives. Dominated by queueing and prompt prefill; it is what users feel as 'responsiveness' in a streaming UI.Prefill and decode Streaming
TTL (DNS)Time To LiveNetworking: How many seconds a DNS answer may be cached by resolvers and clients. A long TTL means fewer lookups; a short TTL means changes propagate faster.DNS DNS resolver Cache
TTSText-To-SpeechAI infrastructure: Synthesising spoken audio from text. Streaming TTS starts playing audio for the first sentence before the rest of the text exists.ASR
Two-way doorTrade-offs: A decision or change you can reverse quickly and cheaply, like a flagged UI change or a revert of an internal tool. Move fast through these.One-way door
TypeScriptProgramming: JavaScript plus a static type system. Types are checked at build time and erased, so they don't validate data arriving at runtime.Static typing JSON Schema

U

UDPUser Datagram ProtocolNetworking: Fire-and-forget packets: no ordering or retransmission, so lower overhead. Used for video calls, games, DNS.TCP
Unit economicsCost engineering: Cost (and revenue) per unit of business value: per booking, per active user, per API call. Turns 'the bill went up' into 'cost per booking went from €0.08 to €0.10'.Cost allocation tag TCO
Unit testTesting: A test of one function or class in isolation, with no network, database or filesystem. Runs in milliseconds and points at the exact failing logic.Integration test Test double (mock, stub, fake)
Unknown outcome (timeout ambiguity)Distributed systems: When a call times out you cannot tell whether the request was lost, processed, or processed with the reply lost. The caller must handle all three.Timeout Idempotency key
Unsupervised learningAI foundations: Finding structure in data without labels, e.g. grouping guests into segments by behaviour. Predicting the next word of raw text is a close cousin, called self-supervised learning.Supervised learning
URL stateFrontend: State stored in the URL path or query string (`?city=lisbon&page=2`) so it survives reloads and can be shared, bookmarked and navigated with Back.Client (UI) state
USE methodUtilization, Saturation, ErrorsObservability: For every resource (CPU, disk, connection pool, queue), chart how busy it is, how much work is waiting, and its error count. Finds the exhausted resource.RED method
User interviewProduct engineering: A structured conversation with a real or potential user about their past behaviour and problems, used as evidence for product decisions.
Good interviews ask about specific recent events ("Tell me about the last time you changed a booking") rather than hypotheticals ("Would you use…?"), which people answer optimistically.
Jobs to be done

V

VADVoice Activity DetectionAI infrastructure: A small, fast model that classifies short audio frames (10–30 ms) as speech or non-speech. The building block for turn detection and barge-in.Endpointing (turn detection)Barge-in
Validation / test setAI foundations: Examples held back from training and used only to measure the model. The gap between training and validation performance is how you detect overfitting.Overfitting Golden dataset
Vector databaseRAG & embeddings: A database optimised to store embeddings and quickly find the nearest ones to a query vector.Embedding pgvector
Vector quantizationRAG & embeddings: Storing vectors with fewer bits per number (e.g. 8-bit integers or 1 bit per dimension instead of 32-bit floats) to cut memory 4–32×, at some loss of recall usually recovered by rescoring.HNSW ANN
Vendor exit planTrade-offs: A written answer to 'how would we leave this vendor?': data export format, contract notice, the code that would change, and a rough migration cost.Vendor lock-in Anti-corruption layer
Vendor lock-inTrade-offs: How expensive it would be to leave a provider, because your system depends on its specific APIs, data formats or features.Managed service
Verbosity biasLLM engineering: An LLM judge's tendency to rate longer, more detailed-looking answers higher even when they are not more correct.LLM-as-judge Judge rubric
Vertical scalingPerformance & scale: Making one machine bigger (more CPU/RAM). Simple, but it has a ceiling and a single point of failure.Horizontal scaling
Vertical sliceBuilding with AI: A piece of work that cuts through every layer (data, API, screen) to deliver one small thing a user can actually use, instead of finishing one layer at a time.Walking skeleton Acceptance criteria
Virtual API keyAI infrastructure: A key issued by your AI gateway to an internal team or service. The real provider keys stay inside the gateway; virtual keys carry budgets, allowed models and rate limits, and can be revoked without rotating provider credentials.AI gateway Secrets manager
Virtual machineCloud: An emulated computer with its own full operating system, running on a hypervisor.Container
Virtual memoryFundamentals: Each process sees its own private address space; the OS and hardware map those addresses onto physical RAM pages. This isolates processes and lets the OS move pages to disk.Process RAM Page fault
Visibility timeoutBackend: How long a queue hides a message after a worker takes it. If the worker doesn't acknowledge it in time, the message reappears for another worker.Message queue At-least-once delivery
Vision-language modelAI infrastructure: A model that takes images (and text) as input and produces text. It can describe, classify and read images, but it reasons over a downscaled version and can confidently misjudge small details, counts and measurements.Image tokens LLM
VolumeContainers: Storage managed outside a container's writable layer, so data survives when the container is removed or replaced.Container
VPCVirtual Private CloudCloud: Your own isolated private network inside a cloud provider, with an IP range you choose. Nothing reaches resources inside it unless you add routes and rules.Subnet CIDR block Security group
VPC peeringCloud: A private, non-transitive link between two VPCs so their resources talk over private IPs. The two IP ranges must not overlap.VPC CIDR block Route table
VPNVirtual Private NetworkSecurity: An encrypted tunnel that makes a remote machine or network behave as if it were on a private network, e.g. an engineer's laptop reaching private databases, or an office linked to a cloud network.VPC TLS
VRAMVideo RAM (GPU memory)AI infrastructure: The memory on a GPU. Model weights plus the KV cache for all in-flight requests must fit in it, which is what usually limits model size and concurrency when self-hosting.KV cache Quantization (model)

W

W3C Trace ContextObservability: The standard `traceparent` HTTP header that carries the trace id and parent span id between services, so their spans join one trace.Distributed tracing Span
WAFWeb Application FirewallSecurity: An L7 filter that inspects HTTP requests and blocks known attack patterns (SQL injection, XSS, bad bots) and can rate-limit by rule. It reduces risk; it does not fix vulnerable code.Firewall Reverse proxy Rate limiting
Walking skeletonBuilding with AI: The thinnest version of a system that works end to end, through every layer, for one tiny case. Built first, so integration problems show up in week 3, not week 10.Vertical slice
Warm standbyReliability: A DR strategy where a scaled-down but fully working copy of production runs in a second region with replicated data. Failover means scaling it up and shifting traffic: minutes.Pilot light Active-active
Watermelon statusBuilding with AI: A project reported green on the outside while it's red on the inside: every update says "on track" until it suddenly isn't. Usually caused by reporting activity (tasks done) instead of outcomes and risks.RAG status Risk register
WCAGWeb Content Accessibility GuidelinesFrontend: The W3C standard for web accessibility, with testable success criteria at levels A, AA and AAA. Level AA is the usual legal and contractual target.Accessibility (a11y)
WebhookBackend: An HTTP request one system sends to a URL you registered when something happens on its side ("payment succeeded"). A reverse API call: they call you.API HTTP
WebRTCWeb Real-Time CommunicationNetworking: A browser and mobile standard for low-latency audio/video, usually over UDP, with built-in jitter buffering, echo cancellation, codecs and NAT traversal.WebSocket UDP Jitter buffer
WebSocketNetworking: A protocol that upgrades an HTTP connection into a long-lived, two-way channel where both client and server can send messages at any time.SSE Polling / long polling
Weights (parameters)AI foundations: The numbers inside a model that training adjusts. A large language model has billions of them; at inference they are frozen and simply read.Neural network Gradient descent
Wide-column storeDatabases: A distributed database where rows are grouped by a partition key and sorted by a clustering key. Handles massive write volumes; queries must follow the key design.Partition key Sharding
WIP limitWork-in-progress limitBuilding with AI: A cap on how many things can be in progress at once (for example two open pull requests per person). It keeps queues short, so work finishes instead of piling up.Bottleneck
WorkerBackend: A background process that takes jobs from a queue and processes them outside the user's request.Message queue
Workflow (AI)Agents & tools: A system where LLM calls and tools are chained along a path your code defines in advance. Predictable, testable, cheaper than an agent.AI agent Agentic system
Working treeDevOps: The files on disk right now, including changes not yet committed. Git can only bring back what was committed (or stashed).Commit
Workload identitySecurity: An identity given to a running service (not a human), proven by short-lived certificates or tokens issued by the platform instead of long-lived keys baked into config.IAM mTLS
Write skewDatabases: Two transactions each check a condition ("at least one manager stays on call"), then write different rows that together break it. Only Serializable isolation or explicit locks prevent it.Isolation level SELECT … FOR UPDATE
Write toolAgents & tools: A tool with side effects: it creates, changes, sends or charges something. Write tools need authorization, idempotency and often human confirmation; read tools usually do not.Side effect Approval gate
Write-ahead log (WAL)Write-Ahead LogDatabases: An append-only log on disk where the database records each change before applying it. Gives durability after a crash and feeds replication.ACID Replication
Write-back cachePerformance & scale: Writes go only to the cache and are flushed to the database later in batches. Very fast writes, but unflushed data is lost if the cache crashes. Also called write-behind.Write-through cache
Write-through cachePerformance & scale: Every write updates the cache and the database together, synchronously. Reads stay fresh; writes pay for both.Write-back cache Cache-aside

X

XSSCross-Site ScriptingSecurity: An attack where malicious JavaScript runs inside your page, able to read anything JavaScript can read, including tokens in localStorage.Cookie

Z

Zero trustSecurity: A security model where network location grants nothing: every request is authenticated, authorized and encrypted based on user and device identity, whether it comes from inside or outside.mTLS Least privilege
Zero-shot promptingLLM engineering: Asking the model to do a task from instructions alone, without examples. Works well for common tasks with capable models; examples help for unusual formats or judgement calls.Few-shot prompting
ZodProgramming: A TypeScript library for declaring schemas once and getting both runtime validation and static types. Commonly converted to JSON Schema for LLM structured output and used to validate the result.JSON Schema TypeScript
ZooKeeperDistributed systems: A coordination service with a replicated, consistent tree of small nodes, watches and ephemeral nodes. Historically used by Kafka, Hadoop and many others for leader election and config.etcd Consensus