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

368 terms shown.

Term Kind Topic What it is
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.
Landing Zone pattern Landing Zones The pre-built, policy-governed cloud foundation into which workloads are deployed — account structure, networking, identity, logging and guardrails.
Last Writer Wins pattern Sync & Conflict Resolution Resolving a conflict by keeping the version with the later timestamp — simple, deterministic, and it silently discards the other change.
Layered Architecture N-Tier pattern Layered Architecture Organising a system into horizontal layers with a strict dependency direction — the default structure, valuable for its constraint rather than its shape.
Layered Architecture N-Tier pattern Architecture Patterns Organising code into horizontal layers — presentation, application, domain, data — where each layer may only call the one beneath it.
Leader Election pattern Distributed Systems The process by which a group of nodes agrees which one of them is currently in charge of a task that must not run twice.
Leader Election in Practice Coordinator Election, Primary Election pattern Leader Election Selecting one node to coordinate, why majority quorum is non-negotiable, and why fencing at the resource is what actually prevents corruption.
Legacy Wrapping pattern Legacy Integration Patterns Placing a modern interface in front of a legacy system so that consumers integrate with the wrapper rather than with the legacy system directly.
Lift and Shift pattern Rehosting Moving an application to new infrastructure with minimal change, trading optimisation for speed and low migration risk.
Load Shedding pattern Load Shedding Deliberately rejecting a portion of incoming work so the system continues serving the remainder at acceptable latency, rather than degrading for everyone.
Local First Write pattern Offline-First Committing to local storage first and treating the server as an eventual replica, which makes the interface responsive and connectivity an optimisation.
Local Revert On-Device Rollback, A/B Partition Update, Watchdog Revert pattern OTA Updates A device automatically returning to its previous known-good software or configuration when the new one fails, without needing to contact a server - the only mechanism that works when the failure prevents commu…
Locale Fallback Chain Language Negotiation Chain, Locale Resolution Order pattern Internationalisation The declared order in which a system degrades from a requested locale to one it can actually serve - and the decision about which values are allowed to degrade at all.
Log-Based CDC pattern Change Data Capture Capturing changes by reading the database's own write-ahead log, which sees every change with no load on the source and no application involvement.
Log-Based Ingestion pattern CDC Pipeline Design Building the pipeline around a database's own change log — an initial snapshot followed by a continuous delta stream, with the two stitched together.
Logical Shard Virtual Shard, Shard Slot pattern Sharding Patterns A unit of partitioned data that routing targets by name rather than by machine, so data can be moved between physical hosts without changing how anything is addressed.
Long-Running Operation SLO Operation Completion Objective, Terminal-State Objective pattern Platform SLOs A reliability objective shaped for multi-minute platform operations like deploys and provisioning - share of runs reaching a terminal state within a deadline with no manual repair - replacing availability perc…
Mainframe Offload pattern Mainframe Modernization Moving read traffic and selected processing off a mainframe onto modern platforms, reducing cost and unblocking new development without replacing the core.
Managed Service Substitution pattern Replatforming Replacing a self-managed component with a managed equivalent during migration, without changing the application's architecture.
Materialised View Pattern pattern Materialized Views Maintaining a pre-computed, query-shaped copy of data so reads are cheap, at the cost of write amplification and staleness.
Materialized View pattern Data Architecture A precomputed, stored result of a query, refreshed on a schedule or from a change stream, read instead of recomputing.
Medallion Architecture Bronze Silver Gold, Multi-Hop Architecture pattern Medallion Architecture Layering a data platform into raw, cleaned and business-ready zones so that reprocessing is always possible and quality improves in defined steps.
Merge Upsert pattern Ingestion Patterns Applying a batch of changes to a target by matching on a key and inserting, updating or deleting per row, which is expensive and frequently avoidable.
Message Queue Work Queue, Job Queue pattern Messaging & Queues A durable buffer between a producer and a worker that decouples them in time, absorbs bursts, and turns a synchronous dependency into a retryable one.
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.
Metadata-Driven Multi-Tenancy Shared-Table Multi-Tenancy, Metadata Schema pattern Application Architecture Holding each tenant's custom structures as metadata rows over one shared physical schema, so that customisation needs no DDL and one upgrade reaches every tenant at once.
Metadata-Only Migration In-Place Table Adoption, Manifest Generation Migration pattern Open Table Formats Adopting a table format over data files that already exist by generating its metadata in place, so a multi-petabyte conversion becomes a minutes-long commit instead of a full rewrite.
Metric Definition Layer pattern Semantic Layer Business metrics defined once in a versioned, tested place and served to every consuming tool, so the number cannot differ by which tool asked.
Micro-Batching Mini-Batch Streaming, Discretised Stream Processing pattern Streaming vs Batch Executing a stream as a sequence of small bounded jobs on a fixed trigger interval, which buys batch failure semantics and atomic sink commits at the price of a latency floor equal to the interval.
Micro-Frontend pattern Micro-Frontends Splitting a web interface into independently developed and deployed pieces owned by different teams, composed at build time, server time or runtime.
Microsegmentation pattern Zero Trust Enforcing fine-grained network policy between individual workloads rather than between broad network zones, so a compromise cannot move laterally.
Microservices pattern Software Architecture An architectural style where an application is a set of independently deployable services, each owning its data and aligned to a business capability.
Model Cascade Tiered Inference, Escalation Ladder pattern Model Selection A cheap fast model handling the clear majority of cases with escalation to a larger model or a human for the uncertain ones - usually a large cost reduction with no quality loss, because the expensive path run…
Model Router pattern AI-Era Architecture Directing each request to a model chosen by the task's difficulty, cost and latency budget, rather than sending everything to the largest model available.
Model Routing pattern Model Selection Directing each request to the cheapest model capable of handling it, rather than sending all traffic to the most capable one.
Model Translation Boundary pattern Anti-Corruption Layer The layer at which an external system's model is converted into your own, preventing its concepts and accidents from spreading into your domain.
Modular Monolith pattern Architecture Patterns A single deployable unit internally partitioned into modules with enforced boundaries, explicit interfaces and no shared internal state.
Modular Monolith Boundaries pattern Modular Monolith A single deployable unit with strictly enforced internal module boundaries, giving domain separation without distribution.
Modularity via the Modular Monolith Modulith pattern Modularity A single deployable unit with strictly enforced internal module boundaries — the default most organisations should exhaust before distributing.
Module Federation Micro Frontends pattern Module Federation Composing a frontend from independently deployed pieces — solving an organisational problem at a real technical cost.
Multi-Leader Replication Multi-Master, Active-Active Replication pattern Replication Accepting writes at more than one node and replicating between them, which removes the single-primary bottleneck and introduces write conflicts.
Multi-Region Active-Active pattern Multi-Region Architecture Serving live traffic from two or more regions simultaneously, which removes failover time and introduces distributed data problems permanently.
N+1 and 2N Redundancy pattern Redundancy Provisioning one spare beyond required capacity versus provisioning double, and the failure assumptions each encodes.
Namespace Tenancy pattern Platform Tenancy Isolating teams within a shared cluster by namespace plus quota plus network policy, and being explicit about what that does not isolate.
Normalised Client Cache Entity Cache, Client-Side Store, Identity-Keyed Cache pattern Client Caching & Data Layer Caching server responses as entities keyed by identity rather than as whole responses keyed by request, so that updating an entity once updates every view that displays it.
Objection Register Opt-Out Register pattern Lawful Basis & Purpose Limitation The durable default-allow counterpart to a consent store, holding every objection and opt-out and consulted at use time by every job, because switching a lawful basis from consent to legitimate interests inver…
Observability in Practice Telemetry, Instrumentation pattern Observability The three signals, what each is actually for, and why the links between them matter more than any of them individually.
Offline-First Architecture pattern Offline-First Treating the local device store as the primary source the application reads and writes, with the network as an asynchronous replication channel.
Offload Freshness Contract As-At Read Contract, Published Staleness Budget pattern Mainframe Modernization An explicit published staleness budget for a read copy that serves traffic taken off a core system, enforced by the copy itself, so that silently stale answers become visible failures rather than wrong decisions.
Online Training Loop Continuous Training, Streaming Model Updates pattern Feature Freshness Training a model continuously on interaction events as they arrive rather than on a scheduled batch, trading the ability to gate a model artefact before serving for the ability to react to feedback within minutes.
Operational Data Push pattern Reverse ETL Sending modelled analytical data back into operational tools, which turns a warehouse table into a production dependency with none of the guarantees.
Optimistic Claim Conditional Assignment, Compare-and-Set Dispatch pattern Consistency Models Ranking candidates from deliberately stale data and resolving the race atomically at the moment of commitment, rather than locking during selection.
Optimistic Concurrency Control OCC, Compare-and-Set pattern Distributed Locking Allowing concurrent work without locks and detecting conflict at write time by checking that the underlying version has not changed.
Optimistic Update Reconciliation Optimistic UI Rollback, Client Reconciliation pattern Client State Architecture The policy deciding what happens when a change already shown to the user differs from what the server ultimately accepts - the part of optimistic UI where the real defects live.
Origin Shield Shield Tier, Mid-Tier Cache, Request Collapsing Tier pattern Reverse Proxies An intermediate caching tier between edge caches and the origin that collapses many simultaneous misses into a single origin fetch - which is what makes multi-CDN and live streaming survivable for the origin.
Outbox Pattern Transactional Outbox pattern Sagas & Compensation Writing a message to a table in the same database transaction as the state change, then publishing it asynchronously, so the two cannot diverge.
Outbox Relay pattern Outbox The process that reads pending messages from an outbox table and publishes them to a broker, providing at-least-once delivery with no distributed transaction.
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.