Portfolio ↗

Terminology

2240 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 areas2240 Architecture Fundamentals77 Distributed Systems107 Data Architecture110 Cloud Architecture94 Networking88 API & Integration Architecture82 Reliability & Resilience80 Observability75 Performance & Capacity Engineering72 Security Architecture86 Cost Architecture & FinOps71 Business Architecture67 Architecture Communication67 Enterprise Architecture66 Legacy Modernization71 AI-Era Architecture74 Software Architecture & Engineering71 Architecture Patterns71 Architecture Decision-Making63 The Architect's Meta-Skills61 Delivery & Release Engineering66 Platform Engineering & Developer Experience70 Testing & Quality Architecture71 Data Platform Architecture69 Streaming & Real-Time Data69 Data Governance & Semantics74 Frontend & Experience Architecture66 Edge, Mobile & IoT68 Regulatory & Data Protection Architecture65 Assurance, Audit & Model Risk69
Kind Any concept806 practice738 pattern379 metric133 case-study77 tool62 protocol45

66 terms shown.

Term Kind Topic What it is
Accessibility Architecture Structural Accessibility, Accessibility by Construction practice Accessibility Architecture Placing conformance in the components routing and release pipeline that every team already uses - so accessibility is maintained by construction rather than recovered by an audit each year.
Accessibility Regression Gate Accessibility CI Gate, Conformance Gate practice Accessibility Architecture An automated check plus a named manual pass in the release pipeline that blocks a change which breaks accessibility, so conformance is maintained by the build rather than recovered by an annual audit.
API Shapes for UI practice API Shapes for UI Designing APIs for what screens actually need — reducing round trips without coupling the backend to the interface.
Backend for Frontend BFF pattern BFF for Experience A dedicated backend per client experience, owned by the client team, that shapes and aggregates downstream services for that client's exact needs.
Beacon Survivorship RUM Survivorship Bias, Abandonment Bias concept Real User Monitoring The bias in field performance data caused by users abandoning a page before the measurement beacon is sent - so the slowest sessions are excluded and the metric improves as the experience gets worse.
Bootstrap Kill Switch Boot-Path Flag, Safe Mode Configuration pattern Client Feature Flags A configuration value read from local storage before any application code initialises, paired with a launch-failure counter, so a client that crashes during start-up can still be disabled and recovered.
Build Graph Scoping concept UI Monorepo Strategy Determining which packages a change actually affects, so a monorepo builds and tests a subset rather than everything on every commit.
Client Feature Flags practice Client Feature Flags Flags evaluated in a browser or mobile app — where the constraints of distribution, caching and offline behaviour make them meaningfully harder than server flags.
Client Request Waterfall Fetch Waterfall, Client-Side N Plus One concept API Shapes for UI A chain of requests where each one can only start after the previous response arrives, so the screen's load time is set by the depth of the chain times the round trip rather than by bandwidth.
Client Runtime Constraint concept Frontend & Experience Architecture The properties of the browser or device you do not control — CPU, network, version, extensions — which make the client a distributed system component rather than a rendering surface.
Client State Architecture practice Client State Architecture Separating server state, client state and URL state — the distinction that removes most frontend complexity.
Client-Side Data Layer Query Cache, Server State Management pattern Client Caching & Data Layer A client library that owns fetching, caching, invalidation and background refresh of server data, distinct from local UI state.
Commitment Read Never Commit From Cache, Authoritative at the Point of Action concept Client Caching & Data Layer The rule that the read immediately preceding an irreversible action must come from the authoritative source, which is what allows everything else in the interface to be aggressively cached.
Component Contracts practice Component Contracts The interface a shared UI component presents — where the discipline is refusing options as much as providing them.
Component Library Versioning practice Design Systems Treating a design system as a versioned product with a compatibility policy and a deprecation process, because its consumers cannot all upgrade at once.
Composed Page Budget Aggregate Performance Budget, Whole-Page Budget practice Micro-Frontends A performance budget enforced on the assembled page rather than per independently-owned fragment - because in a composed frontend nobody owns the total that users experience.
Content Security Policy protocol Frontend Security A response header declaring which sources of script, style and other resources the browser may load, which turns a script injection from a compromise into a blocked request.
Core Web Vitals metric Core Web Vitals A small set of user-centred performance metrics covering loading, interactivity and visual stability, measured on real users rather than in a lab.
Cumulative Layout Shift metric Core Web Vitals The extent to which visible content moves unexpectedly during load, which correlates with mis-taps and is almost entirely preventable by reserving space.
Data Proximity Compute-Data Locality, Edge Distance Problem, Origin Pull concept Edge Rendering The observation that moving compute toward the user moves it away from the data, so edge execution helps only for computations that do not need a central round trip - and hurts for the ones people most want to…
Design System concept Design Systems A versioned library of components, tokens and patterns that encodes an organisation's interface decisions as reusable code.
Device Class Baseline Reference Device, Slow-Tier Baseline practice Web Performance Budgets A named device and network profile, chosen from the slow end of your real user population, against which every performance budget and acceptance test is measured - so that "fast" means fast for the users who a…
Edge Personalisation pattern Edge Rendering Varying a cached response at the edge on a small number of attributes, so the page stays cacheable while still differing per visitor segment.
Edge Rendering Edge-Side Rendering, POP Rendering pattern Edge Rendering Producing a page's HTML in a lightweight runtime at a CDN point of presence rather than in a regional data centre - which removes network distance from the response and adds distance to the data.
Field Data Versus Lab Data concept Real User Monitoring The difference between what real users on real devices experience and what a synthetic run measures, and why the second is systematically optimistic.
Flag Evaluation Latency concept Client Feature Flags The delay between page load and the client knowing which variant to show, which produces a visible flicker unless the flag is resolved before render.
Flag Propagation Time Flag Convergence Time, Kill Switch Latency metric Client Feature Flags The worst-case delay between changing a feature flag and every client acting on the new value - the number that determines whether a flag can be used as a safety control or only as a release convenience.
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.
Frontend Architecture concept Frontend & Experience Architecture The structural decisions in client applications — rendering strategy, state ownership, boundaries and delivery — which have the same character as backend ones and are frequently made by default.
Frontend Security Boundary concept Frontend Security The rule that nothing enforced in the browser is a security control, and the browser-side mechanisms that reduce blast radius anyway.
Hydration concept Hydration Cost The browser attaching interactivity to server-rendered HTML by re-running component logic, during which the page looks ready and is not.
Interaction to Next Paint INP, Responsiveness Metric metric Real User Monitoring A field metric reporting one of the slowest complete interactions on a page - input delay plus handler processing plus the wait for the next paint - which replaced First Input Delay as a Core Web Vital on 12 M…
Internationalisation i18n practice Internationalisation Designing so that language, region and culture are parameters rather than assumptions — cheap upfront and very expensive to retrofit.
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.
Layout Space Reservation Shift Prevention, Dimension Reservation practice Core Web Vitals Allocating space for content before it arrives, so that late-loading elements fill a gap rather than displacing what the user is already reading.
Locale Aware Formatting practice Internationalisation Rendering dates, numbers, currencies and names according to the user's locale rather than the developer's, using the platform rather than hand-written logic.
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.
Long Task Main-Thread Blocking Task, Long Animation Frame metric Web Performance Budgets Any single piece of work holding the browser's main thread for more than 50 ms, during which no input is handled and nothing is painted - the unit in which an unresponsive page is actually measured.
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.
Module Federation Micro Frontends pattern Module Federation Composing a frontend from independently deployed pieces — solving an organisational problem at a real technical cost.
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.
Observable Component Contract Rendered Surface Contract, Implicit Component API concept Component Contracts The full set of things a consumer can depend on in a shared component - DOM structure, class names, computed spacing, specificity and render timing - as distinct from its declared props, which is the only part…
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 Isolation Sandbox Origin, User Content Origin practice Frontend Security Serving user-uploaded or untrusted content from a separate origin, so that content executing there has no access to the application's session, storage or DOM.
Over-Fetching concept API Shapes for UI Transferring fields the interface will not display, which costs bandwidth and parse time on exactly the devices least able to afford them.
Partial Hydration Islands Architecture, Selective Hydration pattern Hydration Cost Attaching client-side interactivity only to the components that need it, rather than reconstructing the whole page's component tree in the browser.
Performance Budget Enforcement practice Web Performance Budgets A stated limit on bundle size or a timing metric that fails a build when exceeded, which is what turns performance from a periodic project into a constraint.
Prop Interface Stability concept Component Contracts The commitment a component makes about its props, slots, events and emitted structure — including the parts consumers depend on that were never intended as interface.
Pseudo-Locale Testing Pseudo-Localisation, Accented Locale practice Internationalisation Rendering the interface with algorithmically transformed strings - lengthened, accented, direction-reversed - to expose internationalisation defects before any translation exists.
Real User Monitoring RUM tool Real User Monitoring Telemetry collected from actual browser sessions, capturing what real users on real devices and networks experienced.
Remote Module Loading pattern Module Federation Importing code from another application's build at runtime, with the versioning, availability and failure questions that a normal import does not have.
Render Location Decision concept Rendering Strategies Where HTML is produced — build time, server, edge or browser — chosen per route by how personalised and how cacheable that route is.
Rendering Strategy SSR, CSR, SSG, ISR concept Rendering Strategies The decision about where and when HTML is produced — build time, server request time, or in the browser — which drives performance, cost and complexity.
Representative Device Measurement Measure Where Users Are, Field Distribution practice Real User Monitoring Measuring performance on the devices and networks the audience actually uses, and on the distribution rather than the median - because a build agent and a median user both represent nobody in particular.
Runtime Composition pattern Micro-Frontends Assembling one page from independently deployed fragments at request or render time, which is what makes micro-frontends more than separate builds.
Runtime Composition Risk Remote Module Risk, Deferred Integration Failure concept Module Federation The class of failures created by resolving module existence, export shape and shared-dependency versions in the user's browser instead of at build time - including the inability to roll back a remote you do not own.
Screen Shaped Endpoint pattern BFF for Experience An endpoint that returns exactly what one screen needs in one request, shaped by the interface rather than by the domain model.
Server State Versus UI State concept Client State Architecture The distinction between data owned elsewhere and cached locally, and state that exists only in this session — conflating them causes most client state bugs.
Shared Singleton Skew Duplicate Framework Instance, Singleton Version Mismatch concept Module Federation The failure class created when independently built front-end bundles expect different versions of a library that must exist once per page, producing either incompatible reuse or two isolated copies that share …
Shell Personalisation Cache the Shared, Personalise the Edge, Hole Punching pattern Rendering Strategies Generating and caching the page that is identical for everyone, then applying per-user variation at the edge or on the client - preserving the cache hit rate that personalising the whole page destroys.