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

681 terms shown.

Term	Kind	Topic	What it is
Evolutionary Architecture	practice	Architecture Fundamentals	Designing for guided, incremental change rather than trying to get the structure right once, up front.
Execution Model Fit	concept	Serverless vs Containers	Matching a workload's traffic shape, duration and state requirements to the execution model that suits it, rather than choosing one model for everything.
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.
Failback	practice	Disaster Recovery	Returning to the primary region after a failover, including reconciling the data written while it was unavailable — the half of DR that is usually unplanned.
Failover Orchestration	pattern	Failover	The sequence of detection, decision, promotion and traffic redirection that moves service from a failed component to a healthy one.
Failure Injection Testing	practice	Resilience Testing	Deliberately introducing faults into a system under test to verify that timeouts, retries, fallbacks and circuit breakers behave as designed.
Failure Thinking	practice	Meta-Skills	Making "what happens when this fails?" a standing question applied to every component and every dependency in a design.
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.
Fan-Out Delivery	pattern	Publish/Subscribe	Delivering one published message to many independent subscribers, each with its own copy, position and failure handling.
Fan-Out Latency Amplification	concept	Tail Latency	The effect by which a request that depends on many parallel sub-requests is governed by the slowest of them, so rare slowness becomes common at the user level.
Fault Domain	concept	Fault Isolation	A boundary within which a single failure is contained, defined by the infrastructure and dependencies that components inside it share.
Fault Tolerance	concept	Distributed Systems	Continuing to operate correctly despite the failure of some components, by design rather than by luck.
Feature Criticality Tiering	practice	Graceful Degradation	Classifying product functionality by whether it must work, should work, or can be dropped, so degradation decisions are made in advance by the business.
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.
Feature Parity Trap	concept	Rebuild vs Re-architect	The expectation that a replacement system must match every behaviour of the old one before it can be adopted, which is what makes rewrites never finish.
Feature Store	tool	ML Platform	A system that computes, stores and serves model input features consistently for both training and inference, eliminating training-serving skew.
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.
Figma's Postgres Sharding	case-study	Data Architecture	Figma delayed sharding for years using replicas and vertical partitioning, then sharded Postgres horizontally without downtime using logical shards and a proxy layer.
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.
Filter Composability	concept	Pipes and Filters	The property that makes a pipeline style work — each stage transforms input to output with no shared state, so stages can be reordered, reused and scaled independently.
FinOps	practice	Cost & FinOps	The practice of giving engineering teams visibility into and accountability for the cost of what they build and run.
First-Principles Reasoning	practice	Meta-Skills	Reducing a problem to the physical, mathematical or economic facts it rests on, then reasoning up, rather than reasoning from analogy or convention.
Fitness Function	practice	Architecture Fundamentals	An automated check that an architectural characteristic still holds, run continuously rather than reviewed occasionally.
Flag Debt	concept	Feature Flags	The accumulating complexity of feature flags that are never removed, producing untested code paths and combinatorial behaviour nobody understands.
Flame Graph	tool	Profiling & Optimisation	A visualisation of sampled stack traces in which width represents time spent, used to identify where a program's execution actually goes.
Flow Logs	tool	Network Troubleshooting	Records of accepted and rejected network connections, giving a queryable history of what actually talked to what.
Foreign Key Constraint	concept	Relational Modelling	A database-enforced rule that a referencing value must exist in the referenced table — referential integrity that no application bug can violate.
Friction Budget	concept	Security vs Usability	The limited amount of security friction users will absorb before they work around it, making usability a security property rather than its opponent.
Functional Cohesion	concept	Cohesion	The strongest form of cohesion, in which every element of a module contributes to a single well-defined task.
Game Day	practice	Reliability & Resilience	A scheduled exercise in which a failure is deliberately introduced and the team responds as though it were real, to test the system and the response together.
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.
Gateway Timeout Chain	concept	API Gateways	The sequence of timeouts from client through load balancer, gateway and service, which must decrease inward or produce confusing failures.
Global Traffic Management GSLB, Global Load Balancing	tool	Multi-Region Architecture	The layer that decides which region a given user reaches, using DNS, anycast or an edge network, and that performs regional failover.
Golden Signals	metric	Observability	The four measurements that cover most of what matters for a request-driven service: latency, traffic, errors and saturation.
Google Maps and Planetary-Scale Spatial Serving	case-study	Performance & Capacity	Map serving is fast because almost nothing is computed on request — the world is precomputed into a pyramid of tiles, and space is indexed onto a one-dimensional curve.
Graceful Degradation	practice	Distributed Systems	Continuing to deliver reduced but useful function when a dependency fails, instead of failing the whole request.
Graph Database	tool	NoSQL Stores	A store whose first-class citizens are nodes and the relationships between them, making multi-hop traversal cheap.
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.
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.
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 Status Codes	concept	gRPC APIs	A fixed set of codes that classify failures and tell a client whether retrying is appropriate.
gRPC Streaming	concept	gRPC Transport	Four call patterns — unary, server streaming, client streaming and bidirectional — built on HTTP/2 streams.
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.
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.
Hardware Security Module HSM	tool	Key Management	A tamper-resistant device that generates and stores keys and performs cryptographic operations without the key material ever being extractable.
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.
Head-of-Line Blocking	concept	TCP/IP	One delayed or lost item stalling everything queued behind it, even when the later items are ready.
Health Check	practice	Observability	An endpoint the platform polls to decide whether an instance should be restarted or should receive traffic — two different questions needing two different checks.
Health Check Configuration	concept	Layer 4 vs Layer 7	The interval, timeout, and healthy/unhealthy thresholds that together determine how quickly a failed backend leaves rotation.
Health Check Semantics	practice	Health Checks	The distinction between liveness, readiness and startup checks, and the failure each is intended to address.
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.
Horizontal vs Vertical Scaling Scale Out vs Scale Up	concept	Performance & Capacity	Adding more machines versus making one machine bigger — and the fact that vertical is underrated for stateful tiers.
Hot Partition Hot Shard, Hot Key	concept	Partitioning & Sharding	One partition receiving disproportionate traffic, so the system saturates at a fraction of its aggregate capacity.
Hot, Warm and Cold Data	concept	Data Lifecycle & Retention	Classifying data by how frequently and how urgently it is accessed, so each tier can be stored on media priced for that access pattern.