Terminology

384 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 areas384 Architecture Fundamentals16 Distributed Systems73 Data Architecture71 Cloud Architecture17 Networking13 API & Integration Architecture17 Reliability & Resilience16 Observability14 Performance & Capacity Engineering13 Security Architecture18 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 concept136 practice90 pattern81 case-study26 protocol19 tool19 metric13

81 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.
AI Gateway	pattern	AI-Era Architecture	A shared proxy in front of model providers that centralises routing, keys, quotas, caching, logging and safety policy.
Anti-Corruption Layer ACL	pattern	Legacy Modernization	A translation layer that converts a legacy or external system's model into your own, so its concepts do not leak into your domain.
API Gateway	pattern	API & Integration	A single entry point in front of a set of services that handles authentication, rate limiting, routing and protocol translation.
Autoscaling	pattern	Cloud Architecture	Adding and removing capacity automatically in response to a demand signal, to track load without paying for peak all the time.
Backend for Frontend BFF	pattern	Architecture Patterns	A separate, narrow backend per client experience, which aggregates and reshapes downstream services for exactly that client's needs.
Bloom Filter Cache Guard	pattern	Caching Strategies	Placing a Bloom filter in front of an expensive lookup so that keys which certainly do not exist never reach it.
Blue-Green Database Schema	pattern	Release Strategies	The constraint that makes fast rollback actually work — both application versions must be able to run against one schema at the same time.
Blue-Green Deployment	pattern	Software Architecture	Running two identical production environments and switching traffic from the old one to the new one in a single cut, with the old kept warm for rollback.
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.
Caching Strategy	pattern	Performance & Capacity	The chosen pattern for how a cache is populated, read and invalidated — cache-aside, read-through, write-through or write-behind.
Canary Release	pattern	Software Architecture	Routing a small fraction of traffic to a new version, watching its metrics, and expanding or rolling back based on what they show.
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.
Cell-Based Architecture Cellular Architecture	pattern	Architecture Patterns	Partitioning a service into complete, independent copies of itself, each serving a subset of customers, so a failure is bounded to one cell.
Change Data Capture CDC	pattern	Data Architecture	Publishing a stream of a database's row-level changes by reading its replication log, without modifying the application that owns it.
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.
Clean Architecture	pattern	Software Architecture	Concentric layers with a strict dependency rule — source code dependencies point only inwards, towards higher-level policy.
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.
Competing Consumers	pattern	Architecture Patterns	Multiple identical consumers reading from one queue, so throughput scales with consumer count and work is distributed automatically.
CQRS Command Query Responsibility Segregation	pattern	Data Architecture	Separating the model used to change state from the model used to read it, so each can be optimised independently.
Crypto-Shredding Cryptographic Erasure	pattern	Data Lifecycle & Retention	Encrypting each subject's data with its own key and destroying that key to render the data permanently unreadable, achieving deletion without deleting.
Database per Service	pattern	Polyglot Persistence	Each service owning its own datastore, with no other service reading or writing it directly.
Dead Letter Queue DLQ	pattern	API & Integration	A separate queue that receives messages which could not be processed after a set number of attempts, so they neither block the consumer nor disappear.
Dual Write	pattern	Data Migration Strategies	Writing the same change to both the old and new stores during a migration, and the reconciliation that makes it trustworthy.
Event Sourcing	pattern	Data Architecture	Storing the full sequence of state-changing events as the system of record, and deriving current state by replaying them.
Event Upcasting	pattern	Event Sourcing	Transforming an old event's stored form into the current shape as it is read, so historical events remain replayable after the schema changes.
Event-Driven Architecture EDA	pattern	Architecture Patterns	A style in which components communicate by emitting and reacting to facts about what happened, rather than by calling each other.
Event-Driven Integration	pattern	API & Integration	Systems integrating by publishing and consuming events rather than by calling each other's APIs.
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.
Feature Flag Feature Toggle	pattern	Software Architecture	A runtime switch that decouples deploying code from releasing behaviour, so unfinished or risky work can ship dark.
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.
Guardrail	pattern	AI-Era Architecture	A deterministic check applied to a model's input or output, enforcing rules that cannot be left to the model itself.
Hedged Request Request Hedging, Tied Request	pattern	Performance & Capacity	Sending a duplicate of a request to a second replica after a short delay and using whichever response returns first, to cut tail latency.
Hexagonal Architecture Ports and Adapters	pattern	Architecture Patterns	Putting the domain at the centre and letting everything external — UI, database, queues — attach through ports implemented by replaceable adapters.
Human in the Loop HITL	pattern	AI-Era Architecture	Requiring human review or approval at a defined point in an automated flow, chosen by the reversibility and cost of the action.
Idempotency Key	pattern	API & Integration	A client-generated unique value sent with a request so the server can recognise a retry and return the original result instead of acting twice.
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.
Layered Architecture N-Tier	pattern	Architecture Patterns	Organising code into horizontal layers — presentation, application, domain, data — where each layer may only call the one beneath it.
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.
Load Shedding	pattern	Distributed Systems	Deliberately rejecting a portion of incoming work during overload so that the remainder can be served correctly.
Log-Based CDC	pattern	Change Data Capture	Capturing changes by reading the database's own write-ahead log, which sees every change with no load on the source and no application involvement.
Materialized View	pattern	Data Architecture	A precomputed, stored result of a query, refreshed on a schedule or from a change stream, read instead of recomputing.
Microservices	pattern	Software Architecture	An architectural style where an application is a set of independently deployable services, each owning its data and aligned to a business capability.
Model Router	pattern	AI-Era Architecture	Directing each request to a model chosen by the task's difficulty, cost and latency budget, rather than sending everything to the largest model available.
Modular Monolith	pattern	Architecture Patterns	A single deployable unit internally partitioned into modules with enforced boundaries, explicit interfaces and no shared internal state.
Multi-Leader Replication Multi-Master, Active-Active Replication	pattern	Replication	Accepting writes at more than one node and replicating between them, which removes the single-primary bottleneck and introduces write conflicts.
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	Architecture Patterns	Writing an outgoing message into a table in the same transaction as the business change, and relaying it to the broker separately, so the two cannot diverge.
Pipes and Filters	pattern	Architecture Patterns	Decomposing processing into independent steps connected by channels, each transforming its input and passing it on.
Priority Queueing	pattern	Load Shedding	Classifying requests by business importance so that overload sheds the least valuable work first rather than an arbitrary slice.
Projection	pattern	CQRS	The process that consumes changes from the write side and maintains a read model, and the component where most CQRS bugs live.
Publish/Subscribe Pub/Sub	pattern	Architecture Patterns	A messaging pattern where each published message is delivered to every interested subscriber, rather than to one competing worker.
Query-Based CDC Polling CDC, Timestamp-Based CDC	pattern	Change Data Capture	Detecting changes by repeatedly querying for rows modified since the last run — simple, universally available, and lossy in specific ways.
Rate Limiting	pattern	API & Integration	Bounding how many requests a caller may make in a window, to protect capacity and enforce fair use.
Read Model Query Model, Projection Store	pattern	CQRS	A data structure shaped for a specific query rather than for the domain, maintained separately from the write model.
Read Replica	pattern	Data Architecture	A copy of a database that receives changes from the primary and serves read-only queries, spreading read load.