Terminology

2205 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 areas2205 Architecture Fundamentals77 Distributed Systems107 Data Architecture110 Cloud Architecture94 Networking88 API & Integration Architecture82 Reliability & Resilience75 Observability70 Performance & Capacity Engineering72 Security Architecture86 Cost Architecture & FinOps71 Business Architecture67 Architecture Communication67 Enterprise Architecture66 Legacy Modernization71 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 concept794 practice734 pattern368 metric125 case-study77 tool62 protocol45

82 terms shown.

Term	Kind	Topic	What it is
Additive-Only Evolution Non-Breaking Change Discipline, Tolerant Reader Contract	concept	API Versioning	Establishing the compatibility contract before the first release - unknown fields ignored, unknown enum values defaulted - so that most future change requires no version at all.
Amazon 2002: The API Mandate Bezos Mandate	case-study	API & Integration	A directive that all teams expose functionality only through service interfaces, with no back doors, is widely credited with making both Amazon's architecture and AWS possible.
API Deprecation Policy	practice	APIs as Products	The published commitment about how long a version is supported, how notice is given, and what consumers can expect — without which nothing is ever retired.
API Documentation	practice	API Documentation	Documentation as part of the product surface — where quality determines adoption more than the API's technical design does.
API Error Design Problem Details, RFC 9457	practice	API Error Handling	Returning failures in a consistent machine-readable structure that tells a client what went wrong, whether to retry, and what to do about it.
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.
API Product Management	practice	APIs as Products	Treating an API as a product with a lifecycle — versioning, deprecation, adoption metrics and a support commitment — rather than as an implementation detail.
API Versioning Strategy	practice	API Versioning	The scheme for introducing incompatible change, and the far more important question of how long old versions live and who pays to migrate.
At-Least-Once Delivery Redelivery Semantics, Duplicate-Tolerant Delivery	concept	Webhooks	The delivery guarantee that a message will arrive but may arrive more than once - the strongest practical guarantee across an unreliable boundary, which pushes the deduplication responsibility onto the receiver.
B2B Integration	practice	Partner & B2B Integration	Integrating with partner organisations, where the technical problem is small and the versioning, onboarding and support problems are large.
Backward Compatibility	concept	API & Integration	The property that a new version of a producer continues to work with clients written against the old version.
Binary Serialisation	concept	Message Formats	Encoding messages compactly using a schema rather than as self-describing text, trading readability for size and parse speed.
Bulk and Batch API Design	practice	REST Design	Endpoints that accept many items in one call, and the partial-failure semantics that make them either useful or dangerous.
Canonical Data Model Common Data Model, Enterprise Data Model	concept	Integration Patterns	One shared representation that every producer maps into and every consumer reads from, trading N×M translations for a single model that grows monotonically and can never be trimmed.
Capability Flag Partner Capability, Feature Declaration	practice	Integration Patterns	Representing genuine differences between integrated partners as explicit declared capabilities, rather than as variant fields in a shared canonical model.
Command vs Notification Event Semantics, Obligation vs Fact	concept	Event-Driven Integration	Whether a published message requests an action someone is responsible for, or states a fact the publisher does not care who consumes - and why conflating them causes outages.
Compatibility Mode	concept	Schema Registry	The registry setting that defines which schema changes are permitted — backward, forward, full, or none — and therefore what upgrade order is safe.
Connection Pinning Sticky Connection Imbalance, L4 Balancing of Multiplexed Protocols	concept	gRPC APIs	The traffic imbalance that appears when a layer-4 balancer distributes long-lived multiplexed connections instead of requests, so new backend capacity receives no traffic until clients reconnect.
Contract Testing Consumer-Driven Contracts	practice	Contract Testing	Verifying that a provider satisfies what its consumers actually depend on, without deploying both together.
Cursor Opacity Opaque Continuation Token, Sealed Cursor	pattern	Pagination & Filtering	Making a pagination cursor an untyped token the client cannot construct or interpret, so the server keeps the freedom to change what it encodes without breaking callers.
Cursor Pagination Keyset Pagination, Seek Pagination	practice	Pagination & Filtering	Paginating by encoding a position in a stable sort order rather than by numeric offset - constant cost per page and correct under concurrent modification.
Deletion Safety Threshold Mass-Delete Guard, Sync Blast Radius Limit	practice	Partner & B2B Integration	A refusal to process a deletion batch above some proportion of the population without human confirmation - the control whose absence produces the most damaging incidents in synchronisation systems.
Delivery Attempt Log Webhook Delivery History	practice	Webhooks	A customer-visible record of every outbound delivery attempt - its response, timing and payload - which converts a support burden into self-service.
Deployment Order Coupling Upgrade Ordering Constraint, Schema Rollout Order	concept	Schema Registry	The constraint that a schema compatibility mode really expresses - which side of an interface must be upgraded first - rather than any statement about whether a change is safe.
Deprecation Brownout Sunset Rehearsal, Scheduled Dark Window	practice	Backward Compatibility	An announced, time-boxed window in which a deprecated interface returns its retirement error, used to convert an abstract sunset date into a failure the consumer sees in their own monitoring.
Destination Isolation Per-Destination Queues, Independent Fan-Out	pattern	Event-Driven Integration	Fanning events out by writing to a queue per destination rather than delivering synchronously to many, so that one failing or slow destination cannot delay, block or duplicate delivery to the others.
Developer Portal	tool	APIs as Products	The self-service surface where consumers discover APIs, read documentation, obtain credentials and test calls — the main determinant of adoption.
Enterprise Integration Patterns EIP	practice	API & Integration	A catalogue of named, composable messaging patterns — router, translator, aggregator, splitter, filter, dead letter channel — that gives integration work a shared vocabulary.
Event Notification vs Event-Carried State	concept	Event-Driven Integration	Whether an event carries only the fact that something happened, or also the data a consumer needs to act on it.
Event Versioning	practice	Event-Driven Integration	Evolving event schemas without breaking consumers that may read messages written months earlier.
Event-Driven Integration	pattern	Event-Driven Integration	Integrating systems by delivering events rather than by polling or synchronous calls — including the delivery guarantees the receiver must be told about.
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.
GraphQL	protocol	API & Integration	A query language and runtime where the client specifies exactly which fields it needs, against a typed schema, usually via a single endpoint.
GraphQL N+1 Problem DataLoader Pattern	concept	GraphQL	The query explosion that occurs when each item in a list independently resolves its nested fields, turning one request into hundreds of database calls.
gRPC	protocol	API & Integration	A contract-first RPC framework using Protocol Buffers over HTTP/2, with generated clients and servers and first-class streaming.
gRPC API Design	practice	gRPC APIs	Designing service interfaces in a schema-first binary protocol — where the discipline differs from REST and where the mistakes are permanent.
gRPC Status Codes	concept	gRPC APIs	A fixed set of codes that classify failures and tell a client whether retrying is appropriate.
HTTP Method Semantics	concept	REST Design	The safety, idempotency and cacheability guarantees each HTTP method carries, which clients and intermediaries rely on.
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 Key	pattern	Idempotency Keys	A client-generated identifier that lets a server recognise a retried request and return the original result instead of performing the action twice.
Idempotency Scope	concept	Idempotency Keys	The boundary within which an idempotency key is unique and meaningful — per account, per endpoint, or global — and the retention window it lives for.
Integration Coupling Modes	concept	Integration Patterns	The distinct dimensions along which two systems can be coupled — temporal, format, location, semantic — each with its own remedy.
Legacy Integration	practice	Legacy Integration	Connecting modern services to systems that cannot be changed — where the constraints are as much commercial and operational as technical.
LinkedIn and the Origin of Kafka	case-study	API & Integration	Kafka was built to replace point-to-point data integration between many systems with a single durable log that any system could publish to and any number could read.
Message Formats	concept	Message Formats	JSON, Protobuf, Avro and the rest — chosen by who the consumer is and how the schema will evolve.
Message Router	pattern	Integration Patterns	A component that inspects a message and forwards it to one of several destinations based on its content or headers.
Message Translator	pattern	Integration Patterns	A component converting a message between two systems' formats, so neither has to adopt the other's model.
N+1 Resolution DataLoader Problem	concept	GraphQL	The default GraphQL execution behaviour in which each field resolver runs per item, producing one query per row instead of one query per request.
OpenAPI Swagger	tool	API & Integration	A machine-readable specification format for HTTP APIs, from which documentation, clients, servers, mocks and validation can be generated.
Outcome Certainty Taxonomy Retryability Classification, Four-State Error Model	pattern	API Error Handling	Classifying every external response into definitely-failed-retryable, definitely-failed-terminal, definitely-succeeded, or unknown - and giving the fourth state a real resolution path rather than a guess.
Pagination Design Cursor Pagination, Keyset Pagination	practice	Pagination & Filtering	Returning large result sets in pages, where offset-based paging is both slow at depth and incorrect under concurrent writes.
Partner Onboarding	practice	Partner & B2B Integration	The repeatable process by which an external organisation is connected, tested and moved to production — and a common hidden bottleneck.
Persisted Query	pattern	GraphQL	Registering allowed queries in advance and having clients send an identifier instead of the query text.
Problem Details RFC 9457, RFC 7807	protocol	API Error Handling	A standard JSON structure for HTTP error responses, giving machine-readable type, human-readable detail, and room for extensions.
Provider Capability Matrix Integration Support Grid, Honest Capability Declaration	practice	Integration Patterns	An explicit per-provider record of which normalised capabilities are genuinely supported, which are approximated and which are unavailable - published as a product feature rather than kept as internal documentation.
Provider Verification	practice	Contract Testing	The provider-side stage that replays every consumer's recorded expectations against the real implementation.
Query Cost Analysis Query Complexity Limiting, Cost-Based Rate Limiting	practice	GraphQL	Computing the resource cost of a client-specified query before executing it, so that an API which lets clients define their own requests cannot be asked to do unbounded work.
Rate Limit Design Token Bucket, Sliding Window	practice	Rate Limiting	The algorithm, scope and response behaviour that determine whether throttling protects the service and treats callers fairly.
Rate Limiting	pattern	API & Integration	Bounding how many requests a caller may make in a window, to protect capacity and enforce fair use.
Rate Limiting in Practice Throttling, Quota Enforcement	pattern	Rate Limiting	Bounding how much work one caller can demand, the algorithm choice that shows through to users, and why distributed enforcement is approximate.