Terminology

681 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 areas681 Architecture Fundamentals38 Distributed Systems73 Data Architecture71 Cloud Architecture55 Networking51 API & Integration Architecture45 Reliability & Resilience40 Observability33 Performance & Capacity Engineering34 Security Architecture50 Cost Architecture & FinOps12 Business Architecture9 Architecture Communication8 Enterprise Architecture8 Legacy Modernization11 AI-Era Architecture34 Software Architecture & Engineering37 Architecture Patterns34 Architecture Decision-Making30 The Architect's Meta-Skills8

Kind Any concept258 practice180 pattern127 protocol32 tool32 case-study26 metric26

127 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.
Agent Handoff	pattern	Multi-Agent Systems	The transfer of a task and its context from one specialised agent to another, and the point at which multi-agent systems most often lose information.
AI Gateway	pattern	AI-Era Architecture	A shared proxy in front of model providers that centralises routing, keys, quotas, caching, logging and safety policy.
Ambassador Pattern	pattern	Sidecar & Ambassador	A helper process that handles outbound network communication on behalf of an application, adding retries, routing, security and telemetry without changing it.
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.
Bidirectional Contract	pattern	Contract Tests	A contract verified from both sides — the consumer's expectations and the provider's actual behaviour — without either running the other's tests directly.
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.
Broker and Mediator Topology	pattern	Event-Driven Architecture	Two ways of organising an event-driven system — components reacting independently to a shared channel, or a central component coordinating a defined sequence.
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.
Client-Specific Aggregation	pattern	Backend for Frontend	A dedicated backend per client type that shapes and combines downstream data for that client's needs, owned by the client team.
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.
Concurrency Limiting	pattern	Fault Isolation	Bounding the number of simultaneous in-flight operations so that overload produces fast rejection rather than resource exhaustion.
Context Propagation	pattern	Correlation IDs	Carrying request-scoped identifiers and metadata across every service, thread and asynchronous boundary so a single flow remains traceable end to end.
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.
Cursor Pagination Keyset Pagination	pattern	Pagination & Filtering	Paginating by an opaque pointer to the last item seen rather than by numeric offset, giving stable results and constant-time page fetches.
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.
Deployment Pipeline	pattern	CI/CD	The automated path from commit to production, structured so that each stage increases confidence and the whole is fast enough to be run on every change.
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.
Dynamic Secrets	pattern	Secrets Management	Credentials generated on demand for a specific consumer with a short lease, rather than stored, shared and rotated periodically.
Envelope Encryption	pattern	Encryption	Encrypting data with a locally-generated data key, then encrypting that key with a master key held in a key management service, and storing the wrapped key alongside the ciphertext.
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 Stream Versioning	pattern	Event Sourcing	Transforming an old event version into the current shape when it is read, allowing a stored event history to be interpreted by evolved code.
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.
Failover Orchestration	pattern	Failover	The sequence of detection, decision, promotion and traffic redirection that moves service from a failed component to a healthy one.
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 Delivery	pattern	Publish/Subscribe	Delivering one published message to many independent subscribers, each with its own copy, position and failure handling.
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.
Field-Level Encryption Application-Level Encryption	pattern	Encryption	Encrypting specific sensitive fields in the application before they reach the datastore, so the store never holds plaintext.
File-Based Integration	pattern	Legacy Integration	Exchanging data as files on a schedule via SFTP or shared storage — dated, still ubiquitous, and workable when its failure modes are handled explicitly.
Gateway Aggregation	pattern	API Gateway	Combining several backend calls into one client-facing response at the gateway, reducing client round trips at the cost of coupling the gateway to backend structure.
Gateway Offloading	pattern	API Gateways	Moving cross-cutting concerns — TLS termination, authentication, rate limiting, compression, logging — from every service into the gateway.
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.
Immutable Backup Object Lock, WORM	pattern	Backup Strategies	A backup that cannot be modified or deleted for a defined retention period, even by an administrator — the control that makes backups survive ransomware and insider error.