Portfolio ↗

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

734 terms shown.

Term Kind Topic What it is
Fail-Closed Control Deny on Error, Safe-Failure Gate practice Control Design vs Operation A control that blocks when it cannot evaluate, rather than allowing the action through - so that a broken control is visible immediately instead of silently ceasing to protect anything.
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.
Failure Domain Annotation Shared-Fate Labelling practice Deployment Diagrams Writing on a deployment diagram what each group of nodes shares - image, configuration source, pipeline, control plane - so the diagram answers what fails together rather than only where things run.
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 Pre-mortem, Failure Analysis practice Failure Thinking The habit of asking what happens when each part fails, applied systematically during design rather than during the incident.
Fallback Independence practice Graceful Degradation The requirement that a degraded path fail independently of the primary - and be exercised continuously, because fallbacks that are never run do not work.
Falsification Trigger Decision Invalidation Condition, Wrongness Condition practice Judgement Under Uncertainty A named signal and threshold written into a decision at the moment it is made, with an owner, so that telemetry rather than memory tells anyone whether the decision is still correct.
Fan-out Threshold Celebrity Threshold, Hybrid Fan-out Switch practice Publish/Subscribe The membership or follower count at which a system switches from pushing to recipients to having recipients pull - and the monitoring that keeps the classification correct.
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.
FinOps practice Cost & FinOps The practice of giving engineering teams visibility into and accountability for the cost of what they build and run.
FinOps Operating Phases practice FinOps Practice The inform, optimise and operate cycle through which an organisation builds cost management into normal engineering practice.
FinOps Practice practice FinOps Practice The operating model that makes cost a continuous engineering concern rather than a periodic finance exercise.
First Principles Thinking practice First-Principles Reasoning Reasoning from what must be true rather than from what is usually done — the technique for problems where precedent is unavailable or misleading.
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 Change Provenance Flag Audit Trail, Configuration Provenance practice Feature Flags Recording who changed a flag, when, from what to what - and, separately, stamping the effective configuration version onto every artefact it influenced, because the first cannot reconstruct the second.
Flag Expiry Discipline Flag Lifecycle, Stale Flag Removal practice Feature Flags Creating every flag with an owner and an expiry date and treating removal as part of the rollout's definition of done - because flags have a creation process and, without this, no removal process.
Flake Budget Flakiness Threshold, Quarantine Policy practice Flaky Test Management A hard limit on test flakiness, enforced by automatic detection and quarantine with a deletion deadline - because above a small rate the suite stops being a signal and starts training the team to ignore failures.
Fleet Management practice Fleet Management Operating a large population of physical devices — knowing what is deployed, where, on which version, in what health, and acting on that at scale.
Focus Management practice Accessibility Architecture Deliberately controlling where keyboard focus sits after an interface change, which is what makes a dynamic application usable without a mouse.
Forced Upgrade practice Mobile Release Strategy Blocking an installed client version from operating until it updates, which is the only lever available and is disruptive enough to need a policy.
Forward Fix Roll Forward, Fix Forward practice Rollback & Forward Fix Recovering from a bad release by shipping a corrective change rather than reverting to the previous version.
Fully-Loaded Comparison Total Cost Comparison, People-Inclusive TCO, Loaded Build-vs-Buy practice Managed vs Self-Managed Comparing options with engineering time, operational burden and opportunity cost included rather than infrastructure and licence prices alone - which usually reverses the apparent answer at small and medium scale.
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.
Game Days practice Game Days Scheduled exercises where a team responds to a simulated or injected failure, testing the humans and the process as much as the system.
Geo-Restriction and Sanctions practice Geo-Restriction & Sanctions Preventing prohibited access and transactions by location or party — where the control must be enforced, evidenced and current.
GitOps practice GitOps Declaring desired infrastructure state in version control and letting an in-cluster agent continuously reconcile reality to it.
Golden Path Paved Road, Paved Path practice Paved Road & Golden Path The supported, documented, pre-integrated way to do a common task, made easier than any alternative rather than mandatory.
Governed Exception Waiver, Standards Exception practice Technology Standards A deliberate, scoped, time-limited departure from a standard, recorded with an owner - which is always better than the ungoverned workaround it prevents.
Governed Metric Set The Twenty Numbers, Governance Boundary practice Self-Service vs Governed The deliberately small collection of metrics defined once with an owner, with everything else left explicitly self-service - because governing all analysis becomes a bottleneck and is abandoned.
Graceful Degradation practice Distributed Systems Continuing to deliver reduced but useful function when a dependency fails, instead of failing the whole request.
Grain Declaration practice Dimensional Modelling Stating exactly what one row of a fact table represents, before any column is chosen, because every later decision depends on it.
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.
Guardrail Availability Policy Fail-Open Guardrail Decision, Safety Check Degradation Policy practice Guardrails The decision, made in advance and per action class, about what the system does when a safety check cannot run - because the alternative is that a timeout in a classifier decides your safety posture at 03:00.
Handling Ambiguity practice Handling Ambiguity Making progress when the requirements are unclear, the stakeholders disagree, and waiting for clarity is not an option.
Handling Architectural Disagreement practice Handling Disagreement Resolving a technical dispute in a way that produces a decision people will actually implement, rather than a winner.
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 Semantics practice Health Checks The distinction between liveness, readiness and startup checks, and the failure each is intended to address.
Hermetic Build practice Build Reproducibility A build whose output is a function only of its declared inputs, so the same commit cannot produce two different artifacts.
Idempotency Key Scoping Key Scope, Deduplication Scope practice Idempotency The decision of what an idempotency key is unique within, what is stored alongside it, and how long it lives - the three choices that determine whether deduplication actually works.
Idempotent Pipeline practice ETL & ELT A pipeline whose task can be re-run for the same input window any number of times and produce the same result.
Incident Command Incident Command System, ICS practice Reliability & Resilience Assigning explicit roles during an incident — commander, operations lead, communications lead, scribe — so coordination does not compete with diagnosis.
Incident Severity Levels practice Incident Management A small, agreed scale of incident severity that determines response, escalation and communication without requiring debate during the event.
Indexing Strategy practice Data Architecture Choosing the set of indexes a table carries by working backwards from its actual queries, and accepting the write cost that each one adds.
Inference Telemetry practice AI Observability Recording the full context of each model interaction — inputs, outputs, tokens, latency, model version and evaluation scores — so quality and cost can be investigated.
Influence Without Authority practice Influence Without Authority Getting decisions made and adopted by people who do not report to you — which is most of the architect's job.
Infrastructure as Code IaC practice Cloud Architecture Defining infrastructure in version-controlled declarative files that a tool reconciles against the real environment.
Infrastructure as Code in Practice IaC practice Infrastructure as Code Defining infrastructure declaratively in version-controlled code so environments are reproducible, reviewable and auditable.
Infrastructure State Partition State Splitting, Per-Domain State practice IaC Modules & Drift Splitting one infrastructure state file into several along ownership and lifecycle boundaries, so plans are fast and a mistaken apply cannot reach unrelated resources.
InnerSource practice InnerSource Applying open-source collaboration practices inside an organisation, so teams can contribute to code they do not own instead of waiting for it.
InnerSource Contribution Contract Contribution Contract, InnerSource Maintainer Contract practice InnerSource The published statement of what a shared internal component accepts what it refuses and how fast it will answer - which makes a maintainer's "no" fast and survivable instead of turning openness into an unbound…
Instance Family Selection practice Compute Optimisation Matching a workload's resource profile to a machine type designed for it, which is frequently a larger saving than reducing size.
Intended Use Statement Scope of Use, Out-of-Scope Use Declaration practice Model Documentation The part of model documentation that states what the model is validated for and what it must not be used for, so that a deployer can tell whether their use case is covered.
Interaction Modelling practice Sequence Diagrams Showing the ordered exchange of messages between participants over time, to reason about protocols, failure points and latency.
Interest-Based Negotiation Principled Negotiation, Positions vs Interests practice Negotiation Negotiating against what each party actually needs rather than what they have asked for, which opens options that the stated positions foreclose.
Internationalisation i18n practice Internationalisation Designing so that language, region and culture are parameters rather than assumptions — cheap upfront and very expensive to retrofit.
Inverse Conway Manoeuvre practice Conway's Law Deliberately reorganising teams so that the architecture you want becomes the architecture the organisation naturally produces.
Journey-Level SLO Per-Journey Availability, User-Facing SLI practice SLI, SLO & SLA Setting reliability targets per user journey rather than per platform or per service, because consequence differs by journey and only a journey-level measurement reflects what a user experienced.
Keeping-the-Lights-On Baseline Run Reservation, KTLO Allocation practice Portfolio Prioritisation The share of engineering capacity that unplanned and maintenance work consumes whether or not it is planned, reserved explicitly so that roadmap commitments are achievable and the trade-off is visible.
Key Rotation practice Key Management Periodically replacing a cryptographic key with a new one while retaining the old for decrypting existing data, so exposure from any single key is bounded.