---
name: engineering-terms
description: Find the standard engineering term for a problem described in plain words, then apply its technique and check. Use when a request describes a bug, behavior, or requirement without naming the technique (for example "the button submits twice", "search shows old results", "tests pass alone but fail together"), or before writing code for a vague request.
---

# Engineering terms

A glossary of 323 engineering terms from Vibe Coding 101 (https://vibe-coding-101.brighteng.org/). Each term names a known technique, when it applies, how to do it, and how it fails.

## How to use

1. Read the request and name the underlying problem in engineering words.
2. Find candidate terms in the index below. For details, search `references/terms.md` for `## <id>` or for words from the request.
3. Tell the user which term applies, in one line, before you change code.
4. Follow the term's **Do** steps and its check. Watch for its **Avoid** case. Where a worked example is linked, use its failure, exact runnable check, limits, and primary sources. An illustrative check does not prove your production change.
5. If no term fits, say so and proceed normally. Do not force a term onto a request.

## Index

### development workflow

- `tdd` test-driven development: Let one failing example drive the next implementation.
- `refactoring` refactoring: Change internal structure while preserving observable behavior.
- `repro` minimal reproduction: The smallest repeatable case that still shows the bug.
- `root-cause-analysis` root cause analysis: Find the mechanism that produces the failure.
- `git-worktree` git worktree: A separate checkout and index sharing the same Git repository.
- `verification` verification: Check the claimed result against fresh evidence.
- `reverse-engineering` reverse engineering: Recover a behavioral specification from an existing system.
- `characterization-test` characterization test: Record the behavior an existing implementation exhibits.
- `spike` spike: A short investigation answers one technical unknown.
- `walking-skeleton` walking skeleton: A minimal working path connects the application’s essential layers.
- `vertical-slice` vertical slice: Implement one usable behavior across the layers it requires.
- `strangler-fig` strangler fig: Replace an existing system incrementally by routing selected behavior to a new implementation.
- `spec-driven` executable specification: An executable specification makes requirements checkable.
- `bdd` behaviour-driven development: Describe behavior through concrete examples shared by developers and domain experts.
- `ubiquitous-language` ubiquitous language: Use a shared domain vocabulary in requirements, code, and conversations.
- `yagni` YAGNI: Avoid implementing capabilities before a current requirement justifies them.
- `contract-first` contract-first design: Define an interface before implementing its producers and consumers.
- `partial-stage` partial staging: Partial staging selects changes within a file for the next Git commit.

### agents and AI

- `context-engineering` context engineering: Select and maintain the information an agent needs for the current task.
- `tool-use` tool calling: Tool calling lets a model request a defined operation from an application.
- `human-in-the-loop` human in the loop: A person reviews a decision at a defined point in an automated workflow.
- `evals` evals: An evaluation measures an AI system on a defined set of tasks and criteria.
- `guardrails` guardrails: Enforce explicit limits around automated actions.
- `diff-review` diff review: Review the changes introduced by a patch, including tests and configuration.
- `few-shot` few-shot prompting: Few-shot prompting provides worked examples of the desired task behavior.
- `structured-output` structured output: Constrain model output to a defined structure and validate it at the boundary.
- `mcp` MCP: Model Context Protocol standardizes how applications expose tools and context to AI clients.
- `sandbox` sandbox: A sandbox restricts the resources a process can access.
- `embedding` embedding: An embedding represents data as a numerical vector for a particular model and task.
- `rag` retrieval-augmented generation: Retrieval-augmented generation supplies retrieved material to a model before it answers.
- `holdout` holdout set: A holdout set is reserved for evaluating behavior beyond the examples used for development.
- `baseline` baseline: A baseline is a credible comparison under the same evaluation conditions.
- `quantization` quantization: Quantization represents model values with reduced numerical precision.
- `agents-md` repository instructions: Repository instructions document conventions and commands an agent should use.

### code design

- `deep-module` deep module: A small interface hides a substantial useful implementation.
- `seam` seam: A place where behavior can be replaced without editing its consumer.
- `composition` composition: Build a variation by assembling smaller parts.
- `compound-components` compound components: Related components cooperate through a shared parent.
- `component-variant` component variants: Name the supported forms of a component explicitly.
- `dependency-injection` dependency injection: Supply a collaborator through a contract instead of constructing it inside.
- `types-as-spec` type-driven development: Type-driven development uses types to express a design before filling in its implementation.
- `separation-of-concerns` separation of concerns: Separate responsibilities that change for different reasons.
- `leaky-abstraction` leaky abstraction: An abstraction exposes details callers still need to understand.
- `technical-debt` technical debt: A design shortcut creates a continuing cost for future changes.
- `semver` semantic versioning: Semantic versioning communicates compatibility of a declared public API.
- `breaking-change` breaking change: A change requires an existing consumer to adapt.
- `observability` observability: Expose evidence that helps explain a system’s behavior.
- `adr` architecture decision record: An architecture decision record captures a consequential choice and its context.
- `invariant` invariant: A condition must remain true across permitted operations.
- `strategy` strategy pattern: A strategy supplies interchangeable behavior behind a shared contract.
- `adapter` adapter pattern: An adapter translates an existing interface into the interface its caller expects.
- `service-layer` service layer: An application service coordinates a use case across entry points.
- `repository` repository pattern: A repository exposes persistence operations needed by the application.
- `feature-folder` feature-based organization: Feature-based organization keeps related implementation close to the capability it serves.
- `ownership` ownership: Ownership defines which part of a program controls a value’s lifetime.
- `state-machine` state machine: A state machine describes states and permitted transitions driven by events.

### frontend and browser state

- `lifting-state` lifting state: Move shared state to the nearest owner that can coordinate its users.
- `derived-state` derived state: Calculate a value from state you already have.
- `effect-deps` effect dependencies: The reactive inputs that determine when an effect must resynchronize.
- `functional-update` functional state update: Compute the next state from the previous state supplied by the framework.
- `request-waterfall` request waterfall: Requests form a sequence that adds their waiting times.
- `request-deduplication` request deduplication: Share equivalent requests within a defined scope.
- `code-splitting` code splitting: Load a separate code bundle when a feature needs it.
- `suspense` Suspense boundary: Keep a useful shell visible while supported child content is waiting.
- `serialization` serialization: Encode state so it can cross a storage or process boundary.
- `schema-evolution` schema evolution: Change a stored format while handling older data deliberately.
- `event-cleanup` subscription cleanup: Release listeners and subscriptions when their owner stops using them.
- `optimistic-ui` optimistic UI: Show an expected change before the server confirms it.
- `ssr` rendering strategy: Rendering strategy determines when and where initial HTML is produced.
- `hydration` hydration: Hydration connects client-side behavior to server-rendered HTML.
- `tree-shaking` tree shaking: Tree shaking removes unused code that a bundler can prove is unnecessary.
- `controlled-input` controlled input: A controlled input gets its current value from application state.
- `progressive-enhancement` progressive enhancement: Provide a useful baseline and improve it when additional browser capabilities are available.
- `focus-management` focus management: Move and restore keyboard focus deliberately as interface context changes.
- `client-server-state` client state vs server state: Distinguish a local interaction draft from cached data owned by a server.
- `islands` islands architecture: Islands architecture adds interactive components to an otherwise server-rendered or static page.
- `rules-of-hooks` rules of hooks: React Hooks follow rules about where they can be called.
- `list-key` list key: A list key identifies an item across renders.
- `stale-closure` stale closure: A callback retains values from the environment where it was created.
- `css-specificity` CSS specificity: Specificity ranks competing selectors within the relevant cascade context.
- `stacking-context` stacking context: A stacking context groups elements into a local stacking order.
- `server-components` server components: React Server Components run outside the client bundle and can prepare UI close to server data.
- `event-delegation` event delegation: A parent listener handles suitable events from descendants.
- `service-worker` service worker: A service worker can intercept requests and manage offline behavior.
- `web-storage` web storage: Browser storage APIs offer different persistence and access models.
- `structural-typing` structural typing: Structural typing compares the shape of types rather than only their declared names.
- `shadow-dom` shadow DOM: Shadow DOM provides a component subtree with scoped DOM and styling behavior.
- `container-query` container query: A container query adapts styling to a containing context.
- `headless-ui` headless UI: Headless UI separates reusable interaction behavior from a particular visual presentation.
- `state-colocation` state colocation: Keep state near the components that own its lifecycle.
- `custom-hook` custom Hook: A React custom Hook extracts reusable stateful logic.
- `reducer` reducer: A reducer computes the next state from the current state and an action.
- `composable` composable: A Vue composable encapsulates reusable stateful logic through the Composition API.
- `scoped-slot` scoped slots: A Vue scoped slot lets a child provide data to caller-supplied content.
- `computed-vs-watch` computed vs watch: In Vue, computed values derive data while watchers respond with side effects.
- `query-key` query keys: A query key identifies cached data and the inputs that distinguish it.
- `query-freshness` freshness and cache retention: Freshness describes when cached data should be reconsidered; retention describes how long unused data remains available.
- `query-invalidation` mutation invalidation: Query invalidation marks affected cached reads stale after a change.
- `route-loader` route loader and query cache: A route loader prepares data for navigation.
- `sticky` sticky positioning: Sticky positioning keeps an element in normal flow until it reaches an offset in its scrolling context.
- `autosave` autosave: Autosave persists edits without an explicit save command.
- `event-handler` event handler: Run interaction-triggered work in the code that handles that event.

### APIs and data

- `query-plan` query plan: The operations a database chooses to answer a query.
- `db-index` database index: A data structure that can make matching rows cheaper to find.
- `composite-index` composite index: One index covers an ordered combination of columns.
- `partial-index` partial index: Index only rows that satisfy a predicate.
- `n-plus-one` N+1 query: One list query triggers another query for every result.
- `pagination` keyset pagination: Continue a list after the last returned sort key.
- `connection-pool` connection pool: Reuse a bounded set of database connections.
- `prepared-statement` parameterized query: Keep SQL structure separate from input values.
- `transaction` transaction: Commit related database changes together or roll them back.
- `deadlock` deadlock: Operations wait on resources held by one another.
- `unique-constraint` unique constraint: The database rejects duplicate values for a declared key.
- `upsert` upsert: Insert a row or update the row that conflicts with its key.
- `migration` database migration: A recorded transition from one database schema to another.
- `rls` row-level security: Database policies control which rows a role may access.
- `least-privilege` least privilege: Give each runtime identity only the permissions its job needs.
- `webhook` webhook: A service sends an HTTP request when an event occurs.
- `rest` REST: REST is an architectural style for resource-oriented interactions through a uniform interface.
- `rate-limit` rate limit: Limit how often a caller can perform an operation.
- `cache-invalidation` cache invalidation: Mark cached data stale, remove it, or refresh it when its assumptions change.
- `job-queue` job queue: A queue separates accepting work from processing it.
- `circuit-breaker` circuit breaker: Temporarily stop calls to a failing dependency and probe for recovery.
- `graceful-shutdown` graceful shutdown: Stop accepting new work and finish or hand off existing work before exiting.
- `minor-units` minor units: Represent money using integer minor units or an appropriate decimal representation with an explicit currency.
- `utc-local` UTC vs local time: Distinguish an instant from a calendar date and a local scheduled time.
- `optimistic-lock` optimistic concurrency: Accept an update only if the version being replaced still matches the version the caller read.
- `partial-update` partial update: A partial update changes only the fields identified by its contract.
- `isolation` transaction isolation: Transaction isolation defines how concurrent transactions may observe and affect one another.
- `dto` DTO: A data transfer object defines the fields crossing an application boundary.
- `websocket` WebSocket: A WebSocket provides a persistent bidirectional connection.
- `error-as-value` error as value: Represent expected failures explicitly in a function’s result.
- `option-type` option type: An option type represents a value that may be absent.
- `dataloader` DataLoader: DataLoader batches related loads and can memoize results within a chosen scope.
- `middleware-order` middleware order: Middleware ordering determines which request and response processing runs before another step.
- `data-access-layer` data access layer: A data access layer centralizes access rules and data retrieval at a boundary.
- `server-action` server action: A server action exposes a framework-supported server operation to the client.
- `etl` ETL and ELT: ETL transforms extracted data before loading it; ELT loads data before transformation.
- `partitioning` table partitioning: Table partitioning divides a logical table into physical parts.
- `backfill` backfill: A backfill populates or recomputes existing data after a rule or schema change.
- `denormalization` denormalization: Denormalization duplicates or precomputes data to serve a read pattern.
- `batch-stream` batch vs stream: Batch processing operates on bounded input; streaming processes ongoing input.
- `runtime-validation` runtime validation: Check untrusted values when the program receives them.
- `clustered-storage` physical row clustering: Place related rows near each other to reduce scattered reads.
- `normalization` normalization: Store facts according to their keys to reduce update anomalies.
- `leader-follower-replication` leader–follower replication: Send writes through a leader and replicate them to followers.
- `multi-leader-replication` multi-leader replication: Allow multiple write authorities with explicit conflict handling.
- `base` BASE: Design for availability with temporary state and eventual convergence.
- `acid` ACID: Specify atomicity, consistency, isolation, and durability for transactions.
- `strong-consistency` strong consistency: Make the exact freshness and ordering guarantee explicit.
- `write-ahead-logging` write-ahead logging (WAL): Persist the recovery log before the corresponding data pages.
- `checkpointing` checkpointing: Record a recovery boundary after making the required state durable.
- `storage-compaction` storage compaction: Merge storage runs and reclaim obsolete versions when safe.
- `data-locality` data locality: Place related data and computation close to reduce remote work.
- `hot-partition` hot partition: One partition receives more work than its capacity can handle.
- `caching` caching: Reuse a stored result with explicit freshness and failure rules.
- `materialized-view` materialized view: Persist a query result and define how it becomes current again.
- `secondary-index` secondary index: Provide another access path besides the table’s primary organization.
- `covering-index` covering index: Include the values a query needs so fewer table-row fetches may be necessary.
- `bloom-filter` Bloom filter: Reject definite misses cheaply while allowing possible false matches.
- `lsm-tree` LSM tree: Buffer writes and organize persisted data as sorted runs.
- `b-tree` B-tree: Keep keys ordered in a balanced tree for lookups and range scans.
- `query-planner` query planner: Choose an executable access path and join strategy for a query.
- `cost-based-optimizer` cost-based optimizer: Choose among query plans using estimated resource costs.
- `data-skew` data skew: Uneven values or partition sizes make some units of work much larger than others.
- `change-data-capture` change data capture (CDC): Publish source-data changes so downstream systems can follow them.
- `logical-replication` logical replication: Replicate logical table changes rather than a physical copy of storage.
- `physical-replication` physical replication: Keep a standby aligned with the primary’s physical database changes.
- `federation` query federation: Query independently managed data sources through a shared interface.
- `data-lake` data lake: Retain diverse data for later processing and analysis with governance.
- `data-warehouse` data warehouse: Integrate and model data for reliable analytical queries and reporting.
- `columnar-storage` columnar storage: Store values by column to suit selective analytical scans.
- `row-based-storage` row-based storage: Keep a row’s fields together for record-oriented access.
- `time-series-partitioning` time-series partitioning: Partition timestamped records into explicit time intervals.
- `hash-partitioning` hash partitioning: Use a hash of the partition key to assign records to buckets.
- `range-partitioning` range partitioning: Assign rows to partitions by ordered key intervals.
- `consistent-hashing` consistent hashing: Limit key reassignment when the set of storage nodes changes.
- `data-migration` data migration: Move or transform existing records with validation and a controlled cutover.
- `schema-registry` schema registry: Version message schemas and enforce a chosen compatibility policy.

### performance

- `memoization` memoization: Reuse a computed result while its inputs are unchanged.
- `reflow` layout thrashing: Alternating DOM reads and writes forces the browser to recalculate layout repeatedly.
- `critical-path` critical rendering path: The critical rendering path is the work needed before the browser can render content.
- `tail-latency` tail latency: Tail latency describes the slow end of a response-time distribution.
- `cold-start` cold start: A cold start includes initialization work before a new instance can serve its first operation.
- `list-virtualization` list virtualization: Render a window of list items instead of every item at once.
- `memory-leak` memory leak: A memory leak retains memory beyond its useful lifetime.
- `lock-contention` lock contention: Lock contention occurs when operations wait to acquire the same synchronization boundary.
- `game-loop` game loop: A game loop coordinates repeated input, simulation, and rendering.
- `delta-time` delta time: Delta time is elapsed time between updates.
- `object-pool` object pool: An object pool reuses instances instead of creating a new one for each use.
- `frame-budget` frame budget: A frame budget allocates the time available for responsive rendering at a target cadence.

### security

- `authn-authz` authentication and authorization: Authentication establishes identity; authorization decides whether that identity may perform an operation.
- `xss` cross-site scripting: Cross-site scripting lets untrusted content execute in another user’s browser.
- `csrf` cross-site request forgery: Cross-site request forgery induces an authenticated browser to send an unwanted request.
- `ssrf` server-side request forgery: Server-side request forgery causes a server to contact an unintended destination.
- `idor` insecure direct object reference: An insecure direct object reference exposes an object without checking access to it.
- `password-hashing` password hashing: Store a salted password hash using a purpose-built password hashing function.
- `oauth` OAuth and OpenID Connect: OAuth delegates access to resources; OpenID Connect adds identity information for login.
- `csp` content security policy: Content Security Policy restricts resources and execution in the browser.
- `cors` CORS: Cross-Origin Resource Sharing controls which cross-origin responses browser scripts may read.
- `threat-model` threat model: Identify assets, adversaries, entry points, and plausible failure paths.
- `supply-chain` software supply-chain security: Software supply-chain security addresses risks in dependencies, build inputs, and distribution.
- `session-cookie` session cookie: A session cookie carries a session credential in browser requests.
- `prompt-injection` prompt injection: Untrusted content attempts to redirect an AI system’s instructions or actions.

### testing

- `e2e` end-to-end test: Check a user journey through the running application.
- `test-isolation` test isolation: Each test controls its own state and can run independently.
- `test-fixture` test fixture: Reusable setup gives a test a known starting state and owns cleanup.
- `auto-waiting` auto-waiting: Wait for an observable condition instead of a fixed delay.
- `semantic-locator` semantic locator: Find an element by its role, label, or other user-facing meaning.
- `test-double` test double: A controlled substitute makes a dependency predictable in a test.
- `visual-regression` visual regression test: Compare rendered output with an intentionally reviewed baseline.
- `linter-loop` static analysis: Static analysis inspects code without exercising the application.
- `snapshot-test` snapshot test: Compare serialized output with a reviewed expected snapshot.
- `property-based` property-based testing: Generate inputs to test a general property rather than only handpicked examples.
- `flaky-test` flaky test: A test produces inconsistent outcomes without an intentional relevant change.
- `network-panel` network panel: The browser network panel shows requests and responses made by the page.

### concurrency

- `structured-concurrency` structured concurrency: Child tasks finish within the lifetime of their enclosing operation.
- `cancellation` cooperative cancellation: Work must observe cancellation and stop safely.
- `actor-isolation` actor isolation: An actor protects its mutable state through an isolation boundary.
- `actor-reentrancy` actor reentrancy: Other work can change actor state while an operation is suspended.
- `debounce` debounce: Wait for a quiet interval before acting on repeated input.
- `backpressure` backpressure: Let consumer capacity constrain how fast producers send work.
- `race-condition` race condition: An outcome depends on the timing of concurrent operations.
- `event-loop` event loop: An event loop schedules work and callbacks around the runtime’s execution model.
- `mutex` mutex: A mutex provides mutually exclusive access to a protected critical section.
- `async-parallel` async vs parallel: Asynchronous work can yield while waiting; parallel work executes simultaneously.
- `thread-pool` thread pool: A thread pool reuses worker threads to execute submitted work.
- `atomic` atomic operation: An atomic operation takes effect indivisibly with respect to the relevant observers.
- `goroutine` goroutine: A goroutine is a lightweight unit of concurrent execution in Go.
- `quorum` quorum: Require a defined set of replicas or voters before accepting an operation.
- `consensus` consensus: Make participating nodes agree on decisions despite specified failures.
- `cap-theorem` CAP theorem: During a network partition, atomic consistency and availability cannot both be guaranteed.
- `snapshot-isolation` snapshot isolation: Read a stable transaction snapshot while detecting conflicting writes.
- `mvcc` MVCC: Keep multiple row versions so reads can use a consistent snapshot.
- `two-phase-commit` two-phase commit (2PC): Coordinate prepare and commit decisions across transaction participants.
- `three-phase-commit` three-phase commit (3PC): Add a pre-commit phase to reduce blocking under restricted failure assumptions.
- `lock-escalation` lock escalation: Replace many fine-grained locks with a coarser lock in engines that support it.
- `pessimistic-locking` pessimistic locking: Lock the protected rows before making a competing update.
- `dirty-read` dirty read: Read a value another transaction has written but not committed.
- `phantom-read` phantom read: Repeat a predicate query and observe a changed set of matching rows.
- `read-skew` read skew: Read related facts from different committed moments and combine an inconsistent view.
- `write-skew` write skew: Concurrent decisions update different rows and jointly violate an invariant.
- `throttling` throttling: Bound how often work runs while events continue arriving.

### native apps

- `offline-first` offline-first: Design a useful local workflow that tolerates missing connectivity.
- `deep-link` deep link: A deep link addresses a particular location or action in an application.
- `safe-area` safe area: Safe-area insets describe regions where important content can remain unobscured by system UI or display features.
- `navigation-stack` navigation stack: A navigation stack records a sequence of destinations.
- `push-notification` push notification: A push notification delivers an external event through a platform notification service.
- `app-lifecycle` app lifecycle: Applications move between active, inactive, background, and terminated states according to their platform.
- `os-permission` OS permission: Operating-system permissions mediate access to protected capabilities.
- `ota-update` OTA update: An over-the-air update replaces supported application assets or code without a full binary install.
- `main-process` main process vs renderer: Desktop shells such as Electron separate privileged application work from the renderer.
- `ipc` IPC: Inter-process communication exchanges data or requests between processes.
- `context-isolation` context isolation: Electron context isolation separates the page’s JavaScript environment from privileged preload code.
- `single-instance` single instance: Single-instance behavior routes subsequent launches to an existing application instance.
- `code-signing` code signing: Code signing binds an artifact to a signing identity and detects covered modifications.
- `desktop-update` desktop auto-update: Desktop auto-update retrieves and installs a new application release through a defined trust and lifecycle process.
- `app-sandbox` app sandbox: An application sandbox restricts access to system resources.
- `webview` webview: A WebView embeds web content in a native application.
- `secure-storage` secure storage: Use the platform’s protected storage for suitable credentials or keys.
- `app-link` app link: A verified app link associates an HTTPS domain with an application through platform verification.
- `background-execution` background execution: Background execution uses the operating system’s supported scheduling or execution model.
- `adaptive-layout` adaptive layout: An adaptive layout responds to available space and presentation context.
- `in-app-purchase` in-app purchase: In-app purchases exchange a store transaction for a defined entitlement.
- `build-variant` build variant: A build variant selects a deliberate combination of configuration and packaging.
- `dynamic-type` dynamic type: Dynamic Type adapts text to the user’s preferred size on Apple platforms.
- `biometric` biometric authentication: Biometric authentication can authorize a local operation through the operating system.
- `conflict` sync conflict: A synchronization conflict occurs when changes cannot be combined safely under the chosen policy.

### delivery and operations

- `continuous-integration` continuous integration: Run repeatable checks when code changes are integrated.
- `request-scope` request-scoped state: Keep user-specific mutable state within the request that owns it.
- `streaming` streaming: Process or forward data incrementally as it arrives.
- `idempotency` idempotency: Repeating an operation has the same intended effect as doing it once.
- `env-secrets` secret management: Supply credentials through an appropriate secret store or runtime configuration.
- `feature-flag` feature flag: A switch controls whether a behavior is enabled.
- `rollback` rollback: Return to an earlier working release or state after a failed change.
- `load-balancer` load balancer: A load balancer routes requests among service instances.
- `horizontal-scaling` horizontal scaling: Increase capacity by running more service instances.
- `cdn` CDN: A content delivery network serves content through distributed edge locations.
- `read-replica` read replica: A read replica serves a copy of database data.
- `eventual-consistency` eventual consistency: Replicas or projections converge when updates stop and propagation succeeds.
- `saga` saga: A saga coordinates a multi-step operation through local commits and explicit recovery actions.
- `outbox` transactional outbox: A transactional outbox records an event alongside the business change in one database transaction.
- `cache-stampede` cache stampede: Many callers rebuild the same missing or expired cache entry at once.
- `dead-letter` dead-letter queue: A dead-letter destination retains work that exhausted normal processing or retry policy.
- `liveness-readiness` liveness and readiness: Liveness asks whether a process should be restarted; readiness asks whether it should receive work.
- `canary` canary deploy: A canary release exposes a new version to a limited portion of traffic first.
- `failover` failover: Failover transfers responsibility from an unavailable component to another.
- `pub-sub` pub/sub: Publish/subscribe distributes events to interested subscribers.
- `timeout-budget` timeout budget: An operation’s total deadline must account for downstream calls, retries, and cleanup.
- `graceful-degradation` graceful degradation: Keep essential behavior useful when an optional dependency or capability is unavailable.
- `bff` backend for frontend: A backend for frontend adapts backend capabilities to a client’s needs.
- `iac` infrastructure as code: Infrastructure as code describes infrastructure in reviewable files.
- `container` container: A container runs a process with a packaged filesystem and configured isolation.
- `multi-tenancy` multi-tenancy: A multi-tenant application serves distinct customers through shared infrastructure.
- `object-storage` object storage: Object storage stores data as objects addressed by keys.
- `blue-green` blue-green deploy: Blue-green deployment keeps old and new environments available during a traffic switch.
- `config-drift` configuration drift: Configuration drift is a difference between intended and running configuration.
- `tls` TLS: TLS protects communication and authenticates peers according to the configured trust model.
- `http-cache` HTTP caching: HTTP caching controls when clients and intermediaries can reuse a response.
- `reverse-proxy` reverse proxy: A reverse proxy accepts client traffic and forwards it to application services.
- `port-mapping` port mapping: Port mapping publishes a service port through another network boundary.
- `bind-mount` bind mount vs volume: A bind mount exposes a host path to a container; a managed volume has a separate storage lifecycle.
- `preview-deploy` preview deployment: A preview deployment exposes a particular proposed revision for review.
- `build-id` build ID: A build ID identifies the artifact running in an environment.
- `database-cluster` database clustering: Coordinate database nodes with explicit storage, replication, and routing roles.
- `rebalancing` rebalancing: Move existing partitions or replicas to improve their placement.
- `resharding` resharding: Change the shard layout or assignment used to distribute data.
- `split-brain` split-brain: Competing nodes act as the same write authority after losing coordination.
- `high-availability` high availability (HA): Keep the service usable through specified failures and recovery procedures.
- `vertical-scaling` vertical scaling: Give one instance more CPU, memory, or I/O capacity.
- `geo-replication` geo-replication: Replicate data across geographic regions with an explicit consistency policy.

### web interface

- `url-state` URL state: Put shareable navigation state in the URL.
- `reduced-motion` reduced motion: Respect the user’s preference for less interface animation.
- `layout-shift` layout shift: Visible content moves unexpectedly as the page loads or updates.
- `a11y` accessibility: Accessibility makes an interface usable by people with varied abilities and assistive tools.
- `empty-state` empty state: An empty state explains why expected content is absent and what action is available.
- `progressive-disclosure` progressive disclosure: Reveal secondary choices when they become relevant.
- `destructive-action` destructive action: A destructive action removes or invalidates user value.
- `undo` undo: Undo reverses a supported action according to a defined history and lifetime.
- `skeleton` skeleton screen: A skeleton screen reserves the shape of content while it loads.
- `error-copy` error copy: Error copy explains a failure in terms useful to the user.
- `design-tokens` design tokens: Design tokens name reusable visual decisions such as spacing and colors.
- `split-pane` split pane: A split pane divides a workspace with an adjustable separator.