Portfolio ↗

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

362 terms shown.

Term Kind Topic What it is
A/B Partition Update Dual-Bank Update, Seamless Update pattern OTA Updates Writing a new device image to an inactive partition and switching to it only after verification, so that a failed update falls back to the known-good image instead of bricking the device.
A/B Partition Update pattern OTA Updates Writing firmware to an inactive partition and switching on next boot, so a failed update falls back to the previous image rather than bricking the device.
Accessible Component Contract Component Accessibility Contract, Design System Accessibility Guarantee pattern Accessibility Testing A published, tested statement of a shared component's keyboard model, roles, names and announced states, so that accessibility is verified once where the component is built rather than re-audited in every prod…
Adapter Conformance Suite Port Conformance Tests, Shared Adapter Test Suite pattern Hexagonal Architecture One test suite written against a port and run against every implementation including the in-memory fake, so the fake cannot promise behaviour the real adapter does not deliver.
Adaptive Admission Level Priority Admission Threshold, Collaborative Load Shedding pattern Queueing Theory A load-dependent priority threshold that a service publishes back to its callers, so requests that would be rejected downstream are never sent and upstream work is not wasted.
Admission Policy pattern Policy as Code A rule evaluated at the moment a resource is created or changed, which rejects the request rather than reporting on it afterwards.
Admission Queue Virtual Waiting Room, Login Queue, Front-Door Queue pattern Performance & Capacity Holding excess arrivals in an explicit, communicated queue and admitting them at a rate the system can serve - converting an overload failure into a wait, which is a far better outcome and must be built in advance.
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.
Agent Tool Authorisation pattern Tool Calling Enforcing that a tool invoked by a model executes with the requesting user's permissions rather than the application's, and that consequential actions require confirmation.
Agent Transcript Compaction Loop History Summarisation, Working Memory Compaction pattern Agent Architectures Replacing the resolved middle of a long agent loop with a short summary while preserving the original goal and constraints verbatim, so token cost stops growing quadratically and late steps still follow early …
Aggregate pattern Domain-Driven Design A cluster of objects treated as a single unit for data changes, with one root through which all modification passes, defining the consistency boundary.
Aggregation Threshold Policy Minimum Cohort Rule, k-Threshold Output Policy pattern Data Sharing & Clean Rooms A rule that only returns results computed over at least a minimum number of subjects, plus limits on overlapping queries, so that shared analytics cannot be resolved back to an individual.
AI Gateway pattern AI-Era Architecture A shared proxy in front of model providers that centralises routing, keys, quotas, caching, logging and safety policy.
AI Gateway Pattern LLM Proxy, Model Router pattern AI Gateways A single control point through which all model calls pass, providing routing, cost control, caching, logging, guardrails and provider abstraction.
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 Anti-Corruption Layer A translation boundary that keeps another system's model — usually a legacy or vendor one — from leaking into your domain.
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.
Anti-Corruption Layer in Integration pattern Legacy Integration Patterns A translation boundary that keeps a legacy system's model, vocabulary and quirks from leaking into a new system that must integrate with it.
API Gateway pattern API Gateway A single entry point that handles cross-cutting edge concerns — routing, authentication, rate limiting, TLS — so backend services do not each implement them.
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.
Approximate-Then-Commit Stale Selection Exact Commitment, Two-Phase Precision pattern Materialized Views Selecting candidates from a deliberately stale projection and committing with a conditional write against the authoritative record - which buys cheap selection without sacrificing correctness at the moment it …
Archive-and-Shutdown Data-Preserving Decommission, Retire With Retention, Cold Archive Retirement pattern Decommissioning Retiring an application by exporting its data to durable archival storage in a readable format and shutting the application down - separating the obligation to keep data from the obligation to keep software running.
Attestation Transparency Log Verifiable Transparency, Published Measurement Log pattern Edge Security & Attestation A public append-only log of every software measurement a fleet is allowed to run, checked by the client before it sends data, which removes the possibility of a build served to one user only.
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 Backend for Frontend A dedicated backend per client experience, owned by the team that owns that client, so each surface gets exactly the payload it needs.
Backend for Frontend BFF pattern BFF for Experience A dedicated backend per client experience, owned by the client team, that shapes and aggregates downstream services for that client's exact needs.
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.
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.
Base Layer Rebase Run Image Swap, Image Rebasing pattern Container Image Strategy Replacing the operating-system layers underneath an already-built container image without re-running the application build, so a base-image fix reaches hundreds of services in minutes rather than waiting on ev…
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 Deployment Strategies Two complete production environments where traffic is switched from the old to the new in one step, and back just as fast.
Bootstrap Kill Switch Boot-Path Flag, Safe Mode Configuration pattern Client Feature Flags A configuration value read from local storage before any application code initialises, paired with a launch-failure counter, so a client that crashes during start-up can still be disabled and recovered.
Bounded Queue pattern Backpressure & Flow Control A queue with a maximum depth, which converts unbounded latency growth into an explicit rejection you can control.
Branch by Abstraction pattern Refactoring Making a large change incrementally on the trunk by introducing an abstraction over the old implementation, building the new one behind it, then removing the abstraction.
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.
Build Provenance Attestation, SLSA Provenance, Artefact Lineage pattern Supply Chain Security A signed, verifiable record of which source, builder and inputs produced a given artefact, checked at deployment - which makes the integrity of the build system testable rather than assumed.
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.
Burn Rate Alerting Multi-Window Multi-Burn-Rate, SLO Burn Alert, Budget Consumption Alert pattern Alerting Alerting on how fast an error budget is being consumed, across multiple time windows simultaneously, so that a sudden outage pages immediately while a slow erosion opens a ticket.
Caching Strategies pattern Caching Strategies Which cache pattern to use, how staleness is bounded, and the failure modes that only appear under load.
Caching Strategies in Practice Cache-Aside, Write-Through, Read-Through pattern Caching Strategies The write and read strategies, the stampede that takes down origins, and why cache invalidation deserves its reputation.
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 Progressive Delivery Routing a small fraction of production traffic to a new version and promoting only if its metrics hold against the incumbent.
Cell Cellular Architecture, Bulkhead Cell, Independent Stack pattern Cell-Based Architecture A complete, independent instance of a system serving a subset of customers, sharing no state with other cells - so that almost every class of failure is bounded to one cell's population rather than the whole u…
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 Router Cell Mapping Layer, Partition Front Door pattern Cell-Based Architecture The thin shared component that maps a customer to their cell - the one part of a cell-based architecture that is not isolated, and therefore the part that must be simplest.
Cell-Based Architecture Cellular Architecture, Shuffle Sharding pattern Cell-Based Architecture Running many complete, independent copies of the stack, each serving a subset of users, so any failure is confined 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.
Change Data Capture in Practice CDC pattern Change Data Capture Turning a database's replication log into an event stream, so downstream systems learn about changes without the application publishing them.
Chunk-Level Deduplication Content-Defined Chunking, Sub-File Deduplication pattern Storage Costs Splitting files into content-addressed pieces at boundaries chosen by the data itself, so repeated rewrites of a large artifact store only the bytes that changed rather than a new full copy.
Chunked Prefill Prefill Splitting, Interleaved Prefill, Piecewise Prompt Processing pattern AI Cost Management Breaking a long prompt's prefill into pieces interleaved with other sequences' decode steps, so that one enormous request cannot stall every in-flight interactive response.
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.
Claim-Code Binding Device Claiming, Ownership Binding, Claim on First Use pattern Device Provisioning Giving a device its cryptographic identity at manufacture but its owner at first use, so the factory line never depends on the cloud and ownership can be transferred without re-keying.
Clean Architecture Onion Architecture pattern Clean Architecture Concentric layers with dependencies pointing inward, so business rules know nothing about frameworks, databases or delivery mechanisms.
Client-Side Data Layer Query Cache, Server State Management pattern Client Caching & Data Layer A client library that owns fetching, caching, invalidation and background refresh of server data, distinct from local UI state.
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.