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
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 Event-Driven Architecture A style in which components communicate by publishing and reacting to facts, rather than by calling each other and waiting.
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 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.
Executable Reference Architecture Service Template, Golden Path Template pattern Reference Architectures A template that generates a working, compliant, observable, deployable service - replacing a reference document with something teams adopt because it is the fastest way to start.
Expand and Contract Parallel Change, Expand-Migrate-Contract pattern Database Migration Under CD Changing a schema or contract in three deployable steps so old and new code are correct at every moment.
Expand-Contract Migration Parallel Change, Add-Migrate-Remove, N-1 Compatibility pattern Zero-Downtime Migration Making a breaking change as a sequence of individually reversible steps - add the new alongside the old, migrate readers and writers across, then remove the old - so that at no point is a rollback destructive.
Exponential Backoff pattern Distributed Systems Increasing the wait between retries geometrically, with random jitter, so that failures do not synchronise into a stampede.
External Key Store Hold Your Own Key, External Key Manager, HYOK pattern Digital Sovereignty Holding the key-unwrapping function in a system the cloud provider does not operate so that a decrypt requires a call outward, converting a contractual promise about foreign access into a technical dependency.
Fail-Open Audit Boundary Audit Fail-Open Rule, Accountability Degradation Policy pattern Healthcare Data Protection A pre-declared rule saying which classes of access may proceed when the audit trail cannot be written and which must be refused, so a logging failure does not become a safety failure or an invisible one.
Failover pattern Failover Switching to a standby when the primary fails — where detection, fencing and the decision to automate are harder than the switch itself.
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 Progressive Delivery A runtime switch that separates deploying code from releasing behaviour.
Feature Flags Feature Toggles pattern Feature Flags Decoupling deployment from release, so code ships continuously and exposure is a runtime decision — with a lifecycle that must be enforced.
Fencing Token pattern Distributed Locking A monotonically increasing number issued with a lock, checked by the resource, so a holder whose lease expired cannot act on stale authority.
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.
Filtered Vector Search Predicate-Constrained ANN, Metadata Filtering in ANN pattern Vector Databases Combining a metadata predicate with approximate nearest-neighbour search - where the predicate's selectivity, not the corpus size, decides whether results are correct or latency collapses.
Follower Fetching Closest-Replica Fetch, Rack-Aware Consumption pattern Streaming Cost Letting a consumer read from the in-sync replica in its own availability zone instead of from the partition leader, which removes consumer-side cross-zone transfer charges and adds replication delay to every read.
Freshness Tiering Hot Index, Recent-Document Tier pattern Indexing Splitting a search corpus into a small aggressively-refreshed index of recent documents and a large lazily-refreshed main index, so sub-second freshness is paid for only on the documents that need it.
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.
Golden Path Paved Road, Service Template, Supported Path pattern Paved Roads A generated, fully-configured starting point for a new service that arrives with observability, pipeline, identity, ownership and cost attribution already in place - making the compliant path the fastest one r…
Graceful Degradation in Practice pattern Graceful Degradation Deliberately reducing functionality to preserve the core when a dependency fails — a product decision expressed in architecture.
Graduated Escape Hatch Partial Opt-Out, Layered Override pattern Abstraction Level Choice The ability to override one component of a platform's abstraction without abandoning the rest - which prevents a single unmet requirement from causing total defection.
Guardrail pattern Guardrails vs Gates A control that makes the unsafe action impossible or automatically corrected, rather than reviewing it before it happens.
Guardrails pattern Guardrails Deterministic checks applied to model inputs and outputs, enforcing constraints that the model itself cannot be relied upon to respect.
Health Checks pattern Health Checks Endpoints that tell the platform whether to route traffic to an instance or restart it — and a well-documented way to amplify an outage.
Hedged Request Request Hedging, Tied Request pattern Failure Modes Sending the same request to a second replica after a short delay and using whichever responds first, to cut tail latency caused by unlucky slow servers.
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.
Hexagonal Architecture in Practice Ports and Adapters pattern Hexagonal Architecture The application defines ports; adapters implement them — so the same core is driven by HTTP, a queue, or a test with no changes.
Hub and Satellite pattern Data Vault Modelling Separating stable business keys from their changing attributes and from their relationships, so each can be loaded independently and kept forever.
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.
Human in the Loop Design pattern Human-in-the-Loop Design Placing human judgement at the points where automation should not decide alone — with attention to whether the human can actually exercise judgement.
Human-in-the-Loop Design pattern Human in the Loop Placing human review at the points where model error is consequential, designed so the review is genuinely effective rather than nominal.
Hybrid Retrieval Dense + Sparse Retrieval, BM25 + Vector pattern RAG Architecture Running lexical keyword search and dense vector search together and fusing the results, because each fails where the other succeeds.
Idempotency Idempotency Key, Exactly-Once Effect pattern Idempotency The property that performing an operation twice has the same effect as performing it once — the only practical defence against the duplicates a retrying client will inevitably send.
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 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.
Idempotent Consumer pattern Exactly-Once Semantics A message consumer whose effect is the same whether a message is processed once or many times, which is what makes at-least-once delivery safe.
Idempotent Sink pattern Exactly-Once Semantics A destination where writing the same record twice has the same effect as writing it once, which is what makes end-to-end exactly-once achievable at all.
Identity-Record Separation Pseudonymous Subject Reference, Retention-Erasure Split pattern Data Lifecycle & Retention Holding regulated business records under a pseudonymous reference and the reference-to-person mapping in a separate governed store, so a retention obligation and an erasure right can both be satisfied.
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.
In-Memory Reservation Service Inventory Reservation Service, Single-Owner Counter, Memory-Speed Allocation pattern Database Performance Moving a heavily-contended counter or inventory pool into a single-owner in-memory service that serialises decisions at memory speed and persists asynchronously, trading a small durability window for orders of…
Ingestion-Query Isolation Write-Read Workload Separation, Analytics Isolation pattern Observability Separating a continuous high-volume write path from a spiky, arbitrary query path so that an expensive query cannot stall ingestion - because a query delay is recoverable and an ingestion gap is not.
Integrated Cache Tier Cache-Behind-the-Client, Storage-Managed Cache, Transparent Cache pattern Caching Strategies Placing the cache inside the storage layer's own client rather than in each calling application, so invalidation is driven by the change stream and consistency semantics are defined once instead of per team.
Integration Log of Record Log as Source of Truth, Monolog Pattern pattern Enterprise Integration An ordered, retained log that every consuming system reads from, replacing point-to-point integrations so that a new consumer can rebuild its entire view by replaying history instead of negotiating a back-fill.
Intermediate-State Diagram Transition-State View, Migration Step View pattern Architecture Diagrams A short series of diagrams showing the system at each step between today and the target, each marking which store is authoritative and where rollback stops being possible.
IoT Ingest Architecture pattern IoT Ingest Architecture Receiving high-volume telemetry from a large device fleet — where connection count, backpressure and reconnection storms dominate the design.
Irreversible Operation Guard Soft Delete Window, Two-Person Destructive Control pattern Segregation of Duties The set of design choices that make a destructive action recoverable by default - a delay before permanence, a type check on the target, and a second approver for bulk effects.
Islands Architecture Partial Hydration, Selective Interactivity, Component Islands pattern Hydration Cost Rendering a page as static HTML with independently-hydrated interactive regions, so JavaScript is shipped and executed only for the parts that need it rather than for the whole page.
Just-in-Time Data Access Time-Boxed Data Grant, Expiring Analytical Access pattern Data Access Models Replacing permanent read grants with short-lived grants issued on request with a recorded purpose, so that entitlement decays by default instead of accumulating for as long as someone stays employed.
Kappa Architecture pattern Kappa vs Lambda Treating the stream as the single processing path, and handling historical reprocessing by replaying the log through the same code.
Key-Custodian Separation Token Vault Separation, Split-Custody Pseudonymisation pattern Pseudonymisation Keeping the mapping or key that re-identifies pseudonymised data in a system with a different access path from the data itself - so a breach of the analytical store yields behaviour without people.
Kubernetes Operator pattern Kubernetes A custom controller that encodes operational knowledge for a specific application, reconciling a custom resource towards a desired state the same way built-in controllers do.
Lakehouse pattern Data Lakes & Lakehouses Open table formats over object storage that add transactions, schema enforcement and incremental updates to a data lake.
Lambda Architecture Batch and Speed Layer, Dual-Path Analytics pattern Kappa vs Lambda Running the same computation as both a scheduled recomputation over all retained history and a streaming job over recent events, so that any defect in the fast path is erased by the next full recomputation.