Terminology

2185 terms, tools, patterns and metrics an architect is expected to use precisely. Each one gets a short explanation of what it is, and — where it matters — what it is commonly confused with. Search filters as you type; the column headers sort.

All areas2185 Architecture Fundamentals77 Distributed Systems107 Data Architecture110 Cloud Architecture89 Networking88 API & Integration Architecture82 Reliability & Resilience75 Observability70 Performance & Capacity Engineering72 Security Architecture81 Cost Architecture & FinOps66 Business Architecture67 Architecture Communication67 Enterprise Architecture66 Legacy Modernization66 AI-Era Architecture69 Software Architecture & Engineering71 Architecture Patterns71 Architecture Decision-Making63 The Architect's Meta-Skills61 Delivery & Release Engineering66 Platform Engineering & Developer Experience70 Testing & Quality Architecture66 Data Platform Architecture64 Streaming & Real-Time Data69 Data Governance & Semantics69 Frontend & Experience Architecture66 Edge, Mobile & IoT68 Regulatory & Data Protection Architecture65 Assurance, Audit & Model Risk64

Kind Any concept785 practice729 pattern362 metric125 case-study77 tool62 protocol45

40 terms shown.

Term	Kind	Topic	What it is
Backpressure in Practice Flow Control, Push-Back	pattern	Backpressure & Flow Control	Signalling upstream to slow down so queues stay bounded, and what to do at boundaries where the producer cannot be slowed.
Bounded Queue	pattern	Backpressure & Flow Control	A queue with a maximum depth, which converts unbounded latency growth into an explicit rejection you can control.
Brownout	pattern	Load Shedding	Deliberately reducing the quality or completeness of every response under load, rather than serving some requests fully and rejecting others.
Bulkhead	pattern	Bulkheads & Isolation	Partitioning resources so that exhaustion in one area cannot consume the capacity another area depends on.
Bulkheads in Practice Resource Partitioning, Compartmentalisation	pattern	Bulkheads & Isolation	Partitioning resources so one dependency's failure cannot consume what another needs, and the aggregate-sizing mistake that moves the exhaustion one layer down.
Cell Isolation	pattern	Bulkheads & Isolation	Bulkheading at the level of a complete system copy, so that any failure — including ones nobody predicted — is contained to the customers assigned to one cell.
Circuit Breaker	pattern	Distributed Systems	A proxy that stops calling a failing dependency after a failure threshold, failing fast instead, and periodically tests whether it has recovered.
Circuit Breakers in Practice Failure Detector, Trip Switch	pattern	Circuit Breakers	What a breaker is actually for, the configuration that stops it causing the outage it prevents, and why Netflix moved away from static thresholds.
Client-Side Discovery	pattern	Service Discovery	The caller queries the registry itself and chooses an instance, rather than sending to a stable address that something else resolves.
Compensating Transaction	pattern	Sagas & Compensation	A business operation that semantically undoes a previously committed step — not a rollback, because the original effect was visible and may not be fully reversible.
Conflation Last-Value Caching, Superseding Updates	pattern	Backpressure & Flow Control	Discarding superseded updates so that a slow consumer receives the latest state rather than a backlog of stale ones - bounding work by entity count instead of by message rate.
Deadline Propagation Budget Propagation, Request Deadline, Remaining-Time Passing	pattern	Timeouts & Deadlines	Carrying the originating request's absolute deadline through every downstream hop so that each service works with the remaining budget - and refuses work that cannot finish in time, rather than starting it.
Deadline Propagation Deadline Budget, Request Deadline	pattern	Timeouts & Deadlines	Passing the remaining time budget down each call in a request chain so downstream services never work on a request whose caller has already given up.
Distributed Locks in Practice Lease, Mutual Exclusion	pattern	Distributed Locking	Why lease-based locking is unsafe without fencing, when locks are unavailable entirely, and the partitioning alternative that removes the problem.
Event Streaming Distributed Log, Commit Log	pattern	Event Streaming	A durable ordered log of facts that many independent consumers read at their own pace, retaining events after consumption rather than deleting them.
Exponential Backoff	pattern	Distributed Systems	Increasing the wait between retries geometrically, with random jitter, so that failures do not synchronise into a stampede.
Fallback Strategy	pattern	Circuit Breakers	What a caller does instead when a circuit breaker is open — the part of the pattern that determines whether failing fast helps anyone.
Fencing Token	pattern	Distributed Locking	A monotonically increasing number issued with a lock, checked by the resource, so a holder whose lease expired cannot act on stale authority.
Hedged Request Request Hedging, Tied Request	pattern	Failure Modes	Sending the same request to a second replica after a short delay and using whichever responds first, to cut tail latency caused by unlucky slow servers.
Idempotency Idempotency Key, Exactly-Once Effect	pattern	Idempotency	The property that performing an operation twice has the same effect as performing it once — the only practical defence against the duplicates a retrying client will inevitably send.
Idempotency Token Store	pattern	Idempotency	The durable record of which idempotency keys have been seen and what each one returned, and the component that decides whether the guarantee is real.
Leader Election	pattern	Distributed Systems	The process by which a group of nodes agrees which one of them is currently in charge of a task that must not run twice.
Leader Election in Practice Coordinator Election, Primary Election	pattern	Leader Election	Selecting one node to coordinate, why majority quorum is non-negotiable, and why fencing at the resource is what actually prevents corruption.
Load Shedding	pattern	Load Shedding	Deliberately rejecting a portion of incoming work so the system continues serving the remainder at acceptable latency, rather than degrading for everyone.
Message Queue Work Queue, Job Queue	pattern	Messaging & Queues	A durable buffer between a producer and a worker that decouples them in time, absorbs bursts, and turns a synchronous dependency into a retryable one.
Optimistic Claim Conditional Assignment, Compare-and-Set Dispatch	pattern	Consistency Models	Ranking candidates from deliberately stale data and resolving the race atomically at the moment of commitment, rather than locking during selection.
Optimistic Concurrency Control OCC, Compare-and-Set	pattern	Distributed Locking	Allowing concurrent work without locks and detecting conflict at write time by checking that the underlying version has not changed.
Outbox Pattern Transactional Outbox	pattern	Sagas & Compensation	Writing a message to a table in the same database transaction as the state change, then publishing it asynchronously, so the two cannot diverge.
Per-Dependency Concurrency Limit Dependency Semaphore, Downstream Bulkhead	pattern	Bulkheads & Isolation	A hard cap on in-flight calls to a specific downstream, which bounds the damage a slow dependency can do regardless of how slow it becomes - more reliable than a circuit breaker because it needs no detection.
Priority Load Shedding Tiered Shedding, Criticality-Based Shedding, Selective Degradation	pattern	Load Shedding	Dropping traffic by declared business criticality under stress rather than uniformly or randomly, exploiting the fact that the highest-volume requests are usually the least valuable ones.
Priority Queueing	pattern	Load Shedding	Classifying requests by business importance so that overload sheds the least valuable work first rather than an arbitrary slice.
Retry Budget Retry Ratio Limit, Adaptive Retry Throttling	pattern	Retries & Backoff	A global cap on retries as a proportion of total requests, which bounds retry amplification during broad failures in a way that per-request retry counts cannot.
Saga Compensating Transaction, Long-Running Transaction	pattern	Distributed Transactions	A sequence of local transactions across services where failure is handled by compensating actions rather than by rollback.
Saga	pattern	Distributed Systems	A sequence of local transactions across services where each step has a compensating action that semantically undoes it if a later step fails.
Saga Orchestrator	pattern	Sagas & Compensation	A component that explicitly drives a saga's steps and compensations, holding the flow in one place rather than distributing it across event subscriptions.
Service Discovery	pattern	Service Discovery	How a caller finds a healthy instance of a callee in an environment where instances appear and disappear continuously.
Shuffle Sharding Virtual Sharding, Randomised Subset Assignment	pattern	Bulkheads & Isolation	Assigning each tenant a random subset of the available capacity rather than a single shard, so that any two tenants rarely share their entire subset and one tenant's failure affects almost nobody completely.
Thread Pool Isolation	pattern	Bulkheads & Isolation	Giving each downstream dependency its own pool of threads or permits, so one slow dependency cannot consume the capacity needed to serve everything else.
Timeout Budget Deadline Propagation	pattern	Distributed Systems	Assigning a request an overall deadline at the edge and passing the remaining time down each hop, so no service works on something already out of time.
Try-Confirm-Cancel TCC, Reservation Pattern	pattern	Distributed Transactions	A three-phase distributed transaction where each participant first reserves resources, and a coordinator then confirms or cancels all reservations.