Terminology

454 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 areas454 Architecture Fundamentals16 Distributed Systems73 Data Architecture71 Cloud Architecture55 Networking13 API & Integration Architecture17 Reliability & Resilience16 Observability14 Performance & Capacity Engineering13 Security Architecture50 Cost Architecture & FinOps12 Business Architecture9 Architecture Communication8 Enterprise Architecture8 Legacy Modernization11 AI-Era Architecture15 Software Architecture & Engineering19 Architecture Patterns15 Architecture Decision-Making11 The Architect's Meta-Skills8

Kind Any concept166 practice107 pattern93 case-study26 tool26 protocol22 metric14

73 terms shown.

Term	Kind	Topic	What it is
Admission Control	pattern	Load Shedding	Deciding at the edge whether to accept a request at all, based on current capacity, before any work is done on it.
At-Least-Once Delivery	concept	Messaging & Queues	The guarantee that a message will be delivered, possibly more than once — the practical default in every distributed messaging system.
Atomic Commit Protocol	concept	Distributed Transactions	Any protocol ensuring that several participants reach the same decision to commit or abort — and a problem provably unsolvable with certainty in an asynchronous system with failures.
Backpressure	concept	Distributed Systems	A mechanism by which a component under load tells its callers to slow down, rather than accepting work it cannot complete.
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	Distributed Systems	Partitioning resources so that exhaustion caused by one dependency or tenant cannot starve the others.
Byzantine Fault	concept	Failure Modes	A failure in which a component behaves arbitrarily or deceptively — returning wrong results rather than stopping — as distinct from simply crashing.
CAP Theorem Brewer's Theorem	concept	Distributed Systems	During a network partition a distributed system must choose between consistency and availability; it cannot have both.
Cascading Timeout	concept	Timeouts & Deadlines	The effect of independently-chosen per-hop timeouts summing to a total far longer than any caller is willing to wait.
Causal Consistency	concept	Consistency Models	A model guaranteeing that operations which causally depend on one another are seen in the same order everywhere, while concurrent operations may be seen in any order.
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.
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.
Consistent Hashing	concept	Distributed Systems	A hashing scheme where adding or removing a node remaps only a small fraction of keys, instead of nearly all of them.
Consistent Prefix Read	concept	Consistency Models	A guarantee that if a sequence of writes happens in a given order, a reader sees a prefix of that sequence — never an out-of-order subset.
Consumer Group	concept	Event Streaming	A set of consumers that cooperatively read one stream, with each partition assigned to exactly one member, so the group collectively processes every message once.
Credit-Based Flow Control	protocol	Backpressure & Flow Control	A scheme where a receiver grants the sender a budget of bytes or messages it may transmit, replenished as the receiver consumes.
Deadline Exceeded	concept	Timeouts & Deadlines	The error returned when a request's overall budget expires — semantically distinct from a per-hop timeout, and a signal that must not be retried blindly.
Event Stream	tool	Distributed Systems	An append-only, retained log of events that many independent consumers read at their own position, and can re-read.
Eventual Consistency	concept	Distributed Systems	A guarantee that replicas will converge to the same value if updates stop, with no bound on how long reads may be stale.
Exponential Backoff	pattern	Distributed Systems	Increasing the wait between retries geometrically, with random jitter, so that failures do not synchronise into a stampede.
Fail-Fast vs Fail-Safe	concept	Failure Modes	Whether a component should stop immediately on detecting a problem, or continue in a degraded but safe mode — a choice that depends entirely on which outcome is worse.
Failure Threshold	concept	Circuit Breakers	The condition that trips a circuit breaker — best expressed as a failure rate over a rolling window with a minimum request volume, not as a consecutive-failure count.
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.
Fan-Out	concept	Distributed Systems	One incoming request causing many outgoing ones, which multiplies both load and tail latency.
Fault Tolerance	concept	Distributed Systems	Continuing to operate correctly despite the failure of some components, by design rather than by luck.
Fencing Token	pattern	Leader Election	A monotonically increasing number issued with leadership or a lock, checked by the resource, so writes from a deposed holder are rejected.
Graceful Degradation	practice	Distributed Systems	Continuing to deliver reduced but useful function when a dependency fails, instead of failing the whole request.
Grey Failure Partial Failure, Fail-Slow	concept	Failure Modes	A component that is degraded rather than down — slow, intermittently erroring, or failing for a subset of operations — which defeats health checks built for binary states.
Half-Open State	concept	Circuit Breakers	The circuit breaker state that allows a limited number of trial requests through to test whether a failed dependency has recovered.
Harvest and Yield	concept	CAP & PACELC	A refinement of CAP that treats availability as a continuum — yield is the fraction of requests answered, harvest is the fraction of data reflected in an answer.
Idempotency	concept	Distributed Systems	The property that performing an operation many times has the same effect as performing it once.
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.
Lease	concept	Leader Election	Time-bounded leadership or ownership that must be renewed before it expires, so a leader that becomes unreachable automatically relinquishes its role.
Linearizability Atomic Consistency, Strong Consistency	concept	Consistency Models	The strongest single-object guarantee — every operation appears to take effect instantaneously at some point between its call and its return.
Load Shedding	pattern	Distributed Systems	Deliberately rejecting a portion of incoming work during overload so that the remainder can be served correctly.
Lock Lease Expiry	concept	Distributed Locking	The timeout on a distributed lock that prevents a crashed holder deadlocking the system — and the source of the pattern's hardest failure mode.
Log Compaction	concept	Event Streaming	A retention policy that keeps only the most recent value for each key rather than deleting by age, so the log becomes a durable snapshot of current state.
Message Ordering	concept	Messaging & Queues	The guarantee about the sequence in which messages are delivered — normally per-partition or per-group only, and lost the moment consumption is parallelised.
Message Queue	tool	Distributed Systems	A store that holds messages until a consumer processes them, decoupling producer availability and rate from consumer availability and rate.
Noisy Neighbour	concept	Bulkheads & Isolation	One tenant or workload consuming shared resources to the detriment of others sharing the same infrastructure.
Offset Management	concept	Event Streaming	How a consumer records its position in a stream, and the decision that determines whether processing is at-least-once or at-most-once.
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.
PACELC	concept	CAP & PACELC	An extension of CAP that also describes the normal case — if Partitioned choose Availability or Consistency, Else choose Latency or Consistency.
Partition Tolerance	concept	CAP & PACELC	The ability to keep operating when the network drops or delays messages between nodes — not a choice, but a property of any system spanning more than one machine.
Pivot Transaction	concept	Sagas & Compensation	The step in a saga after which the transaction can no longer be cancelled — everything before it is compensatable, everything after it is retriable until it succeeds.
Priority Queueing	pattern	Load Shedding	Classifying requests by business importance so that overload sheds the least valuable work first rather than an arbitrary slice.
Quorum	concept	Distributed Systems	A minimum number of nodes that must acknowledge an operation for it to count, chosen so that read and write sets are guaranteed to overlap.
Raft	protocol	Consensus Protocols	A consensus algorithm designed to be understandable, decomposing agreement into leader election, log replication and safety.
Reactive Streams	protocol	Backpressure & Flow Control	A specification for asynchronous stream processing in which the consumer requests a specific number of items, making backpressure part of the protocol rather than an afterthought.
Read Timeout Socket Timeout	concept	Timeouts & Deadlines	The bound on how long a client waits for response data after a connection is established — distinct from the connect timeout, and the one that usually matters.
Read-Your-Writes Consistency Read-After-Write	concept	Consistency Models	A session guarantee that a client always sees its own updates, even when reads are served from replicas that may lag.
Redlock	protocol	Distributed Locking	An algorithm for distributed locking across independent Redis instances, and the subject of a well-known critique about what locks can guarantee at all.
Retry Budget	pattern	Retries & Backoff	Capping retries as a proportion of overall traffic rather than as a count per request, so retries cannot multiply during the failure they are meant to survive.
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.
Scalability	concept	Distributed Systems	The ability to handle growing load by adding resources, ideally with cost rising no faster than the load.