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

32 terms shown.

Term Kind Topic What it is
Bloom Filter Cache Guard pattern Caching Strategies Placing a Bloom filter in front of an expensive lookup so that keys which certainly do not exist never reach it.
Caching Strategies pattern Caching Strategies Which cache pattern to use, how staleness is bounded, and the failure modes that only appear under load.
Caching Strategies in Practice Cache-Aside, Write-Through, Read-Through pattern Caching Strategies The write and read strategies, the stampede that takes down origins, and why cache invalidation deserves its reputation.
Change Data Capture CDC pattern Data Architecture Publishing a stream of a database's row-level changes by reading its replication log, without modifying the application that owns it.
Change Data Capture in Practice CDC pattern Change Data Capture Turning a database's replication log into an event stream, so downstream systems learn about changes without the application publishing them.
CQRS Command Query Responsibility Segregation pattern Data Architecture Separating the model used to change state from the model used to read it, so each can be optimised independently.
CQRS as a Data Architecture pattern CQRS Treating the serving layer as a derived, rebuildable projection of an authoritative write store.
Crypto-Shredding Cryptographic Erasure, Key Destruction Deletion, Per-Subject Encryption pattern Data Lifecycle & Retention Encrypting each data subject's personal data under a key unique to them, so that a deletion request is satisfied by destroying the key rather than by rewriting immutable or widely-replicated data.
Database per Service pattern Polyglot Persistence Each service owning its own datastore, with no other service reading or writing it directly.
Event Sourcing pattern Data Architecture Storing the full sequence of state-changing events as the system of record, and deriving current state by replaying them.
Event Sourcing in Practice pattern Event Sourcing Storing state as an immutable sequence of events and deriving current state by replay — powerful where history is the domain, expensive everywhere else.
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.
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.
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.
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.
Lakehouse pattern Data Lakes & Lakehouses Open table formats over object storage that add transactions, schema enforcement and incremental updates to a data lake.
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.
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.
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.
Projection pattern CQRS The process that consumes changes from the write side and maintains a read model, and the component where most CQRS bugs live.
Query-Based CDC Polling CDC, Timestamp-Based CDC pattern Change Data Capture Detecting changes by repeatedly querying for rows modified since the last run — simple, universally available, and lossy in specific ways.
Read Model Query Model, Projection Store pattern CQRS A data structure shaped for a specific query rather than for the domain, maintained separately from the write model.
Read Replica pattern Data Architecture A copy of a database that receives changes from the primary and serves read-only queries, spreading read load.
Replication in Practice Read Replicas, Multi-Primary pattern Replication Copying data across nodes for availability and read capacity, and the lag that turns into user-visible bugs if session guarantees are not designed in.
Reservation Ledger Stock Ledger, Reserve-Then-Commit pattern Transactions & Isolation Modelling stock as an append-only sequence of reservations, releases and allocations rather than as a mutable count - so the number has a history, can be reconciled, and does not become a single point of contention.
Sharding Horizontal Partitioning pattern Data Architecture Splitting one dataset across multiple independent databases by a partition key, so that each holds a disjoint subset.
Sharding in Practice Horizontal Partitioning pattern Partitioning & Sharding Splitting data across independent stores, how to choose the key, and why resharding is the operation nobody plans for.
Snapshotting pattern Event Sourcing Periodically storing an aggregate's computed state so it can be loaded without replaying its entire event history.
Star Schema pattern Data Warehousing A dimensional model with one central fact table of measurements surrounded by denormalised dimension tables describing them.
Tenant Placement Hybrid Tenancy, Shared-to-Dedicated Migration pattern Partitioning & Sharding Routing each tenant to a shared pool or a dedicated database according to its size and requirements, with an online migration path between them - the hybrid model that neither all-shared nor all-dedicated can match.
Versioned Dataset Swap Atomic Pointer Flip, Generation Swap, Blue-Green Data pattern Data Architecture Publishing a regenerated dataset as a complete new version alongside the live one and flipping a serving pointer atomically, so readers never observe a mixture of generations and rollback is a pointer flip rat…
Workload Class Isolation Compute Separation by Class, Interactive vs Batch Pools pattern Data Lakes & Lakehouses Running interactive, scheduled and batch analytical workloads on separate compute over shared storage, so that a long-running job cannot make an analyst's query unpredictable.