Patterns

Design patterns: circuit breaker, saga, CQRS, bulkhead, staged rollout, etc.

1797 pages

Most-cited

• Upstream the fix 12 sources — When a performance / correctness / security issue lives in a shared ecosystem primitive (language engine, standard library, OSS framework),…
• Staged rollout 10 sources — Progressively roll out a change — code, config, feature flag — starting in a limited scope and expanding only if health signals stay green.…
• Specialized agent decomposition 8 sources — Build per-domain agents (storage, databases, client-side traffic, network, …) that each carry a small, well-scoped toolset,…
• Streaming broker as lakehouse Bronze sink 8 sources — Problem. Most organisations running a Kafka-class streaming broker for operational data also run a lakehouse with a Medallion Architecture for analytics.…
• Tool-surface minimization 8 sources — Tool-surface minimization is the discipline of keeping the number of tools an agent sees small, because (a) tool-calling accuracy degrades as the tool inventory grows (arXiv…
• Central proxy choke point 7 sources — Central proxy choke point is the organisational-scale posture of forcing all AI / LLM / agent traffic in an enterprise through one proxy before it reaches any provider,…
• Fast rollback 7 sources — Ability to revert a change to a known-good state quickly — ideally within seconds — without re-running the full CI/CD pipeline.…
• Measurement-driven micro-optimization 6 sources — Pick the code worth optimizing by production profiling, not by taste; validate each candidate change against a repeatable benchmark; ship;…
• Broker-native Iceberg catalog registration 5 sources — Broker-native Iceberg catalog registration is the pattern where a streaming broker (writing data as Apache Iceberg snapshots) owns the full lifecycle of its Iceberg tables against…
• LTX compaction (time-window merge of SQLite page runs) 5 sources — Represent a database's changes as sorted per-transaction page-range files (LTX), then periodically k-way-merge adjacent time windows into larger files that keep only the latest…
• AI Gateway provider abstraction 4 sources — AI Gateway provider abstraction is the pattern of routing all application LLM calls through a single proxy endpoint that owns provider / model selection, secret injection,…
• Cheap approximator with expensive fallback 4 sources — Serve most queries with a fast, low-cost ML approximator; fall back to the slow authoritative solver only when the approximator reports high uncertainty.…

All pages (A–Z)

• A/B variant prototyping at database level — When two competing schema designs are in contention, build both on parallel database branches forked from the same parent,…
• A11y checks via Playwright fixture extension — A team has a growing Playwright E2E suite and wants to add accessibility (Axe) checks without: (a) forcing test authors to learn a new framework, (b) doubling the number of tests,…
• A/B-Test Rollout with Percentile Guardrails — When shipping a performance-sensitive change whose impact is noisy across client environments, run it as a controlled A/B experiment rather than a fixed-timeline rollout,…
• Accept-header format negotiation for legacy sunset — When a service replaces a legacy interface, the consuming fleet doesn't migrate in a day. At Zalando's scale the pre-PRAPI Product pipeline had ~350 engineering teams consuming…
• Accept-header rewrite to markdown route — On every request, check if Accept contains text/markdown; if so, rewrite the URL to a dedicated markdown-serving route before any static-file or page handler runs.…
• Accept unattributed flows — Design posture: a small percentage of unattributed records is acceptable; any misattribution is not. Systems embracing this tradeoff return a "don't know" signal for records they…
• Access pattern visualisation for data stewardship — Data owners cannot effectively steward their tables without knowing who consumes them. The historical fallback — stakeholder conversations, internal documentation,…
• Accessibility delegate override for semantic fix — Accessibility delegate override for semantic fix is the Android-platform pattern of correcting framework-level accessibility semantics by attaching a subclass…
• Achievable-target-first migration — For a large multi-team migration, pick a tractable, well-aligned first workload — not the hardest or most prestigious one.…
• Action log vs state log replication — Every database engine that supports downstream CDC + HA must answer two orthogonal design questions:
• Actionable error messages (as agent-recovery primitive) — Actionable error messages replace generic errors ("invalid query") with specific, corrective ones ("unknown field 'stauts' – did you mean 'status'?").…
• Active / Dormant User Training Split — Recommendation systems must serve two populations from the same model: active users with recent short-term signal (views,…
• Actor-tagged query observability — Pattern: capture the authenticated actor (user / service account / internal tool / API key / tenant) on every query emitted by an authenticated request,…
• Ad-hoc bpftrace profiler — Ad-hoc bpftrace profiler = the specific instance of ad-hoc-profiler where the DSL is bpftrace and the orchestrator compiles + schedules + deploys the user-authored script as if it…
• Adaptive rate-limited scheduling — Apply a dynamically recomputed rate limit to the scheduler that enqueues work, so that work is uniformly distributed over the scanning/processing interval regardless of changes…
• Additive capability ladder — Structure an agent's (or any untrusted-code consumer's) execution environment as a ladder of capability tiers, where:
• Adversarial corner-case test for recovery — Deliberately drive a stateful system into its worst-case regime and measure whether it can climb back out. Applied to congestion controllers: inject severe packet loss early…
• Adversarial review sub-agent — Spin up an independent sub-agent with an adversarial reviewer prompt to critique a PR before any human looks at it. The sub-agent has no context from the main (building) agent's…
• Advisory over blocking — Advisory over blocking is a design principle for automated review systems: default findings to advisory (informational, non-blocking) with full traceability back to the source…
• Age-based exponential TTL — When caching time-series data where recent buckets are unsettled and old buckets are final, assign each bucket a TTL that scales monotonically with the bucket's data age:
• Agent-assisted label validation — Use the same agent you are trying to evaluate to assist with validating its evaluation labels. When the agent's quality clears an alignment bar against human judges,…
• Agent-driven benchmark loop — Shipping a quality-sensitive ML-adjacent system (retrieval, extraction, classification, synthesis) requires fast iteration on architecture and prompts against a measurable…
• Agent-driven headless browser — Give a coding agent a full browser as a first-class tool — usually a headless Chrome driven via CDP or Playwright — and let the agent verify its own front-end changes by operating…
• Agent-first storage primitive — Build a storage / retrieval service whose API shape, economics, and protocol choices are optimised for the shape of agent workloads first,…
• Agent orchestration meta-skill — Bundle the golden-path end-to-end workflow for a specific codebase into a skill — not a narrow single-tool binding, but a procedural runbook the agent consults for multi-step work…
• Agent provisioning protocol — Let an agent take a user from literal zero at a cloud provider — no account, no payment method, no API token — to a production deployment on that provider,…
• Agent sandbox with gateway-only egress — Give the AI agent a real sandbox (container / microVM / OS- level isolation) with full compute, tool, and filesystem access for its reasoning and tool-output post-processing…
• Agent skill with fallback chain — When an AI agent runs across many repositories with divergent conventions, give the agent a three-tier fallback chain for finding the right orchestration skill to apply:
• Agent spawn parallel exploration — Performance-engineering-class work — finding hotspots in a large codebase, proposing optimisations to Rust/C/C++/Go hot paths…
• Agent training-crawler redirect — Classify AI-training crawlers at edge + redirect them to a different URL than the one humans see, when the human-visible page would poison future LLM answers if ingested verbatim.
• Agentic Access Control (AAC) — Agentic Access Control (AAC) is an access-control pattern specialised for AI agents as the requesting principal. Three properties:
• Agentic PR triage — Give a coding agent:
• Agentic RL from Production Signal — An LLM-based agent deployed in production generates trajectories — sequences of prompts, reasoning, tool calls, code changes,…
• Aggregating buffered logger — Pattern. A library (or service) that emits very high-frequency events keeps an in-process aggregating counter map keyed on the event's identifying tuple,…
• Aggregation pushdown under join — When a query has GROUP BY + aggregate operators above a cross-shard join that cannot be pushed down, rewrite the plan so that each side of the join is pre-aggregated before…
• Aggregation shield for TSDB cardinality — Place a dedicated metric-aggregation tier in front of the TSDB that drops expensive labels during ingestion, converting high-cardinality raw series into lower-cardinality…
• Aggressive FEC at low bitrate — In real-time communication (RTC), audio calls over poor networks suffer packet loss. Retransmissions don't fit in the latency budget.…
• Aho-Corasick snippet extraction — Shrink long retrieved documents (reviews, website pages, menus, community-Q&A threads) to just the short spans around keyword hits before passing them to the answer- generation…
• AI-driven framework rewrite — Rewrite a non-trivial framework — one previously requiring months of team-engineering — with one human engineer directing a capable AI coding agent under the right preconditions…
• AI Gateway provider abstraction — AI Gateway provider abstraction is the pattern of routing all application LLM calls through a single proxy endpoint that owns provider / model selection, secret injection,…
• AI-generated fix-forward PR — When a detector surfaces a regression + attributes it to a root-cause pull request, auto-generate a mitigation PR and route it to the original PR author for review…
• AI migration skill workflow — Package a mechanical-refactoring migration workflow as a structured, multi-step AI skill with engineer verification checkpoints at risk boundaries.…
• AI-powered admin agent (self-debug) — Run a second agent whose job is operational introspection of the first. Give the second agent a read-only tool surface over the primary agent's telemetry (usage stats, error logs,…
• AI reimplementation against conformance suite — Reimplement an API surface from scratch using AI assistance, gated by a pre-existing comprehensive conformance test suite as the correctness oracle,…
• AI review risk tiering — Classify every incoming change into a small number of risk tiers before any AI reviewer runs, and use the tier to decide how many agents to spawn, which model tier each runs on,…
• AI writes own e2e tests — Let the AI agent write the e2e test suite (not just the production code), deploy to a real test environment, run the tests, and loop on failures until green.…
• AIMD ingestion-rate control — An event-driven or message-broker-fed system has downstream processing capacity that is bounded (by external providers, DB IOPS, CPU,…
• Alarm aggregation per entity — Once detections pass validation + become alarms, do not forward every new detection as a new alert. Roll up per entity (camera + use case + zone), auto-close on resolution,…
• ALB path routing per tenant — Use one Application Load Balancer per infra group with per-tenant listener rules that inspect a tenant identifier in the request (path or HTTP header) and forward to the tenant's…
• Alert backtesting — Replay a proposed alert expression against historical metric data to answer: "when would this alert have fired, and how often,…
• Alert-channel-to-Jira auto-ticket workflow — An automated check (security scan, accessibility audit, SLO breach, monitoring alarm) produces a signal. Downstream there's a triage team with a ticket-tracking tool (Jira,…
• Alerts as code — Treat each alert as a first-class software artifact: authored with IDE-style tooling, validated against historical data before deploy, diffed on change, and reviewed like code.…
• Align with upstream plugin input schema — When you build a variant integration of an OSS engine for your own ingress / proxy / mesh / framework, you face a schema-design question: what does the request object look like…
• All-layer ensemble decoding — At the LLM decoding step, apply the transformer's final projection matrix (LM-head) to every layer's hidden state — not just the final layer's…
• Allowlisted read-only agent actions — Constrain an LLM-driven agent's side effects to a static allowlist of known-safe, read-only verbs, enforced at both the application layer (the tool wrapper refuses anything not…
• Alternative-explanation forensics — Alternative-explanation forensics is the rhetorical + analytical pattern of publishing a long-form post that deflates a malicious interpretation of an observed anomaly by (a)…
• Always-be-failing-over drill — A failover code path that is only invoked during actual incidents accumulates three failure modes silently:
• Analytical intent retrieval — Analytical intent retrieval is the query-time half of Pinterest's Text-to-SQL stack: at request time, the user's natural-language question is embedded into the same unified…
• Annual peak event as capability forcing function — Annual peak event as capability forcing function is the organizational pattern by which a recurring, business- critical, calendar-driven peak event (Cyber Week, tax day,…
• Anonymous attribute proof — Anonymous attribute proof is the design pattern of replacing "infer intent from passive signals" with "ask the client to present a cryptographic proof of the attribute the origin…
• Antithesis multiverse debugging — Distributed-systems bugs are notoriously hard to reproduce: they depend on timing, partition topology, message order, and node-state combinations that occur probabilistically…
• API as single source of truth over event streams — At sufficient microservices scale, the common "subscribe to the event stream and build your own local store" architecture produces competing sources of truth:
• API contract first across three languages — You're designing an API that must be implemented in three languages simultaneously — TypeScript (RN), Swift (iOS), Kotlin (Android). Each language has different conventions:
• API normalization layer (cross-provider LLM serving) — Build an internal API surface that exposes a unified contract to feature teams, hiding per-provider differences in API shape, error codes, rate-limit behaviour, telemetry schema,…
• API stability annotations — You're shipping a library with a public surface that other teams (inside or outside your organisation) will compile and link against,…
• Append-only event log for agent state — An LLM agent turn is not a single request — it involves streaming tokens, calling tools, waiting for results, delegating to sub-agents, and potentially awaiting human approval.…
• Append-only log as substrate — Build higher-level data-plane and control-plane systems on an append-only log (distributed-log) rather than on a mutable datastore.…
• Application-level cascade orchestration — A proxy or clustering layer sitting above MySQL/InnoDB must apply FK cascading actions (ON DELETE CASCADE, ON UPDATE CASCADE, ON DELETE SET NULL,…
• Application-level sharding — A team outgrew single-server vertical scaling and decided to horizontally partition a table across multiple database instances,…
• Application-side query limit with dynamic threshold — Application-side query limit with dynamic threshold is an admission-control discipline where the query-builder / client-library layer — upstream of the shared backend…
• Application-State layer outside React — Pattern. Put the state that drives a React application in a central store that sits outside the component tree (shape: Redux-family),…
• Approver / discarder filter — The approver / discarder filter is a named dual used in Datadog's Workload Protection FIM to do correct in-kernel pre-filtering against an evolving rule engine,…
• Architect sharding from first principles per engine — A managed-database vendor has built a mature, battle-tested sharding layer for one engine (e.g. Vitess on MySQL). Demand arrives for an equivalent sharding capability on a second…
• ArgoCD multi-source Helm + values — An Argo CD Application CRD with two sources entries — one pointing at the upstream Helm chart repository, the other at the customer's own values repository.…
• Artifact-as-API between agents — The artifact-as-API pattern replaces unstructured context passing between agents (or between agents and humans) with schema-validated files on disk that serve as the typed…
• Artifact rides model-deploy pipeline — When a serving tier needs per-model configuration (feature allowlists, per-model routing weights, per-model traffic policies, per-model resource limits),…
• AS-path prepending for traffic engineering — AS-path prepending for traffic engineering is the operator pattern of deliberately padding one's own ASN into the outbound AS path multiple times on specific sessions,…
• ASPA for path validation — ASPA for path validation is the BGP-security pattern of using Autonomous System Provider Authorization objects — RPKI-signed, published by each AS holder,…
• Assert factory object count — Encode the expected output size of a test fixture as an assertion inside the test suite itself, so future refactors that accidentally broaden the factory's object graph will fail…
• Asset Bundle Single-Command Deployment — Asset Bundle Single-Command Deployment is the pattern of packaging an entire data + AI pipeline (orchestration, inference calls, schemas, storage references,…
• Asset Preload Prediction — In SSR apps the server only learns which JS bundles the page needs after rendering completes (it records component IDs during render and looks them up in a build-time manifest).…
• AST-based query generation — When a user-facing query language must support recursive or nested logical combinations (parenthesised AND/OR/NOT), the production-scale shape for compiling it into a backend query…
• AST codegen for boilerplate shim — When building a shim layer over a large library with many classes / structs / enums / constants, use abstract-syntax-tree parsing of the library's headers to auto-generate…
• AST-normalized query fingerprinting — Problem. An observability system needs to aggregate metrics across a stream of SQL executions where every execution has different literal values (id = 1, id = 2, id = 3),…
• AST + LLM hybrid conversion — Compose a deterministic AST codemod and a large language model into a single code- conversion pipeline, where:
• Asymmetric autoscaling — aggressive up, conservative down — When implementing reactive autoscaling for latency-sensitive, spiky workloads, deliberately make the scale-up policy more aggressive than the scale-down policy. Specifically:
• Async agent invocation over Kafka — Put a Kafka-style broker (Amazon MSK, Redpanda, self-hosted Kafka) between the caller and an agent-orchestration runtime so that:
• Async block-clone for stateful migration — Relocate a stateful workload (VM + attached large volume) from one host to another with near-stateless interruption time,…
• Async-buffered Kafka produce — Writes from the hot request path land in an in-process buffer (a Go channel, a JVM blocking queue, etc.) and return immediately.…
• Async-centralized quota + local enforcement — Pattern: centralise the quota lifecycle in a control-plane service (CRUD, authorization, validation, audit, rightsizing)…
• Async consistency-checker sidecar — Async consistency-checker sidecar is the mechanism used by Zalando's Returns parallel-run implementation to keep the comparison work off the client-facing hot path:…
• Async graph enrichment job — The async-graph-enrichment-job pattern is a scheduled background-job loop that discovers, materializes, and re-indexes cross-entity relationships in a metadata graph.…
• Async middleware inspection — An application-server middleware (e.g., a framework-provided after filter) intercepts each outbound response, performs a minimal synchronous step…
• Async-projected read model — Async-projected read model is the operational shape of CQRS: a write-optimized source of truth (normalized relational DB, event log, document store) is the command side,…
• Async queue for on-demand feature compute — Front the feature store with a generic async-capable compute substrate, not a dedicated microservice. Let requests enqueue the missing features;…
• Async-refresh cache loader — A plain TTL cache has exactly two states per key: fresh or expired. At the TTL boundary, the next request synchronously pays the origin round-trip latency…
• Async replication for cross-region, semi-sync within region — Configure semi-synchronous replication only between replicas within the same region (where cross-AZ latency is single-digit milliseconds) and asynchronous replication…
• Async SQS → Lambda for interactive optimisation — Interactive optimisation workloads — e.g. a partner portal where users tweak parameters and re-run an expensive optimiser…
• Asynchronous cascade delete for high-fanout graph nodes — Asynchronous cascade delete for high-fanout graph nodes is a graph-database deletion pattern: when a node with potentially millions of connected edges is deleted,…
• Asynchronous Frame Generation Pipeline — The Asynchronous Frame Generation Pipeline is the umbrella pattern AWS and Synthesia Research Engineering designed for chunked latent-diffusion video inference (specifically…
• Asynchronous pre-computed report batch framework — A pre-computation framework is a platform-layer substrate that runs asynchronous workflow-orchestrated batch jobs to scan domain data for a given scope, produces a durable report,…
• Atomic conditional batch claim — When a scheduler needs to pop a variable-size batch bounded by a budget from a shared queue — pop as many items as fit, but no more…
• Attenuate on use — Before every API operation, narrow the token's privileges to the minimum the operation requires — by appending caveats client-side — and transmit only the narrowed token.…
• Attestation before session-key release — Gate the release of the client's session-key material on a successful remote-attestation verification of the server TEE's binary digest against a known-good policy…
• Audit log as rollback substrate — When a system performs destructive bulk operations on configuration data (cleaning up unused fields, removing deprecated work types, bulk-dissociating from schemes),…
• Audit-then-refactor migration — A repeatable playbook for rolling out a new code-level invariant (new ID type, new API, deprecated helper, etc.) across a large multi-team codebase, without a big-bang rewrite.
• Authoritative slot over authoritative offset — When a CDC consumer tracks stream position in two independent locations (a framework offset store plus a source-database-level cursor like a Postgres replication slot),…
• Auto-detect agent context — A CLI designed for both humans and agents auto-detects when it's being driven by an agent harness (Claude Code, Cursor, Codex CLI,…
• Auto-detect INSTANT-DDL eligibility — MySQL 8.0+ offers two roughly-non-blocking schema-change paths that differ by two orders of magnitude in execution time and by one order of magnitude in revert story:
• Auto-escalation on quality failure — Run the cheapest viable model first. Check the output against a quality bar. If the output fails the bar, escalate the same task to a stronger (and more expensive) model…
• Auto-materialized aggregation via semantic layer — When BI dashboards on a metric become slow, enable materialization on the metric in the semantic layer rather than hand-building aggregate tables + refresh pipelines + BI-tool…
• Auto-scaling telemetry collector — Run the telemetry-collection tier (metrics / logs / traces scrapers and forwarders) as a horizontally-scaling fleet whose capacity tracks the workload it observes,…
• Auto-tuning control loop on storage histograms — A background worker that continuously polls per-table partition-size distribution histograms from the storage engine, compares the observed distribution against a configured…
• Automate account lifecycle — In an account-per-tenant platform, automate AWS account creation as a full orchestrated workflow (typically Step Functions + AWS Organizations APIs + CloudFormation baseline…
• Automated cluster standup and decommission — Fully automate the end-to-end lifecycle of serving clusters: from hardware arriving at a data center through configuration, readiness testing, gateway registration,…
• Automated configuration mapping — Automated configuration mapping is the migration pattern where you encode the translation rules between old and new system configurations as code…
• Automated design-compliance review — Automated design-compliance review is a pattern where an LLM-backed agent automatically retrieves relevant design documents (threat models, API contracts,…
• Automated detect-remediate within 10 minutes — Customer interruptions become qualitatively worse past a threshold — for Slack, "about 10 minutes" — at which point customers stop treating the event as a "blip" and start treating…
• Automated discovery + developer reporting — Build an inventory of a domain-specific concern (cryptographic primitives, ML-model usage, PII access, etc.) by combining two complementary mechanisms with disjoint failure modes:
• Automated IP warming with deliverability feedback — You have:
• Automated job lifecycle promotion — The automated job lifecycle promotion pattern is a control-loop for managing multi-phase migrations across many jobs in parallel: every job continuously emits its current phase +…
• Automated migration at monorepo scale — The wrapping architectural pattern for large-scale, language-level, or framework-level code migrations inside a monorepo with tens of millions of lines of code: scale- out…
• Automated SRM alert — A/B test results are only as trustworthy as the groups being compared. When the actual user split deviates from the designed split — sample-ratio-mismatch (SRM)…
• Automated upstream cherry-pick bot — Continuously mirror merged upstream OSS pull requests into a privately-modified fork without human intervention on the common path, while gracefully handling conflicts,…
• Automated volume-health monitoring — Network-attached block storage (EBS and equivalents) experiences performance-variance degradation as a first-class failure mode, not an outage.…
• Automatic Persisted Queries — A GraphQL deployment at scale has two costs that grow with query text: bandwidth (each request carries full query text, which can be kilobytes) and unboundedness (any caller can…
• Automatic provider failover — Automatic provider failover is the pattern of routing an LLM / inference call to a second provider without application- level retry code when the first provider becomes unavailable…
• Autonomous distributed mitigation — Autonomous distributed mitigation is the architectural posture of running threat detection + threat mitigation on every node of a distributed fleet,…
• Autotuned execution pipeline selection — When a workload has multiple viable execution pipelines with orthogonal performance trade-offs (e.g. preprocessing cost vs per-element work), don't hard-code one.…
• Auxiliary engagement task for conversion retrieval — Train a conversion-optimised retrieval model with engagement prediction as a jointly-trained auxiliary task, sharing the encoders (towers).…
• Babel plugin for automatic collapsable=false — When a rendering optimization (in React Native's new architecture: view flattening) silently breaks a pervasive concern (end-to-end tests' ability to find views by testID),…
• Backend localization for hydration stability — Pattern. When a React component needs to display a locale-formatted date, number, currency, or relative-time, do not call Intl. or toLocaleString in the component.…
• Background hydration to local file — Serve queries against a remote data source immediately via a slow-but-cold-open-capable read path (e.g. HTTP Range GETs),…
• Background Reconciler for read-path optimization — When the write path is optimised for ingest cost (e.g., cross-partition coalescing into object-storage PUTs), the resulting on-storage layout is rarely read-optimal.…
• Background worker pool for async I/O — You want an application process to stop blocking on synchronous I/O, but the obvious answer (iouring, libaio) has real downsides:
• Backup and restore tier — DR tier where nothing runs in the recovery environment during steady state — only periodic backups are stored there. On disaster,…
• Backward-compatible config migration (boolean → enum) — When a boolean configuration property needs to grow into a richer enumerated type (three or more states), migrate forward with automatic mapping from the deprecated boolean…
• Bad-host auto-drain — Attribute each query failure to the host that caused it, alert when a single host's failure-attribution count exceeds a threshold, and auto-drain that host from the serving fleet.…
• Bandwidth-adaptive codec mode — Real-time communication network conditions change within a call. A single call may traverse great-network → congested → degraded → recovered network states.…
• Base-class automatic instrumentation — Instrumenting N similar components (screens, handlers, services) with the same measurement logic scales as O(N) engineering work when each component adds the instrumentation…
• Bash in sandbox as retrieval tool — Expose bash (and a batched variant like bashbatch) as tools on the agent, backed by an isolated sandbox that has a curated filesystem loaded in…
• Batch embedding for index consistency — When building an ANN index for a two-tower retrieval / ranking system, favor batch inference over a single consistent model checkpoint over incremental streaming updates that mix…
• Batch-goroutine parallel consumption — Consume Kafka messages in batches rather than one-at-a-time, and process each message in the batch concurrently via goroutines (or equivalent lightweight threads).…
• Batch number for rollback grouping — A versioned schema migration tool with up/down reversibility needs a named unit of rollback. The finest-grained unit — one migration file…
• Batch over network to broker — On the producer side of a messaging system, group many small records into one protocol batch before dispatching across the network.…
• Batch + streaming + on-demand feature serving — Batch + streaming + on-demand feature serving is the feature- platform shape in which three complementary ingestion lanes feed a single unified online-serving surface:
• Batch-then-real-time fallback — Present a single CSV/Parquet-in, CSV/Parquet-out batch interface to callers regardless of whether the underlying LLM provider offers a native batch API.…
• Batched background deletion with requeue — A maintenance-cron Sidekiq job that deletes up to limit aged rows per invocation via deleteall, then re-enqueues itself if the deletion count equalled the limit (implying more work…
• Batched matmul for pairwise similarity — A service needs to score every candidate against every reference item via a per-pair similarity function — cosine, dot product, Euclidean, etc.…
• Beam search with retailer-partitioned mapping — Compose beam search over a generative-retrieval decoder with a retailer-partitioned index that maps generated Semantic IDs back to available,…
• Behavior-discrepancy sampling — Behavior-discrepancy sampling is the pattern of prioritising evaluation effort on cases where LLM-predicted labels and observed user behaviour disagree,…
• Belt-and-braces dependency resolution — In a rapidly evolving infrastructure, circular dependencies in startup ordering can re-emerge at any time — new service versions introduce new implicit dependencies,…
• Benchmark in your own environment before upgrade — Before committing to a major-version upgrade of a stateful system, reproduce the benchmarks in your own environment with your own workload profile…
• Bidirectional index-query attribution — Problem. Operators ask two equally-important questions about index usage:
• Big Bet dedicated facility — Override fleet-mode concurrency for the highest-reliability events by dedicating one whole broadcast operations facility to one event.…
• Binary format for broker throughput — When raw streaming-broker throughput is the constraint, prefer binary encodings (AVRO, Protobuf) over text encodings (JSON) for on-wire payloads.…
• Binary search on sorted partition prefix — When a database planner has to filter a sorted collection of physical-storage units (parts, segments, files) by a predicate on the leading prefix of the sort key,…
• Bisect-driven regression hunt — Bisect-driven regression hunt is the canonical debugging pattern for "something got worse after an upgrade, but I don't know what" problems. It composes:
• Blast radius in VM, not host — On a conventional VM platform, orchestration code lives on the host. Shipping a change means restarting host daemons or, in the worst case,…
• Blending logic to model server — Feed-blending / multi-objective reranking logic historically lives in backend service code — Java/C++/Scala custom nodes inside the feed-serving backend,…
• Bloblang-interpolated multi-table routing — A single streaming-sink pipeline definition routes records to N destination tables based on per-record content, by embedding a mapping-language expression into the connector's…
• Blobless clone + lazy hydrate — Blobless clone + lazy hydrate is the concrete pattern for materialising a Git repository onto an agent-sandbox / CI-worker / container filesystem without blocking on full-repo…
• Block-device container image for lazy loading — At image build time, convert the standard gzip-tarball OCI image into a block-device-based image format with fixed-size sectors (e.g. 4 MB).…
• Block-level continuous replication — Replicate changes at the block-device layer, continuously (not on a snapshot schedule), producing a crash-consistent replica that tracks the source within seconds of each write.…
• Blocking model per request (Tomcat) — One thread is dedicated to handling one HTTP request for that request's entire lifetime. When the handler blocks on a downstream call (JDBC, HTTP client, queue offer),…
• Bloom-filter membership test before storage fetch — Put a Bloom filter membership test on the hot request path in front of a slower authoritative store. The filter answers "does this key exist?" in sub- microseconds with the error…
• Bloom-filter redirect to split partition — A Bloom-filter-gated read-path divert that decides on every read whether the partition has been split or not — and only on a Bloom-filter hit incurs the cost of a metadata-table…
• Blue/green database deployment — Applying schema changes, version upgrades, or instance-class changes to a stateful database without downtime is harder than the analogous application-tier problem.…
• Blue/green service-mesh migration — Blue/green service-mesh migration is the pattern for cutting traffic between two disjoint service-mesh environments that cannot share networking…
• Bootstrap eval dataset from production traces — Bootstrap eval dataset from production traces is the pattern of materializing evaluation dataset records by SQL-querying durable production trace tables…
• Bootstrap Then Auto-Follow — When a *policy-based automation primitive only applies to resources created after the policy is installed, cover the pre-existing set with an imperative bootstrap pass before…
• Bot score on checkout — Emit a per-payment bot-likelihood score at the checkout surface, leaving enforcement policy (block, throttle, queue, require human verification, allow) to the merchant.…
• Bounded-load consistent hashing — Bounded-load consistent hashing is a consistent-hash variant that caps the traffic any single backend can absorb at a configurable multiple of the cluster average — typically 2×.…
• Bounded telemetry data structures for policy engine — When you embed a policy engine inside an ingress proxy, the engine's OOM fate and the proxy's OOM fate are now the same. Any unbounded in-memory path inside the engine becomes…
• BPF filter for API event source — Manufacture a control-plane event that a kernel / SDK / library doesn't expose natively, by attaching a BPF filter to the data-plane stream and treating every filter match…
• bpf-lsm allowlist hook denial — bpf-lsm allowlist hook denial is the pattern of gating a vulnerable kernel code path by attaching an eBPF program to the relevant Linux Security Module (LSM) hook and denying…
• Branch-based schema-change workflow — Production schema changes are two hard things entangled:
• Branching is PITR with time=now — On a compute-storage-separated substrate with copy-on-write storage, two operations that are usually built, billed, and operated as separate features collapse into one primitive…
• Brand-new domain experiment — A controlled empirical methodology for testing whether a specific crawler or bot operator respects origin-side directives:
• Broadcast join for small reference tables — The broadcast join for small reference tables pattern is a Spark optimisation that eliminates expensive shuffle operations on multi-key joins with date ranges by broadcasting…
• Broker-native Iceberg catalog registration — Broker-native Iceberg catalog registration is the pattern where a streaming broker (writing data as Apache Iceberg snapshots) owns the full lifecycle of its Iceberg tables against…
• Broker write caching as client-tuning substitute — A Kafka-API streaming cluster is CPU-saturated because producer batches are too small, but the producers aren't tunable:
• Bucketed event-time partitioning — Persisting high-throughput time-series events keyed by an identifier (counter, user, device, sensor) in Cassandra (or any partitioned wide-column store) naturally concentrates all…
• Buddy allocator adaptive shard scheduling — In a thread-per-core system writing to object storage, upload parallelism must adapt to load: too many streams produce tiny payloads (wasting S3 PUTs and money),…
• Budget-enforced quota throttle — Pattern: when a project / team / tenant's dollar-budget is exceeded inside a defined time window, automatically lower its maximum-resource quota by a tier-weighted haircut…
• Buffered resumable inference stream — Buffered resumable inference stream is the pattern of having an AI gateway buffer a streaming LLM response as it's generated, independently of the caller's lifetime,…
• Bug-bounty research proxy — A vendor-published tool that intentionally makes external security research against a proprietary protocol / API easier — trading some attacker-lowering-the-bar cost…
• Build both fabric alternatives — When choosing between two qualitatively different architectural substrates at hyperscale — each with deep operational-ecosystem implications,…
• Build-tag dependency isolation — Keep an unwanted dependency out of some Go binaries by marking the file that imports it with a build tag the wanted binaries don't pass.…
• Build-time tech-debt detection — Run static-analysis rules in every CI build of every repo in the fleet, treating rule violations not (only) as build-failure gates but as measurable, queryable,…
• Build without the bytes (BwoB) — Skip downloading cached action outputs to the client unless a downstream local action actually needs them; keep just the content-addressed digest.…
• Bulk job enqueue — When enqueuing many jobs of the same class at once, issue a single bulk enqueue call with the full ID list rather than one enqueue per job.…
• Bulk namespace import for backward compatibility — When a shim layer renames an underlying library's namespace from foo:: to foonew:: / foolegacy:: (for ODR reasons in a dual-stack migration),…
• Bulk-write + prefetch + parallel — the batch-optimization framework — When batch ETL jobs regress after migrating from an in-engine set-based substrate (PL/SQL inside an RDBMS) to an application-layer loop against a remote database (Java / Python /…
• Bundle-size budget for browser telemetry — Observability in a browser context has a cost server-side observability never has: every byte of the telemetry SDK adds to page weight and competes with customer-facing JavaScript…
• Bundled rules auto-scoped to library consumers — Co-locate static-analysis rules with the library they govern, in a separate compiled artefact (different jar, classifier, or variant),…
• Business-Logic-Free Data Aggregation Layer — You are building an API gateway / aggregation layer (BFF, GraphQL, REST facade) that sits between N frontend clients and M backend microservices, and you want:
• Business to Engineering Requirement Translation — Business-voice requirements (from accountants, lawyers, product managers, compliance officers, business analysts) are often:
• BYO model via container — BYO model via container is the pattern of an inference platform productising "bring your own custom or fine-tuned model" as a container-image push…
• CA-bundled certificate for third-party tool trust — Configure a third-party tool that does not ship a public-CA trust store to connect to a managed service by uploading (or pasting) the managed service's CA root PEM into the tool's…
• CAB approval gate (anti-pattern) — CAB approval gate is the traditional change-management pattern in which every significant production change must be reviewed and approved by a Change Advisory Board…
• Cached KV cross-attention for deduplication — Ranking-stage transformers in recommendation systems let each candidate item attend to the user's history sequence — this coupling is what gives ranking models more expressive…
• Cached Lookup with Short TTL — Cache the result of an expensive or availability-coupled lookup (DB query, RPC, DNS, auth token validation) in local in-process memory with a short TTL — seconds, not minutes.…
• Caching proxy tier — Interpose a stateless proxy tier speaking the cache's native wire protocol between applications and the underlying cache fleet (Redis, Memcached, etc.),…
• Callback-slice VM in Go — You need to build a bytecode-VM-class fast interpreter for a dynamic expression language in Go. The mainstream designs (big-switch VM,…
• Canary and shadow cluster rollout — Two-stage deployment pipeline for long-running fleet services: a canary tier catches correctness and performance regressions that surface quickly,…
• Canary-shard substrate migration — When migrating a horizontally-sharded database fleet to a new storage substrate (e.g. EBS → direct-attached NVMe, gp3 → io2, rotating disk → SSD),…
• Canonical entity ID — Canonical entity ID is the pattern of resolving every representation of the same real-world entity (person, document, project,…
• Canonical tag as crawler redirect — Use existing tags as the declarative source for class-specific HTTP 301 redirects at the edge. Per-class policy (e.g.…
• Capability-manifest plugin isolation — Isolate each third-party plugin (or agent-authored extension, LLM-generated tool, untrusted script) in a capability-based sandbox.…
• Capability-returning authenticate() — Authenticating a client at the start of an RPC session and authorizing its subsequent calls is traditionally done in one of two ways, each with real ergonomic and security cost:
• Cardinality-based unused-index detection — Identify candidate secondary indexes that are structurally unused — either empty, degenerate, or never populated with distinct values…
• Catalog-managed commits for external write safety — Catalog-managed commits for external write safety is the deployment pattern in which every commit to a managed open-format table (Delta,…
• Caveat for privilege separation — Give a broadly-privileged subject (e.g., an orchestrator that must touch many tenants) a token that carries a third-party caveat dischargeable only by proving tenant-specific…
• CBR → capped-VBR live rollout — Switching a production live-streaming pipeline's rate-control mode from CBR to capped VBR is deceptively small as an encoder config change but has three structural effects…
• CDC driver ecosystem — Publish one stable, documented vendor-side change-stream API and let every ETL / data-warehouse / data-lake ecosystem write its own driver on top of it,…
• CDC fan-out from a single stream to many consumers — A service's database has many downstream consumers of its change stream: a full-text search index, an analytical warehouse, a feature store, a vector index,…
• CDF incremental replacing full rescan — The CDF incremental replacing full rescan pattern uses Delta Lake's Change Data Feed to replace full-table rescans / overwrites of multi-terabyte upstream tables with change-driven…
• CDN edge cache over central origin — The CDN pattern: keep the authoritative copy of content in a single region (the origin), and replicate read-hot copies into edge caches at geographically-distributed points…
• CDN in Front for Availability Fallback — Put a CDN in front of an origin, configured to cache successful responses. Primary purpose isn't latency or bandwidth — it's that when the origin is totally down,…
• CDN-like database connectivity layer — Structure the database-access path like a CDN. Client connections land at the nearest edge point-of-presence, where the provider-owned fabric terminates the wire protocol (TCP +…
• CDP proxy for headless browser — CDP proxy for headless browser is the pattern of standing up a local Chrome DevTools Protocol endpoint inside an agent / application / sandbox that forwards CDP frames through…
• Cell-based architecture for blast-radius reduction — Partition the service into independent cells (self-contained deployable units with isolated data, compute, and control paths) so that any fault's impact is bounded to at most one…
• Central proxy choke point — Central proxy choke point is the organisational-scale posture of forcing all AI / LLM / agent traffic in an enterprise through one proxy before it reaches any provider,…
• Central telemetry aggregation — In a multi-account platform (especially account-per-tenant), forward logs / metrics / traces from every source account into a single central aggregation tier,…
• Centralised backend proxy for micro-frontends — A micro-frontend deployment has N independently built and deployed frontend bundles, each potentially needing to call M backend microservices.…
• Centralised deployment orchestration across systems — A company at scale runs many different deployment systems — one per workload class, per cloud substrate, per era of infrastructure.…
• Centralized ahead-of-time indexing — Pattern: shift code indexing off the developer's machine and off IDE startup paths, run it on a shared fleet ahead of time,…
• Centralized cloud media library — Centralized cloud media library is the architectural pattern of uploading all production media into one cloud-addressable asset namespace once at ingest,…
• Centralized Embedding Platform — Centralized embedding platform is the pattern of operating a single, org-wide service for creating, governing, ingesting,…
• Centralized experimentation platform — Teams run A/B tests ad-hoc, each with their own randomization logic, analysis scripts, and KPI definitions. Three failure modes follow:
• Centralized fleet-wide rule catalog — A polyrepo organization runs one canonical rule-execution plugin in every CI build of every repo in the fleet, with rules sourced from a central catalog that includes both…
• Centralized forward declarations (Fwd.h per directory) — When a codebase chooses forward-declaration over #include as the default strategy for breaking C++ header include chains,…
• Centralized identity federation — Operate one external identity provider (an IdP — SAML / OIDC / IAM Identity Center / ADFS / Okta / corporate AD) and federate identities from it into every target…
• Centralized routing proxy for ML serving — Centralized routing proxy for ML serving is the bootstrap-era pattern where one mandatory proxy fronts all model-inference traffic and bundles routing, model selection,…
• cGroup-scoped egress firewall (eBPF) — cGroup-scoped egress firewall (eBPF) is the pattern of applying a per-process-set outbound network policy on a host by (1) placing the target processes into a dedicated Linux…
• Change-detection ingestion — Change-detection ingestion is the optimization of comparing a newly-computed record against its current value in the online store before writing,…
• Chargeback / Cost Attribution — Pattern: the infrastructure tier that does the expensive thing (egress, compute, storage) also records the cost-driving metric (bytes-transferred, CPU-seconds,…
• Cheap approximator with expensive fallback — Serve most queries with a fast, low-cost ML approximator; fall back to the slow authoritative solver only when the approximator reports high uncertainty.…
• Checkpoint as metadata clone — A storage or VM product wants first-class checkpoint / restore — fast enough that users treat checkpoints like git commit (cheap, often,…
• Checkpoint backup to object storage — A distributed state-distribution system (gossip, CRDT, replicated database) can enter a state where reasoning about the live data is harder than rebuilding it from scratch…
• Checkpoint before risky step — Before an AI agent executes any potentially destructive command in its sandbox, take a copy-on-write checkpoint of the sandbox state.…
• Checkpoint-resumable fiber — Run long-running agent work (tens of minutes to days) as a fiber — a regular async function — whose executions are registered in the host actor's durable storage before execution…
• CI as agent quality gate — The AI agent is inside the CI loop: when the CI pipeline runs on its PR, the agent reads the pipeline output, identifies failures,…
• CI/CD agent guardrails — Scale AI-agent autonomy progressively over time by layering CI/CD guardrails between agent-generated changes and production: required test execution, automated code review,…
• CI ephemeral database branch with schema-diff comment — When a pull request is opened against a repository that holds a schema migration, CI provisions an ephemeral database branch off mainline,…
• CI parallel over local serial — Invest engineering effort in making the full-suite path fast on CI (where parallelism and large agents are cheap), not on making the full-suite path fast locally (which almost no…
• CI pipeline as customer-authored durable workflow — Treat the CI/CD pipeline as a customer artefact, not a platform artefact: each repo ships its own CIPipeline extends WorkflowEntrypoint class in .cloudflare/ci.ts (or…
• CI regression-budget gate — A CI regression-budget gate is the pattern of (1) identifying a scalar cost proxy that correlates with a real system property (build time, binary size, memory footprint,…
• Circuit breaker — A circuit breaker wraps a call to a failure-prone dependency with a state machine that trips open when the dependency is failing at a threshold rate,…
• Classic DSP over ML for compute-constrained targets — An ML-based alternative to an established DSP (digital signal processing) technique exists and produces higher quality at the same bitrate / memory / operating point.…
• Clean reimplementation over adapter — When an adapter approach (reverse-engineering the output of a closed / bespoke upstream tool to reshape it for a target platform) becomes unsustainable,…
• Cleanup phase survives interruption — Design a multi-step state-mutation — acquire → act → release, mark → act → unmark, open → act → commit — so that the release / unmark / commit step is executed regardless of how…
• CLI safety as agent guardrail — When wrapping a CLI as an MCP server (wrap-cli-as-mcp-server) and exposing mutating operations to an LLM agent, rely on the CLI's existing human-operator refusal invariants…
• ClickHouse plus Snowflake dual storage tier — An event / IoT pipeline needs both the strengths of Snowflake (enterprise governance, SQL richness, managed compute-storage separation,…
• Client-committee key shares — Distribute the decryption key (or the hints needed to derive it) for an aggregate across a small, rotating committee of client devices — not the central server,…
• Client-driver fix over application workaround — When a production failure mode stems from driver-level behaviour (e.g. the wire-protocol client library, the language-level database driver, the low-level SDK),…
• Client-proximal leader pinning — On a multi-region cluster, pin each topic's partition leaders to the region where that topic's producer/consumer clients are concentrated,…
• Client-side compression over broker compression — Kafka-API brokers support two compression topologies:
• Client-side query rewriting — Client-side query rewriting is the practice of restructuring queries at the application layer to work around known inefficiencies in the database's query planner…
• Client-side schema validation — Validate events against schemas in a shared client library, on the publisher / subscriber side, rather than via a centralized validation service on the runtime path.…
• Closed feedback loop for AI features — An architectural discipline for employee-facing (and by extension customer-facing) AI features: every recommendation, ranking,…
• Closest-replica consume — On a multi-region (or multi-AZ) replicated cluster, route each consumer's fetch requests to the closest replica — leader or follower…
• Cloud region migration during conflict — Pattern: When a cloud region (or small cluster of regions) is in a geography experiencing active military conflict or sustained kinetic attack,…
• CloudWatch Metric Streams to VPC OpenTelemetry collector — A composite reference architecture for push-based, vendor-neutral metric ingestion that keeps all data inside the customer's VPC.…
• Cluster-wide aggregation guardrail — A cluster-wide aggregation guardrail is a backend-managed cap on the per-request aggregation bucket count, enforced inside the shared search backend — not at the caller.…
• Cluster a table by WHERE-clause columns to reduce data-scanned cost — You have an OLAP data warehouse — BigQuery, Snowflake, Redshift, Athena, Databricks — where per-query billing is proportional to bytes scanned,…
• Clustering keys as engine input — Hive-style table partitioning forces architects to commit to a specific physical layout — a fixed column choice that defines a directory structure — at table creation time.…
• Co-design with OCP partners — Building hyperscale hardware alone means paying the full design/validation/standardization cost of every subsystem. Building hyperscale hardware via bilateral or multilateral…
• Co-located inference GPU and object storage — Run inference GPUs and the object storage that holds their model weights / datasets on the same platform, in the same regions,…
• Code generation over tool calls — Instead of presenting an LLM agent with N individually-described MCP tool schemas and asking it to "pick a tool and fill in its parameters," *convert the tool surface into a typed…
• Code Mode MCP for data agent — A pattern for exposing a data agent's tool surface to its LLM that replaces the standard "30 individual MCP tools, one round-trip per call" shape with two meta-tools (search,…
• Code-split by route + intent prefetch — A two-part bundle-size discipline that addresses the JavaScript-boot bottleneck on hard-navigation cache hits:
• Codebase correction as implicit feedback — LLM-based coding agents inherit whatever patterns exist in the codebase they read. If a codebase has a sloppy pattern — a deep-clone where a reference would do,…
• Codec feature gradual rollout — Codec feature gradual rollout is the deployment pattern of enabling an already-standardised codec feature on a limited subset of titles first,…
• Codex enforced via AI code review — Codify an organisation's engineering standards into a machine-consumable ruleset, then enforce it on every merge request via an AI code-review substrate that can reason over…
• Cognito group → IAM role mapping — A multi-tenant SaaS authorization pattern: every tenant is backed by a Cognito user pool group linked to a dedicated IAM role with a scoped policy,…
• Cohort percentage rollout with explicit inclusion criteria — Specialisation of staged-rollout for fleet-wide enforcement rollouts (binary authorization, new auth model, mandatory MFA,…
• Cold-to-Hot Vector Tiering — Cold-to-hot vector tiering is the operational pattern of storing the full vector corpus in a cheap, storage-optimized index (the cold tier) and selectively promoting a subset…
• Collaborative throttler check API — When a database must be protected from massive batch workloads (migrations, online DDL, mass purges), the protection mechanism needs to be:
• Collective-library / transport co-design — In hyperscale AI training, the collective-communication library (NCCL / RCCL) and the network transport (RoCE / InfiniBand) are traditionally treated as separate layers:…
• Colocated child actor RPC — When an agent (or any parent actor) needs to delegate work to subordinates that each have their own state + tool surface but need tight coordination,…
• Colocation Sharding — Group related tables that share a shard key into a colocation ("colo"), and make the colo the unit of physical sharding. Tables within the same colo can still support cross-table…
• Column-level classification propagation — Automatically propagate data classification tags from input columns to output columns as data flows through ML pipeline modules.…
• Columnar time-partitioned feature storage — Store ML features (especially user event sequences) in a columnar, time-partitioned layout that behaves like a set of tables: each enrichment / feature lives in its own column,…
• Comparative documentation benchmark — Benchmark your documentation site's agent-consumption cost against competitor / industry-average documentation sites using a fixed agent model + client and a fixed set of technical…
• Comparative RUM benchmarking — You want to publish a credible, network-fair comparison of your CDN / edge / network product against competitors — not a marketing graph,…
• Compat native escape hatch — A cross-platform UI library (react-strict-dom) maps an HTML subset to native components (RN primitives on mobile, plain HTML on web).…
• Compatibility-mode client transition — A stateful datastore ships a new major version. The operations team wants to upgrade the cluster (security, performance, new features).…
• Compiled vs dynamic plugin tradeoff — When extending a host application with plugins, ship both an in-process compiled-plugin path (host's native language, linked into the binary,…
• Complexity-Tiered Model Selection — Complexity-tiered model selection is the pattern of routing each input to a different model stack based on an estimate of its complexity,…
• Component-level latency from OTel spans — Component-level latency from OTel spans is the pattern of computing per-span / per-tool / per-component latency percentiles (P50 / P99) directly over OTel-spans tables to attribute…
• Component-tree simplification — Flatten a component tree composed of many thin reusable wrappers into fewer dedicated, use-case-specific components. Pay some code duplication to win fewer render calls,…
• Composite hash uniqueness constraint — Pattern: enforce uniqueness or enable fast equality lookup across multiple columns at once by (a) building a MySQL generated column that hashes a delimiter-separated concatenation…
• Composite index for multi-column AND-predicate — Pattern: when a high-frequency query filters on colA = x AND colB = y AND …, a single composite index on (colA, colB, …) is the correct index design…
• Composite model pipeline — Wrap a core LLM in a structured pipeline of pre- and post-processing stages where each stage targets a specific failure mode with a specific latency budget.…
• Composite workflow pattern — Ship three engine-native workflow primitives — foreach, subworkflow, conditional branch — that compose into higher- order workflows.…
• Concurrency buffer stage for high-latency I/O — A concurrency buffer stage is a queueing stage inserted into a write pipeline immediately upstream of a high-latency I/O step,…
• Conditional animation for scroll performance — *Gate UI animations on two conditions — (a) interaction state (only animate when the user is not actively scrolling / interacting) and (b) device class (disable animation entirely…
• Conditional child state scoping — Move expensive / rarely-active state into conditionally-rendered child components so the state and its cost exist only when the state is active…
• Conditional optimisation by page depth — Pattern: when a cost transformation is a win in one regime but a loss in another (e.g. fast at page 100, slower at page 1), do not apply it unconditionally.…
• Conditional-probability ranking objective — Integrate a new ranking signal into an existing multi-objective ranker by adding a conditional-probability term P(outcome | new condition) with a tunable weight,…
• Conditional-write lease (CASAAS — single-writer via object-store CAS) — Implement a time-based lease — a mutex with expiration — on top of an object store's conditional write primitive. A single writer holds a lease file in the bucket;…
• Conditional-write transaction strategy — Replacing a graph database engine's default pessimistic locking with DynamoDB conditional writes and transaction APIs to ensure data integrity at lower overhead.
• Conditional Write (Compare-and-Set on Storage) — A conditional write is a storage-layer primitive that performs a write (typically PUT) only if a precondition on the current state of the target is satisfied…
• Confidence-thresholded AI output — An output-gating pattern in which an AI system refuses to emit a recommendation when its confidence is below a threshold,…
• Config-based soft-spacing framework — Soft-spacing penalties start out as one-off code for one sensitive content class (e.g. elevated-quality-risk content). As more quality axes get identified over time…
• Config deployment as code deployment — Apply the same staged-rollout + health-gating + automated- rollback discipline to configuration changes that already governs code deployments.…
• Config distribution for quota rules — Pattern: treat quota rules as a dynamic configuration payload and distribute them via the organisation's existing configuration- distribution substrate (feature flags,…
• Config-driven DAG generation — Config-driven DAG generation is the platform pattern in which customers declare a pipeline with a high-level configuration file (JSON/YAML/SQL + metadata) and a platform-owned…
• Config separated from code via pub/sub — Config separated from code via pub/sub is the pattern of publishing operational configuration (routing rules, A/B test definitions, traffic splits,…
• Configuration-as-code feature pipeline — Express sequence + enrichment + event-type definitions as configuration-as-code in a regular programming language (Pinterest uses Python) with a well-defined schema.…
• Configuration-driven tenant onboarding — Treat new-tenant onboarding as a configuration change, not an infrastructure-provisioning exercise. All infrastructure the new tenant depends on — VPC, subnets, load balancer,…
• Connection multiplexing proxy — A connection multiplexing proxy is a server tier placed between application clients and a database that:
• Connection timeout = RTT × 3 — Size the connection timeout as roughly three times the expected round-trip time between caller and server. It is a conservative default that covers the TCP three-way handshake (~1…
• Connector library as protocol abstraction — Connector library as protocol abstraction is the pattern in which a complex protocol (open table format, RPC framework, streaming wire protocol,…
• Connector transformations + enrichment API — Expose two distinct per-tenant customisation surfaces on a shared managed replication platform — one at the transport layer (Kafka Connect single-message transforms + custom…
• Conservative anomaly-gated config update — You have a learned or computed configuration artefact (classifier thresholds, routing tables, feature importances, rate-limit tiers,…
• Conservative capacity bin-packing during incident — An upstream capacity-provisioning failure (e.g. EC2 launch failure) has frozen the fleet at its current size. A known peak-traffic window is about to hit.…
• Consistency Checkers — SQL-based invariant tests that compare expected system state against data recorded across multiple sources of truth, run on a pre-defined cadence in both development…
• Consolidate database and search — Collapse the "primary database + bolt-on search engine + sync pipeline" shape into a single substrate where search is a first-class capability of the primary database and queries…
• Consolidate identical in-flight queries — When many concurrent callers ask the same read-only question against a backing store within a short window, issue the question upstream exactly once,…
• Constant-time state map — Replace O(n) array scans / multi-hop lookups on a hot path with O(1) access via a JavaScript Map (or nested Maps) keyed by the identifier the caller already has.
• Constrained memory API — An agent given raw database or filesystem access as its memory substrate will burn tokens designing queries and choosing storage strategies rather than doing the actual task.…
• Constrained-resource benchmark for shared-tenant capability disclosure — When benchmarking a multi-tenant substrate for customer-facing capability disclosure, cap the total resources at a tier-meaningful number,…
• Consumer-group partition exclusivity — Within a consumer group, each partition is assigned to exactly one consumer instance at a time. No two consumers in the same group can read the same partition simultaneously.
• Content-derived suggested questions — Generate user-facing "you could ask..." prompt suggestions from the specific entity's own content (reviews, owner description,…
• Context compaction service — Run a dedicated service before each LLM call that trims or summarises older tool outputs when the context approaches its token limit,…
• Context-encoded prompt handoff — A pattern for bridging a deterministic operator-side tool with a foundation-model LLM agent: the deterministic tool emits a prompt template populated with operator-environment…
• Context-segregated sub-agents — When an agent needs to do work that (a) would consume large amounts of the main context window, (b) needs a different tool surface than the parent,…
• Context template prompt with special tokens — For a generative-retrieval recsys decoder, structure the input prompt as a fixed-shape template with special tokens delimiting named segments…
• Context-threaded SQL tag propagation — Pattern: thread per-request SQLCommenter tags through the application stack via the language's explicit per-request storage primitive — in Go,…
• Continued pretraining for domain adaptation — Take a capable open-weights foundation model, continue-pretraining it on a balanced mix of domain-specific and general-domain replay data,…
• Continuous fault injection in production — Run fault-injection drills in production, during business hours, under engineer supervision — as a continuous, automated,…
• Continuous perf-record for time-travel — Loop perf record in fixed-size timestamped windows for hours or days, so that when a rare event fires you can load just the window that captured it.…
• Continuous red-team validation — Verify that a layered security architecture actually constrains blast radius in practice — not just on a whiteboard — by testing it continuously from both attacker perspectives…
• Contract-driven topic provisioning — Make the per-node contract.yaml the single source of truth for which topics exist on the broker, validated by regex + enum, and materialised by a single extractor that runs in CI,…
• Contrastive loss via taxonomy tree — Use a product / item taxonomy tree as the graded supervision signal for a contrastive loss term during representation learning,…
• Control-plane proxy with ETag cache — Decouple a large data-plane fleet from a shared upstream config source (Kubernetes API, service registry, auth server, any config store) by inserting a single coalescing proxy…
• Controlled experiment before shipping — Product teams shipping a UX change that adds a step to a conversion funnel face a recurring risk: the new step may improve the downstream metric (the thing the step is optimising)…
• Controlled rollout with traffic ramp-up — A new variant ships to 100% of users on day one. If the variant has a bug, everyone sees it. If multiple teams are coordinating a launch,…
• Coordinator-fronted sharded search — For large search indices that don't fit in a single primary-replica cluster, run a coordinator service in front of multiple per-shard clusters.…
• Coordinator / sub-reviewer orchestration — Decompose an AI-driven review / critique / analysis task into:
• Correlation-triggered re-verification — When a cross-session correlation signal fires on previously- classified sessions, force those sessions back through fresh telemetry collection and re-score…
• Cost-based load balancing (LLM) — Route LLM requests across replicas using server load measured in model units — not active request count, not RPS — and route through an auto-sharder that supports stateful sessions…
• Cost-model-driven incrementalization strategy — When an IVM engine refreshes a materialized view, it has multiple viable update strategies. No single strategy dominates across all workloads…
• Count over byte-size batch trigger — When a batching layer supports multiple batch-close triggers (accumulate until count messages OR bytesize bytes OR period ms elapsed — whichever first),…
• CRDT over Raft for WAN state distribution — You need every node in a globally-distributed fleet (dozens of regions, thousands of servers) to converge on the same view of some dataset.…
• Credential refresh cron as auth compat shim — When a data-plane resource enforces short-lived JWT auth, and the integrating application was designed for a long-lived credential (read once at startup, reuse forever),…
• Credential vending for external engine access — Credential vending for external engine access is the deployment pattern in which a central catalog or governance plane mints short-lived,…
• Credentialed proxy sandbox — When an agentic system needs to execute model-generated code that can act on a user's account, do not put the credentials inside the sandbox. Instead:
• Critic tool-call introspection suite — Give a critic agent a dedicated set of tools for inspecting peer agents' tool-use methodology — not just their claimed findings.…
• Cron-driven PR-closed cleanup — Decouple the teardown of per-PR ephemeral environments from the PR-close event itself. A separate cron polls the version-control system's PR API on a fixed cadence;…
• Cross-Cloud Replica Cache — Pattern: the canonical copy of a dataset lives in one cloud; a scheduled incremental-replication job materialises a local replica in each consumer cloud's object store;…
• Cross-DC semi-sync for durability — Place semi-sync replicas in a different datacenter / availability zone from the primary, so that an ack from a semi-sync replica implies the transaction is persisted outside…
• Cross-domain warm-start via shared embeddings — When a single ML task must be served across many related distributions, with one data-rich source domain and many data-scarce target domains (each new tenant, partner, region,…
• Cross-engine database migration audit — Cross-engine database migration audit is a pre-migration pattern: before moving a schema between two SQL engines (e.g. PostgreSQL → MySQL),…
• Cross-index unified retrieval — Let a caller query across many physically-separate search indexes in a single call, with the platform owning the fan-out, merge,…
• Cross-layer block tracing — When a layered protection infrastructure blocks a request, identify which tier made the block decision and which rule inside that tier matched…
• Cross-model prompt adaptation — Cross-model prompt adaptation is the pattern of treating the prompt not as a hand-written string tied to one model, but as a compiled artifact re-generated per target model…
• Cross-partition failover — An architecture that deploys duplicate infrastructure across two or more AWS partitions so a workload can continue operating when the primary partition becomes unavailable…
• Cross-payment-method fraud network — Operate fraud detection across a heterogeneous portfolio of payment methods (cards, bank debits, BNPL, wallets, crypto, real-time payments,…
• Cross-platform base image — A workload needs to run in multiple execution contexts — e.g. managed training jobs, interactive notebooks, and K8s serving pods…
• Cross-region read via object storage — Serve read traffic in regions where producers do not live by reading segment files from the shared object store instead of replicating the stream to a second broker cluster.…
• Cross-repo tracer fan-out — When a confirmed bug lives in a shared library consumed by multiple downstream repositories, decide whether the bug is reachable from outside separately for each consumer repo…
• Cross-surface enrichment via internal service — When domain data surfaces on multiple product pages (a landing page, a product detail page, an email campaign), store IDs in the CMS and enrich the IDs with values from the system…
• Crossplane composition (XRDs + Compositions) — Package N cloud primitives behind one high-level Kubernetes custom resource via Crossplane's two-part mechanism:
• Crypto-API guardrails — Prevent the creation of new cryptographic usages vulnerable to a known-coming weakness (typically: quantum-vulnerable primitives ahead of a PQC migration) by applying friction…
• Cryptography-plus-TEE defense in depth — When the workload requires provable confidentiality of per-user data and the deployment substrate is a server you do not fully trust (or that you don't want users to have to fully…
• CSV-in / Parquet-intermediate / output-merge — Accept user-friendly file formats (CSV or Parquet) at the service boundary, but immediately convert to a columnar intermediate format (Parquet) for all internal processing…
• CTE-emulated upsert — CTE-emulated upsert is a Postgres query pattern for "insert-or-update" semantics that replaces the built-in INSERT ... ON CONFLICT DO UPDATE with a data-modifying Common Table…
• Custom benchmarking harness — When a vendor-supplied benchmark tool doesn't match your workload shape or reports the wrong latency metric, write a narrowly-scoped custom harness against the same API.…
• Custom data structure for hot path — When stdlib or well-known crate data structures don't match your workload shape on a genuine hot path, write one that does.…
• Custom L7 proxy for telemetry over service mesh — Build a purpose-built L7 ingress tier for observability / telemetry traffic, running independent of the general-purpose service mesh that carries business traffic.…
• Custom operator over StatefulSet — Running a stateful workload (database, broker, stream processor) on Kubernetes normally uses a StatefulSet — the Kubernetes-documented default for stateful workloads.…
• Custom TalkBack actions as gesture alternative — Custom TalkBack actions as gesture alternative is the Android pattern of exposing any gesture-only interaction — drag-and-drop, long-press, swipe-to-dismiss,…
• Customer-cohort segmented service instances — Run a critical service as multiple independent instances, each handling a distinct customer cohort — free vs. paid, enterprise vs. self-serve, region vs.…
• Customer-community-tag export policy — Customer-community-tag export policy is the BGP export configuration pattern in which a router's outbound policy requires each advertised route to satisfy two independent…
• Customer-Driven Feature Prioritization — A product-development practice: feature selection and ordering are driven directly by customer requests, not by internal roadmap speculation.…
• Daily-diff cron for automated migration — The delivery channel for a large-scale automated migration: an internal cron system produces a daily batch of migration diffs against user-defined selection criteria,…
• Daily MySQL Snapshot Plus Spark ETL — You need to build an OLTP-to-analytics pipeline where:
• Daily S3 vectorstore update pipeline — Keep a RAG vectorstore fresh on a daily cadence via a scheduled batch job that:
• Dark-ship for behaviour parity — Dark-shipping is running a new implementation of a subsystem in parallel with the old one inside the live production request path, for a sampled fraction of real traffic,…
• Data Abstraction Layer (DAL) as a service — The Data Abstraction Layer as a service pattern puts a dedicated RPC service (typically gRPC) between microservices and the actual database(s),…
• Data Application Productization — When a question or workflow repeats often enough, turning the underlying logic into a simple application saves time and reduces cognitive load across teams.…
• Data-center density optimization for GPU clusters — At GPU-cluster scale (~10K+ GPUs), the bottleneck shifts from compute silicon and fabric switches to the data hall itself: power capacity, cooling capacity,…
• Data-driven allowlist via monitoring mode — Shipping a default-deny enforcement system (allowlist-based access control, binary authorization, egress firewall, API-allowlist gateway) without first observing the actual…
• Data-driven annotation curation — Replace blanket per-site daily annotation with intelligent, performance-driven curation that directs human labelling effort only where it would most improve the model.…
• Data-placement spreading — For each new object, choose a different subset of drives to place it on — even for objects owned by the same tenant, in the same bucket.…
• Data-quality analysis tool with edge-case logging — The data-quality analysis tool with edge-case logging pattern is a debugging primitive on top of a warm-query telemetry store: log mismatches at first detection in aggregate form…
• Database as data router — During a zero-downtime migration, the operator wants to validate the application against the destination database before committing to it as primary.…
• Database as final arbiter of uniqueness — Pattern: for any logical uniqueness invariant, the database's unique index (or equivalent row-lock-based conditional insert primitive) must be the final authoritative check…
• Database as real-time message broker — An application needs to fan out heterogeneous real-time events (chat, presence, call state transitions, media frames, notifications) to many connected clients.…
• Database as tile server (middleware replacement) — Web maps over large geospatial datasets cannot ship the full dataset to the browser — "over 100,000 polygons… would slow down map navigation a lot" (Source: ).…
• Database branch per test over mocking — On a substrate where database branching is sub-second and cheap (copy-on-write storage fork; e.g. Lakebase / Neon), replace database-interface mocks with per-test / per-PR / per-…
• DB-authoritative with WebSocket notify — Serve real-time UIs by splitting correctness and latency into two channels: a durable transactional database is the source of truth for every state change;…
• DB-Routed Request Proxy — A reverse proxy makes its per-request upstream-selection decision by querying a database rather than by consulting a static configuration file or pre-loaded in-memory map.…
• De-obfuscate via redundant condition — Pattern: when a query's WHERE clause wraps an indexed column in an expression that defeats the index (see index obfuscation), and you cannot rewrite the predicate to be sargable,…
• Dead-letter queue for invalid records — Dead-letter queue for invalid records is a validation pattern where a data pipeline's producer-side validator redirects records that fail validation to a separate queue…
• Debezium + Kafka Connect CDC pipeline — The canonical open-source shape for change-data-capture at scale:
• Declarative CDC over hand-rolled MERGE — Pattern. When building a CDC or SCD pipeline, prefer a declarative API (where the author names semantics — keys, sequence column, delete predicate,…
• Declarative load-test conductor — Declarative load-test conductor is the pattern of building a dedicated, long-lived microservice that owns the complete lifecycle of a load test — deploy production versions,…
• Declarative schema management — Database schemas drift over time — columns get added on one environment but not another, indexes get created manually during an incident and never propagated,…
• Declare boot interface order upfront — Eliminate guesswork in the network boot interface probe stage by declaring the correct interface upfront in the pre-boot PXE stage for each hardware + use-case combination,…
• Decoder-side synthesis for compression — Decoder-side synthesis for compression is the architectural pattern of transmitting the parameters of a generator that can reconstruct a signal rather than transmitting the signal…
• Decouple frontend build from backend artifacts — In a monorepo with both a backend (Python, Ruby, Java, Go) and a frontend (TypeScript, JavaScript), it's common for the frontend build's dependency graph to transitively include…
• Decouple reads from writes at storage layer — Decouple reads from writes at storage layer is the architectural move of making the read tier and the write tier independent of each other by inserting a shared object-storage…
• Decouple What From How In Preferences — Decouple "what" from "how" in preferences is the schema-design pattern of splitting a preference axis that conflates what to notify / show / deliver with how to notify / show /…
• Decoupled compute and serving stacks — An ML platform runs two fundamentally different workload classes — compute (training, batch inference, hyperparameter optimisation,…
• Decoupled parallel retrieval pipelines — Run lexical (inverted-index + BM25) and dense semantic (encoder + ANN) retrieval as parallel, independent pipelines, fed by a shared query-preprocessing stage,…
• Decoupled state commit from data commit — Stop bundling state-change commits inside data-commit boundaries. In systems where both data (rows, documents, segments) and state (schema, settings,…
• Dedicated application_name per workload — Pattern: use distinct Postgres applicationname connection- string parameters per logical workload (web tier / background jobs / one-off scripts / migrations / analytics),…
• Dedicated backend training fabric — Hyperscale AI training clusters have qualitatively different network requirements from the rest of the data center:
• Dedicated backup instance with catchup replication — A production database's backup has two conflicting requirements:
• Dedicated ECS cluster per tenant — Provision one dedicated ECS cluster per tenant inside a shared-account infra group. Each cluster runs only that tenant's workload, loads only that tenant's in-memory state,…
• Dedicated host pool for hostile peripheral — Segregate worker hardware so that VMs using a risky hardware peripheral (GPU, FPGA, DPU, custom NIC, HSM) do not share a physical host with VMs that don't use that peripheral.…
• Dedicated observability Kubernetes clusters — Run the org's observability workloads (metrics ingestion, storage, query, dashboards, alerting) on Kubernetes clusters dedicated to observability…
• Deduplicate decode across encoder lanes — When a multi-lane video transcoding pipeline must produce many encoded outputs from a single source (typically a DASH ladder),…
• Deep-link indirection middleware — In an SDUI-first mobile app, you want new screens to ship without client releases. But deep-links — zalando://stories/ 123, https://…/stories/123 via universal links,…
• Deep link to UI from CLI — A CLI that drives a system with a rich web UI emits deep links back into the UI — precise URLs that land the human at the exact dashboard / alert / SLO / trace view that the agent…
• Default-closed allowlist with automated PII scan — The implementation pattern that makes default-closed table allowlisting operationally tractable. New tables enter the data platform in a pending state;…
• Default continuous profiling — Default continuous profiling is the operational posture of running a low-overhead continuous profiler on every host, all the time,…
• Default-on security upgrade at no additional cost — A product-strategy pattern where an infrastructure provider ships a security capability as a universal, default-enabled platform behaviour…
• Defense in depth for webhook abuse mitigation — When building a webhook-sender service, no single defence is sufficient against all abuse shapes. The canonical shape is a layered composition of orthogonal mitigations,…
• Deferred-copy cached collection — When a hot-path operation needs read access to a large shared collection, and the collection is read-mostly (many concurrent readers, occasional writers),…
• Deferred join for offset pagination — Pattern: when an application needs to paginate a large table with LIMIT N OFFSET M and M becomes large, rewrite the query as an inner index-only primary-key selection + outer…
• Deferred re-duplication at GPU — Request-level data in a recommendation-system batch — especially ~16K-token user sequences — is identical across all candidates in a request.…
• Delayed symbolization service — Delayed symbolization service = the system shape where production hosts ship raw instruction addresses + unwound stacks to a centralised off-host service that resolves them…
• Delayed timeout task as crash safety net — Give a durable workflow near-zero happy-path overhead while still guaranteeing crash recovery, by scheduling a single delayed timeout task in the persistent scheduler at workflow…
• Delete inner parallelization inside outer orchestrator — A tool or component has its own worker pool / thread pool / multiprocessing logic because at the time it was written, no outer orchestrator existed.…
• Demo harness for SDUI rendering — In an SDUI system, the authors of new screens (typically web developers) need to iterate on:
• Deny-overrides-allow — An effect-resolution rule in permissions engines where, given a set of policies that apply to a (principal, action, resource, context) request:
• Dependency update discipline — A narrowly-scoped but frequently-ignored operational pattern: keep track of what needs updating, update for security fixes and important bug fixes,…
• Deploy-marker overlay on time-series — Problem. A metric changes shape — latency drops, throughput spikes, error rate flips. The operator needs to know "did a recent deploy cause this?"…
• De-prioritize all except target — Prioritisation and de-prioritisation are duals. To prioritise one client identity without explicit exemption, set a high default rejection ratio globally,…
• DES + gradient-free optimiser under uncertainty — Many real-world decision problems have the following combination of properties:
• Design-system component library cross-platform — You maintain a design system — buttons, cards, dialogs, typography, etc. — and you want a single design-system component library that renders on web + iOS + Android with consistent…
• Destructive operation confirmation as agent guardrail — A CLI tags destructive commands in its machine-readable catalog and fails any invocation of a destructive command that doesn't carry an explicit confirmation flag.…
• Destructive testing on ephemeral branch — When database branching offers sub-second reset at zero storage cost, destructive testing becomes a daily development option rather than a quarterly operations exercise.…
• Deterministic intent with ML fallback — For command-interpretation surfaces (voice assistants, chat bots, CLI NL translators), route every input through a deterministic intent engine first — hand-authored phrases,…
• Deterministic key hash for partition affinity — Problem. A Kafka consumer receives a stream of aggregate-shaped messages (counts, sums, mergeable sketches) and wants to merge messages that share the same logical key before…
• Deterministic + model autofixer — For post-stream code repairs where the fix requires both an objective invariant check and a judgment about where / how to emit the fix, combine:
• Deterministic rule ordering — Deterministic rule ordering is the pattern for building a ranker / decider (e.g., "which of these two candidates is better?") out of a fixed-order list of rules plus…
• Deterministic task caching — Cache the outputs of workflow tasks keyed on their parameters + input data fingerprints. When a subsequent run invokes a task with identical inputs,…
• Dev shard iteration loop — Every feature gets deployed to an isolated dev shard on a real cluster — not a unit-test mock, not a local emulator — where the agent deploys, runs e2e tests, fixes issues,…
• Developer-owned schema change — Make a production schema change feel like a production code change: the same author writes it, the same review system approves it, the same pipeline ships it,…
• Developer portal as interface — An internal developer platform exposes its capabilities through one intuitive frontend — the developer portal — that hides all underlying tooling (Kubernetes, Crossplane, OPA,…
• Device blocklist from telemetry — A device blocklist from telemetry rolls out a new backend/feature/API to client devices by gathering compatibility signals from live sessions, aggregating per-device-class,…
• Diagnose via heap-dump lock introspection — Thread dumps tell you who is waiting for what, but not always who holds what. Several failure modes make the thread dump silent about the lock owner:
• Diff-artifact validator for build refactor — Migrating a large, tangled build system to a new one (e.g. moving a multi-language pipeline onto Bazel) is a high-risk, long-duration project.…
• Diff-based static analysis — Pattern: run the code indexer on each diff (pull request) to produce a machine-readable summary of the change (" diff sketch"),…
• Digest-based query prioritization — Problem. A production MySQL workload executes thousands of distinct SQL patterns daily. Manually running each query to find the slow ones doesn't scale;…
• Direct-attached NVMe with replication — Run each database instance on a direct-attached NVMe drive (local, fast, ephemeral) and solve the "instance dies, data dies" durability problem with application- layer replication…
• Directive-based field authorization — A mixed-domain GraphQL graph — one where a single query may fetch public product data alongside confidential customer data…
• Directive-based field lifecycle — A new GraphQL field goes through three stages between creation and non-breaking stability:
• Directive-based HTTP endpoint partitioning — A vanilla GraphQL deployment collapses every operation — every mutation, every query, every subscription — onto a single HTTP path, canonically POST /graphql.…
• Directive-based PII redaction — Observability pipelines (structured logs, distributed traces) typically capture request variables verbatim for reproducibility…
• Directive-driven entity codegen — An entity-based GraphQL schema — Zalando's UBFF is the canonical wiki instance — (entity-based-page-composition) repeats the same structural boilerplate for every entity type:
• Director / Expert / Critic investigation loop — Run a long-running investigative agent task (security alert triage, root-cause analysis, deep research, incident review) as a three-persona agent team with a round-based loop:
• Disable default systemd units in base image — When you inherit a cloud base image or distro golden image, audit its default-enabled systemd units and disable anything that doesn't match your deployment shape…
• Disable GraphQL in production — A GraphQL endpoint that accepts arbitrary, well-formed queries is by design open to any query shape a client cares to send.…
• Disable legacy crypto before rotate — After enabling new cryptographic primitives (typically post- quantum), the migration is not complete until two further steps are executed in order:
• Disaggregated inference stages — Disaggregated inference stages is the serving-side architectural pattern of splitting distinct stages of a multi-stage inference pipeline onto separate tiers of servers,…
• Diskless / disk-lite hybrid streaming — Capture the cross-AZ bandwidth savings of a fully diskless streaming shape (object-storage-as-data-plane) without sacrificing the Kafka-protocol guarantees — transactions,…
• Disposable VM for agentic loop — Instead of running an LLM-driven agentic coding loop on the developer's laptop (or on any shared dev server), spin up a disposable, clean-slate VM per task / session,…
• Disruption-Budget-Guarded Upgrades — Disruption-budget-guarded upgrades is the pattern of protecting workloads against platform-driven node churn using three composable primitives:
• Distribute DNS load to host resolver — When a central DNS-server cluster saturates a per-ENI resolver rate limit (canonical case: the AWS VPC resolver 1,024-pps-per-ENI cap), the fix is topological,…
• Distributed fleet as data pipeline — Treat a deployed fleet of edge devices — smart carts, cameras, vehicles, robots, phones, sensors — as a distributed data-collection pipeline feeding ML model training.…
• DNS health check cutover — Cut over production traffic from the original (compromised / failed) environment to the rebuilt/recovered environment using DNS records with health checks so traffic shifts only…
• DNS proxy for hostname filtering (eBPF) — DNS proxy for hostname filtering (eBPF) is the pattern of turning a kernel-level packet / socket firewall into a hostname-based allow/deny list by redirecting the target processes'…
• Durable-Object-backed Git server — Durable-Object-backed Git server is the substrate pattern for serving a Git repo per storage unit: one Durable Object per repo hosts the Wasm Git server + embedded storage;…
• DO-plus-KV edge config distribution — A DO-plus-KV edge config distribution is the recurring Cloudflare architecture for hot-read, rare-write configuration surfaces: a per-unit Durable Object holds the source of truth…
• Dogfood as adoption proof — Dogfood as adoption proof is the organizational pattern of a platform / SRE team applying its own new framework to its own services for a bounded trial period,…
• Domain-driven data modeling choice — Empower each domain team to choose the data model shape (separate or monolithic) that best fits their specific business domain,…
• Double-buffer + CUDA events for pipeline overlap — The double-buffer + CUDA events for pipeline overlap pattern is the safety half of GPU pipeline overlap, sibling to dual-cuda-stream-compute-and-copy-overlap: it duplicates…
• Downsample / recode for long-term archive — Before moving media into long-term retention (cold storage, Glacier, tape), re-encode or downsample it to a lower- fidelity format that preserves just-enough quality for compliance…
• Draft PR for conflicts — When an automated pipeline encounters a merge-conflict it can't resolve, don't fail or stall — open a draft PR with the conflicted state intact, label it clearly,…
• Draft-verify inference — Draft-verify inference is the generalised pattern behind speculative decoding and speculative cascades: a cheap generator proposes a block of output,…
• Drafter-Evaluator refinement loop — Interpose a reasoning-focused Evaluator agent between a fast generative Drafter agent and ship-to-user, so the Drafter's output is never shipped without passing a rubric.…
• Drag-and-drop CMS layout — In a headless-CMS stack with modular entry-type composition, give authors a drag-and-drop UI that lets them add, remove, and reorder module references on a page…
• Drop non-critical metrics under TSDB overload — Mitigate time-series-database (TSDB) overload — whether driven by traffic spikes, cluster degradation, or pre-scaling multiplicative-fan-out…
• Dual-architecture CI builds — For a multi-quarter mobile framework migration (React Native's old → new architecture is the canonical example), build and test the app under both the current and the target…
• Dual CUDA stream compute and copy overlap — The dual CUDA stream compute and copy overlap pattern is the narrowest form of GPU pipeline overlap: split GPU work onto two CUDA streams…
• Dual-granularity rollup tables — Problem. A time-series UI has two modes: a "show me last month" zoom-out and a "show me last hour" zoom-in. A single-granularity store punishes one or the other…
• Dual-layer governance — SQL-statement guard plus per-tool access guard — When an MCP server (or equivalent agent-facing surface) brokers AI-agent access to a database, defend the database with two independent guards: a SQL-statement guard that inspects…
• Dual-metric disambiguation — *When a single top-line metric is elevated by two different underlying pathologies, emit a second cause-tagged metric whose values uniquely identify each pathology.…
• Dual-owner approval for metric changes — Require both the Business Owner and the Operational Owner to approve any change to a governed metric's definition before it is merged into the canonical package.
• Dual-pipeline deprecation — Safely decommission legacy data tables by running old and new pipelines in parallel for validation before cutting over, minimizing risk to downstream consumers.
• Dual positive signal for sparse labels — When the primary training signal is sparse, noisy, or delayed, supplement the positive set with a second, denser engagement signal…
• Dual-run version-specific proxies — During a major-version upgrade of a datastore whose data proxy is pinned to a specific major version of the datastore, run two parallel proxy fleets — one per major version…
• Dual-store graph + search index — The dual-store graph + search index pattern is a storage shape for catalog / metadata / discovery services where:
• Dual-stream telemetry pipeline — Pattern: emit observability data over two independent streams — a per-occurrence "notable" stream carrying full-fidelity data for the rare interesting tail (slow, heavy,…
• Dual-system sync during migration — Dual-system sync during migration is the intermediate-state posture where a legacy system and a strategic system that replaces it are both live in production,…
• Dual-tier observability (TSDB + lakehouse) — At hyperscale, neither a TSDB alone nor a lakehouse alone is adequate for an observability platform:
• Dual-write branch cutover via new cluster — Problem. A sharded cluster needs to grow shard count (4 → 8, 8 → 16, etc). A live Vitess / logical-replication reshard is available but:
• Dual-write migration — Dual-write migration is a pattern for protocol/backend transitions where producers emit to both the legacy and the new system simultaneously for the overlap window.…
• Dual-Write to Online and Offline Store — Dual-write to online and offline store is the ingestion-time discipline of a feature-store-shaped or embedding-store-shaped platform writing every new record to both storage tiers…
• Durability review — A durability review is a structured gate applied to any code change that could affect a service's durability posture. The artifact is modeled after a security threat model (see…
• Durable chain of custody — To defend against data corruption between the customer and the storage service — network flips, buggy middleboxes, memory errors on intermediate hops…
• Durable event log as agent audit envelope — Every agent interaction — prompt, input, context retrieval, tool call, output, and action — is captured as a first-class durable event on a streaming log.…
• Durable micro-VM for agentic loop — Run an LLM-driven coding agent loop inside a persistent, per-user (or per-project) micro-VM that survives across agent sessions — the VM keeps installed packages, written files,…
• Dynamic allowlist for safe exposure — *Maintain a runtime-configurable allowlist of (endpoint, field/identifier, context) tuples where sensitive data exposure is intentional and safe,…
• Dynamic binding over static binding — For every platform primitive that currently binds a single resource at deploy time (one Worker class, one Workflow class, one Durable Object namespace, one queue handler),…
• Dynamic cardinality reduction by tag collapse — Pattern: an observability aggregation pipeline that emits one message per unique tag combination runs two dynamic cardinality reducers that observe in-flight data and collapse…
• Dynamic content filtering in MCP pipeline — Treat the MCP server tier not as a static tool-description endpoint, but as a data-pipeline layer where every MCP tool call passes through a declarative content-filter (Bloblang…
• Dynamic control loop tuning — Replace a static, manually-tuned threshold (or weight, or budget) with a control loop that adjusts it based on fleet-level signals.…
• Dynamic environment composition — Compose a new execution environment at flow-run time from the environments of upstream flows plus additional dependencies of the current task…
• Dynamic /index.md fallback — Expose every page's markdown representation at /index.md, implemented dynamically via HTTP rewrite rules rather than by duplicating content.…
• Dynamic knowledge-injection prompt — Rather than rely on web-search RAG (vulnerable to the telephone-game failure mode) or a frozen baseline system prompt (vulnerable to the training-cutoff dynamism gap),…
• Dynamic partition split async pipeline — A four-stage asynchronous pipeline for detecting wide partitions on the read path, planning a split, executing the split into a separately-named target table validated…
• Dynamic prompt composition via semantic retrieval — Instead of shipping one large monolithic system prompt that carries every instruction, example, and edge case the system has ever needed,…
• Dynamic routing — use LLMs selectively — Not every input needs an LLM. Dynamic routing is the architectural pattern of using a streaming filter / routing layer to:
• Dynamic-schema field-name encoding — Reduce document size + storage footprint of MongoDB collections that use the bucket-pattern + computed-pattern combo by promoting a bounded-cardinality discriminator from a value…
• Dynamic subsetting load balancer — Auto-tune the subset size (the "aperture") that an on-host proxy balances across, so each proxy maintains connections to only a fraction of the total backend pool…
• Dynamic UI generation — Instead of returning text-only responses, an agentic interface generates UI components alongside text, selected from a library of visual blocks (charts, tables, architecture maps,…
• DynamoDB Streams + Lambda outbox relay — The DynamoDB Streams + Lambda outbox relay pattern is the DynamoDB-native realisation of transactional outbox: the service writes only to its DynamoDB table in the synchronous…
• E2E test as synthetic probe — E2E test as synthetic probe is the pattern of running a small set of browser-driving end-to-end test scenarios on a scheduled cron against live production,…
• Earliest-finish-job greedy — Earliest-finish-job greedy is the online scheduling primitive of "iteratively [scheduling] the job that finishes earliest" among all queued candidates,…
• Early ack on durability — Respond to the client as soon as a write has reached the durable stage of the two-phase tentative-then-complete commit path,…
• Early launch on low-traffic screen — You're rolling out a new architecture (e.g. React Native into a legacy native app, or a new framework version, or a new serving stack) and you want to learn — build observability,…
• Early queue-conflict warning — When a long-serial queue processes heterogeneous submissions — each taking minutes to hours — the feedback loop for a failed submission can span the full queue wait time.…
• eBPF header rewrite on egress — Shape: when a packet-header field must hold a value that the control plane hasn't computed yet at tunnel-creation time — but will compute before the first packet flows…
• eBPF map for local attribution — A userspace control-plane daemon writes identity state into an eBPF map; the kernel-resident data-plane program (attached to a tracepoint, kprobe, XDP,…
• Edge-managed protocol complexity — Edge-managed protocol complexity is the pattern in which a CDN (or edge provider) absorbs the implementation cost of a new HTTP / transport protocol that is technically possible…
• Edge-middleware bot-beacon injection — To measure how search-engine crawlers actually render your pages (not what the crawler vendor says they do), use programmable edge middleware to:
• Edge proxy as telemetry collector ingress — Browser-side observability requires sending telemetry (spans, metrics) from a customer's browser on the public internet to an internal collector. Three structural problems arise:
• Edit-quiescence indexing — Edit-quiescence indexing is the indexing-trigger pattern of delaying index updates until a document has been stable — no edits — for a wall-clock threshold (Figma: 4 hours).…
• Eject failing PR, keep queue running — When a merge-queue's future-state pipeline fails for a queued PR, remove that single PR from the queue (leave it open with the failure results attached to the PR) and let the queue…
• EKS add-on as lifecycle packaging — An AWS-native Kubernetes operator (or dependency controller) ships initially as a Helm chart. Customer installation requires:
• EKS Cost Allocation Tags — Use AWS Billing's split cost allocation data for EKS to map Kubernetes-native identity dimensions (cluster / namespace / deployment / node) directly onto AWS cost allocation tags,…
• Elastic scaling for production spikes — Absorb the inherently spiky demand of film / TV production workloads — long quiet intervals punctuated by bursts requiring thousands of parallel jobs…
• Eliminate partial updates — In a CRDT-replicated state-distribution system, producers face a choice for how to publish changes:
• ELT on Workflows with DO state — A pattern for building an internal ELT (extract, load, transform) engine on top of Cloudflare's Developer Platform. Pipelines are YAML-frontmatter-defined SQL DAGs;…
• Embedded dashboard with zero-trust iframe — A pattern for embedding analytics dashboards into other internal tools that defends in depth via three layers: CSP frame-ancestors to restrict embedding sites,…
• Embedded decode recipe in frame — Format-aware compression produces per-use-case configurations (Plans, dictionaries, graphs). If the decoder needs out-of-band knowledge of which config produced a given frame,…
• Embedded OPA in proxy — You want policy-based authorization enforcement on every HTTP request, at scale. The canonical OPA deployment is either "OPA-as-sidecar" (one OPA container next to every app pod)…
• Embedded routing header as address — Use a large address space (typically IPv6, 128 bits) to encode routing information directly into the address so the forwarding plane can make decisions with static routes against…
• Embedded SRE team from customer pull — The customer-pull pattern for provisioning an embedded SRE team: the product area whose code the embedded team will work on requests the team,…
• Embedding-based name resolution — For a library whose symbol namespace churns (icons, emoji shortcodes, component library exports, translation keys, etc.),…
• Embedding Ingestion Modes (batch + Insert API + on-the-fly) — Embedding ingestion modes is the pattern of a centralized embedding platform exposing three complementary ingestion paths — matching different producer shapes, volumes,…
• Emergency bypass — An explicit, audited escape hatch around the normal change-management pipeline for when incident-response speed matters more than review strictness.…
• Emoji-swarm real-time aggregation — Four-stage pipeline that turns a firehose of per-user clicks into a single low-frequency broadcast mood signal:
• Encapsulate optimization as internal service — Shape: when team A spends years optimizing an infrastructure primitive (a hypervisor topology, a storage substrate, a networking stack) and team B needs the same primitive…
• End-to-end recompute — End-to-end recompute is a pipeline-design pattern where the output is always a deterministic function of the source data,…
• End-to-end use case first (platform bring-up) — When building a cross-cutting platform (a privacy primitive, a governance system, a new runtime feature) that will eventually serve many customers and many requirement shapes,…
• Enforcement throttler proxy — Put the throttler in the query path — as a proxy, or embedded in an existing one — so it can actively delay or reject database requests rather than asking the client to respect…
• Enterprise AI tool registry — An enterprise AI tool registry is an organisation-internal catalog of the tools an organisation's AI agents can call, with four functions…
• Entity-to-Renderer mapping — In an entity-based page-composition system, each request produces a tree of typed Entities (e.g. Product, Collection, Outfit) chosen by personalisation.…
• Envelope-and-verify — For high-stakes agentic AI systems, the architecture Byron Cook prescribes is a three-part discipline:
• Environment-variable interpolation for bash — Problem: GitHub Actions script injection — attacker-controllable ${{ github.event.* }} fields (PR title, branch name, filenames,…
• Ephemeral per-trip sensitive input — A two-sided marketplace needs one party to give the other party a piece of high-sensitivity information for a single interaction — a gate code, a building access pin,…
• Ephemeral preview environments — Deploy a full application stack (or a scoped subset) as a short-lived, IaC-defined cloud environment on demand, run end-to-end validation against it, and tear it down when done.…
• Ephemeral preview URL via port-forward — In a session-scoped dev environment on a platform-owned substrate, automatically detect any bound port the running application opens,…
• Ephemeral sandbox benchmark pair — Developer laptops and shared CI runners have unpredictable ambient load — Slack notifications, Spotlight indexing, cron jobs, browser tabs, antivirus scans, metrics agents,…
• Ephemeral VM as cloud IDE — Spin up a fresh VM per user session, deliver its shell as a browser-based IDE, and tear the VM down at session end. The browser tab is the editor UI;…
• Epoch stamp on object ID for GC — When designing a system that produces temporary objects with unbounded peak counts and a clear "processed everywhere" condition,…
• Error extensions-code for developer-actionable errors — For every failure mode whose action-taker is the Developer (front-end engineer / client code) — not the Customer — model the failure as an entry in response.errors carrying…
• Error isolation per feature wrapper — You are composing a response from many independent units (features, widgets, panels) and you want:
• Error message as self-serve permission request — A UX pattern for governance-heavy data platforms: when a user hits an access denial, the error message is not 'permission denied' — it's a self-serve permission-request flow.…
• Evaluation Harness in Agent Loop — An LLM-based code-generation agent iterates on its output by consuming feedback. Naive feedback shapes — scalar wall-clock time, binary pass/fail on a test,…
• Event-boundary-driven recovery point selection — When recovering from a confirmed cyber event, don't pick the most recent backup — pick the most recent backup before the event boundary that also passes the validation pipeline.…
• Event-driven config refresh — A reactive cache-invalidation pipeline for configuration data that eliminates the TTL-vs-staleness dilemma by pushing updates from the config source to live service instances…
• Event-Time / Content Filter for State Write Reduction — Event-time / content filter for state write reduction is the pattern of dropping incoming stream events inside a KeyedProcessFunction when they would result in a no-op update…
• Event-type-by-event-type shadow cutover — For migrating a multi-tenant ML data platform from a legacy substrate to a redesigned one, walk per-event-type: shadow-run, two-tier-compare (event-level + sequence-level),…
• Evidence library with auto-selection — Maintain a persistent merchant-curated document corpus (uploaded once) and auto-select the appropriate subset per case based on multiple orthogonal classification keys.…
• Exclusion list for known issues and out-of-scope rules — A team runs automated checks (accessibility, linting, security scanning) against a production codebase. Some violations are:
• Executable specification — Write a compact model of the system under test, in the same language as the production implementation, commit it to the same repo,…
• Exhaust simpler scaling first — When a database starts hitting capacity limits, climb the scaling ladder one rung at a time — vertical scaling → read-replicas → vertical sharding → horizontal sharding…
• Expand-and-contract schema migration — When a schema change is irreversible (e.g. dropping a column, renaming a table), split the work across multiple migrations deployed in separate cycles:
• Expand-migrate-contract (parallel change) — Expand-migrate-contract (also known as parallel change, backward-compatible changes, or colloquially the expand-contract pattern) is the canonical six-step discipline for changing…
• Expiring incident mitigation — Treat every protective control added during an incident as temporary by default — each ships with metadata (owner, incident reference, review date,…
• EXPLAIN-before-EXECUTE validation — EXPLAIN-before-EXECUTE validation is the safety pattern for LLM-generated SQL: before running a generated query against the real data,…
• EXPLAIN-driven index verification — Always run EXPLAIN on the query to confirm the index is actually being used — creating an index and hoping is not a verification.…
• EXPLAIN for index verification — Before asking why MySQL isn't using an index, first verify that it isn't — prepend EXPLAIN to the suspect query and read possiblekeys, key, type,…
• Explainability log — Explainability log is the pattern of emitting a structured, per-decision record of everything a non-trivial algorithm did on a given invocation (candidates seen, choice made,…
• Explicit backpressure policy — When a bounded buffer in a streaming pipeline fills and the producer wants to write more, there are only four possible responses (reject, block, drop-oldest, drop-newest).…
• Explicit Boundary Translation — Explicit boundary translation is the implementation pattern that realises boundary-as-feature: when two abstractions genuinely differ on load-bearing semantics,…
• Explicit placement hint — Pin a serverless / edge compute unit to a specific region — overriding the platform's default user-proximity routing — so the compute runs adjacent to a stateful dependency…
• Explicit timeout on remote calls — Set both the connection timeout and the request timeout explicitly on every remote call. Never rely on library defaults; never leave a timeout unset on the theory that "it probably…
• Expose resource as tool for agent discoverability — Expose resource as tool for agent discoverability is the MCP- server integration pattern of registering a companion tool that returns a resourcelink or resource content type…
• Expression-def triples DSL — A boolean-logic DSL built from a single primitive — [left, op, right] triples — composed via and / or / not combinators. The universal shape:
• External coordinator for leadership lock — Instead of building the leadership-lock primitive inside your consensus protocol (fused with the revoke/establish round as in classical Raft/Paxos),…
• External credential store with principal rewrite — You're building a managed multi-tenant product on top of a system whose authorization is static by design — typically a configuration file loaded at pod startup,…
• External feature-branch repo for monorepo patches — When an organization's primary monorepo lacks the branching support needed to track long-lived patches against an upstream OSS project,…
• External metadata for conflict resolution — Replicate per-transaction metadata (transaction ID + timestamp + leader identity) alongside the transaction itself so that a later coordinator…
• External secrets-manager interpolation — At pipeline invocation time, the runtime looks up named secrets from an external key-management backend (AWS Secrets Manager, Azure Key Vault, GCP Secret Manager, Redis,…
• External table over Iceberg metadata pointer — External table over Iceberg metadata pointer is the query- engine-side pattern where a query engine (BigQuery, Athena, Snowflake external stage, Trino with HadoopCatalog,…
• eXtreme Modelling — eXtreme Modelling (XM) is the methodology proposed by Methni, Madeira, Chafia, and Koutny in the 2011 paper Concurrent Development of Model and Implementation for using…
• Fail-pass flip gate — Verify automated patches by requiring a clean fail→pass transition on a targeted test before the patch can proceed — preventing AI-generated fixes that break unrelated…
• Failsafe integration test separation — Split Maven's test run into two phases with two different plugins:
• Fallback rule for experience / context conflict — When selection metadata is used to match a request to exactly one Experience (or, more generally, to pick a single presentation context), ambiguity is unavoidable.…
• Fallback to general-purpose compressor — Format-aware compression relies on exploitable structure. For pure text (enwik, dickens, free-form prose) and unknown / unparseable formats,…
• Familiar UI borrowed from adjacent flow — A product team building a new UX flow needs the user to complete an unfamiliar task — here, share a gate code with a driver they haven't met.…
• Fan-out StackSet deployment — A single CI/CD pipeline in a central administrator account triggers one StackSet update operation that fans out the change to hundreds or thousands of target accounts in parallel.…
• Fast-lane / slow-lane consumer split — Split a single Kafka consumer group into two parallel consumer groups reading from the same topic: a fast lane that skips messages identified as slow-to-process,…
• Fast rollback — Ability to revert a change to a known-good state quickly — ideally within seconds — without re-running the full CI/CD pipeline.…
• Feature allowlist over blocklist — When a producer is trimming a payload down to what a consumer actually uses, it can express the decision two ways:
• Feature-flagged dual implementation — When a module (native module, component, integration) can't be made compatible with both the old and new runtime architectures from a single implementation…
• Feature-flagged job enqueue rejection — A deploy-less kill-switch for async-job classes: install a client middleware on the async-job framework that, on every enqueue,…
• Feature-gate pre-migration network rewrite — When migrating workloads would break users who have hardcoded literal addresses into their configuration, ship a compatibility feature in-guest first that transparently maps…
• Feature parity audit — Cross-reference the features a model sees at training time against the features actually populated at serving time, at the specific serving artifact the model reads from,…
• Feature-Phone Frontend (Thin-edge Sophisticated-backend) — Feature-phone frontend is the architectural shape used by Sub-Saharan African payment platforms (mpesa, Moniepoint, Mukuru,…
• Feature provider lifecycle — You are building a server-driven-UI backend (or any request- scoped composition engine) that:
• Federated GraphQL subgraph per domain — You have:
• Feedback-directed optimization fleet pipeline — A hyperscale operator runs large C++ (or other compiled-language) services across thousands or millions of hosts. Static compiler heuristics leave measurable capacity efficiency…
• Fewer, larger shards for latency-sensitive workloads — In a coordinator-fan-out search system (OpenSearch / Elasticsearch / any scatter-gather index) tuned for latency-sensitive document search with effective pre-filters,…
• Field-level sensitivity tagging — *Attach a sensitivity category to every database column in a central schema. Propagate the tags into the application server (queryable at runtime) and into the data warehouse…
• File-watcher atomic-swap consolidated map — An in-process server module needs to maintain a consolidated lookup structure — e.g., modelname → version → featureallowlist…
• Fine-tuned cross-encoder as filter — Fine-tuned cross-encoder as filter is the production pattern of using a fine-tuned encoder model (DeBERTa / RoBERTa / MiniLM) not as a top-K reranker but as a full-catalog quality…
• Fine-tuned model per product category — Maintain a collection of per-product-category fine-tunes of a text-to-image diffusion base model, so generated images preserve the defining features of specific product classes…
• Fire-and-forget rollup trigger — Writes to an event-log-based aggregation system need to schedule a background rollup for the affected key, but must not block on the rollup…
• Firehose Lambda transform as VPC-private endpoint bridge — Amazon Data Firehose is the managed "push streaming records to a destination" primitive on AWS. It supports a generic HTTP endpoint destination…
• First-class commit-stack workflow — Design the VCS so that working in a stack of small, individually reviewed commits is a comfortable default workflow — not a manual rebase dance layered on top of a non-stack-aware…
• First-error-only hydration error reporting — Pattern. When reporting React 18 hydration mismatches to an error tracker (Sentry, Datadog, Rollbar, custom), forward only the first onRecoverableError call per hydration pass.…
• Five-category service knowledge schema — Capture per-service infrastructure knowledge in a fixed, typed, five-axis schema so that downstream AI-agent retrieval, composition,…
• Five-phase managed-service migration playbook — Move a large self-managed production deployment (database, search cluster, message broker, etc.) onto the vendor's managed equivalent without downtime, with a named,…
• Five questions knowledge extraction — Extract the tribal knowledge the AI coding agent actually needs per module by forcing five targeted questions that drive the depth of the extraction…
• Flamegraph to upstream fix — End-to-end debugging discipline for the class of incidents where a CPU-burning, low-work symptom in your service is caused by a bug several layers deep in an open-source…
• Flat-buffer + ThreadLocal reuse — A hot path needs short-lived working buffers — input matrices, scratch space, output accumulators — on every request. The natural JVM idiom of allocating fresh double[M][D] arrays…
• Flattened tool architecture — Collapse every product's capabilities from separate sub-agent tool surfaces into a single, uniformly named, directly-callable tool surface for the orchestrator LLM.…
• Fleet-mode broadcast operations — Treat concurrent live events as a fleet under centralised dashboards, not as isolated launches in isolated rooms. Each operator oversees many events through a dashboard…
• Fleet-wide methodology via CLI — Rather than documenting an operational methodology as a wiki page, a runbook, or a vendor dashboard, the organisation packages the methodology as an executable command-line utility…
• Fleet-wide retroactive threat hunt — Fleet-wide retroactive threat hunt is the pattern of, on any critical vulnerability disclosure, searching historical fleet-wide logs backwards in time for signs…
• Flex on top of native UI framework — You want Flex layout semantics on mobile — so a single Flex specification (authored on a server, or in a cross- platform codebase) renders consistently on iOS + Android…
• Flip lookup direction — When a hot-path operation is expressed as "for each element in set A, check/remove it from collection B", and |A| ≫ |B| (or vice versa),…
• Flycast-Scoped Internal Inference Endpoint — Flycast-scoped internal inference endpoint is the Fly.io instantiation of the general pattern: expose an inference service only to internal, private-network callers,…
• Force-index escape hatch — When you have proven that the MySQL optimiser is picking the wrong index and no stats refresh or query rewrite fixes it, pin the index choice with USE INDEX (name) or FORCE INDEX…
• Forecast → Estimate → Plan (three-component capacity planner) — Decompose predictive-capacity-planning into three independent components: a Forecaster that predicts exogenous customer demand,…
• Foreign-catalog federation for operational-DB governance — Expose the operational database as a foreign catalog inside the analytical platform's unified catalog, rather than governing it independently with database-tier RBAC.…
• Foreign-key cascade vs dependent destroy-async — A layer-choice pattern for parent-child cascade deletion in Rails applications: push the cascade into the database layer via ON DELETE CASCADE foreign-key constraint,…
• Fork retirement via A/B test — Retire a long-divergent internal fork of an OSS library by running legacy + upstream side-by-side in the same binary via a dual-stack shim,…
• Formal Methods Before Shipping — New protocol — replication, failover, reconfiguration, a transaction-isolation layer, a consensus variant — is correct in principle but has a vast set of possible event…
• Format-aware malware check before OS handoff — A client-side defense pattern: an app performs format-conformance, risk-indicator, spoof-detection, and dangerous-type checks on untrusted media / attachments at the app layer,…
• Forward and reverse adjacency index — Forward and reverse adjacency index is a graph-storage pattern: every edge link is written to two separate KV partitions…
• Forward-selection experiment design — Region-split experiments (region-split-experiment) are the only shape that can observe the full long-term effect of an intervention in a multi-sided marketplace,…
• Foundational platform + domain libraries — Build a minimal, reusable foundational platform. Let each team ship domain-specific libraries on top of it. This is the organisational shape that makes an internal platform viable…
• Foundational principles with decentralized guidelines — Balance organizational consistency with domain-specific flexibility by establishing a small number of non-negotiable structural rules (principles) alongside advisory frameworks…
• Four-component agent production stack — The minimum architectural bar for running AI agents in enterprise production is four interlocking components, each addressing a governance failure mode that bare-sandbox agent…
• Four-phase data agent trajectory — A data agent processing a complex enterprise question proceeds in four named phases: (1) parallel multi-agent data discovery, (2) data investigation, (3) self-correction loop,…
• Fragment embedded in Renderer for migration — A platform migration between two frontend architectures — Mosaic (Fragment-based micro-frontends) to Interface Framework (Entity-and-Renderer-based) at Zalando — can take years.…
• Framework-exposed tracing API for renderer developers — Custom client-side operations (button clicks, filter applies, lazy-load AJAX calls, form submits) are the most interesting things to trace on the web…
• Framework-harness-runtime layering — Building production agents conflates three distinct concerns: developer experience (project structure, CLI, integrations), the agentic loop (tool calling, context, continuation),…
• Framework-inferred cache policy — Framework-inferred cache policy is the pattern of having the CDN / edge / cache layer learn per-route cache semantics from the application framework's build output rather than…
• Framework-managed executor pool — Give a block of code to a framework; the framework manages a pool of executor nodes against a declared min/max/concurrency policy, and runs your block on one of them.…
• Frozen encoder + linear probe — Train a large self-supervised encoder once, freeze it, and deploy it across many downstream tasks with each task getting its own small linear head fitted on top of the frozen…
• FSM RPC for config metadata transfer — When a cross-host operation (migration, replication, failover) depends on per-resource configuration that may differ between hosts — because of version skew, default drift,…
• Full-stack IO instrumentation — Instrument every IO at multiple points in every subsystem of the storage stack — plus run continuous canary workloads — so that (a) the true source of latency/variance can be…
• Fused decompress + tensor-core matmul — When weight compression buys memory-bandwidth headroom on a bandwidth-bound inference workload, do not decompress the weights back to HBM before matmul.…
• Fusion Strategy Selection by Deployment Reality — Pick a multimodal fusion strategy (early-fusion, intermediate-fusion, late-fusion, attention-based-fusion) based on three deployment-reality axes, not on benchmark strength:
• Fuzz AST-vs-VM oracle — You've rewritten an interpreter's execution path — AST interpreter → bytecode VM, or VM → JIT — to win performance. The new path is faster but you now have two implementations…
• Game-engine stack for web canvas — A three-language client+server split for browser applications whose canvas and rendering are performance-critical:
• Gapfill requeue for coverage — Have agents self-report coverage gaps in their own work output, then automatically re-queue those gaps as new narrow tasks for the next pass.…
• Gateway autoscaling — Horizontally scale the gateway (routing / admission tier) itself, not just the backend it fronts. The number of gateway instances grows under load and shrinks when idle.…
• Gateway throttling by dimension — Admission control at a query/request gateway with per-dimension knobs: per-user, per-source, per-IP, and global. Reject requests (or queue with hard bounds) when the gateway…
• Generated hash column for equality lookup — Pattern: when a column is too large or too wide to index directly for strict-equality lookups, add a MySQL generated column that holds a compact hash of the value,…
• Generative retrieval over scoring retrieval — When a recsys retrieval stage hits the vocabulary bottleneck of scoring atomic item IDs at non-stationary catalog scale, replace the scoring model with an autoregressive generative…
• Generic quota management platform — Pattern: build one quota-management platform that serves all quota kinds in the organisation — capacity, rate-limit, and application-specific…
• Geospatial gossip sharding — A stateful dispatch service — Uber-style rider-driver matching, food-delivery dispatch, on-demand logistics — needs to:
• Git-based config workflow — Treat runtime configuration — feature flags, limits, tunables, ACLs — as source code living in a Git repository. Changes flow through pull requests with mandatory reviewers,…
• Git protocol as API — Git protocol as API is the pattern of exposing a service over the Git smart-HTTP protocol as the primary access surface — not just as a secondary sync path…
• Global configuration push — Antipattern framing. A fleet-wide configuration-delivery channel that propagates every edit to every server in seconds, with no canary, no staged rollout, no per-POP health gating.
• Global feature killswitch — An orthogonal fast-off lever that can disable a feature / module / subsystem globally in seconds — independent of the config-delivery pipeline that feeds that feature.…
• Global patch constructors for runtime optimization — To ship a performance-improving replacement for a standard-library or built-in class to unmodified user code, provide a single-call initialisation function that replaces the global…
• Go-native ML serving — Build the request-handling shell of an ML serving stack as a Go-native service that fronts a GPU inference engine (typically Triton + TensorRT-LLM),…
• Golden path with escapes — Golden path with escapes is the platform-team design where the default service-creation / service-config flow is heavily opinionated — consistent defaults,…
• Gossip fingerprint propagation — Gossip fingerprint propagation is the pattern of sharing detection state (threat fingerprints, match rules, ban lists, observed patterns) across peers of a distributed fleet via…
• Governance-tier ranking fusion — Governance-tier ranking fusion is the implementation shape for governance-aware ranking: when ranking retrieval candidates (tables, queries, dashboards),…
• Governed Delta Tables Per Modality — Every input modality (genomics, imaging features, clinical notes, wearables, …) lands in its own set of governed Delta tables under one Unity Catalog governance surface,…
• Governed metric as headless-BI substrate — Define each business metric once as a first-class object in the data platform's catalog (governance plane), with its measure logic, dimensional join graph,…
• GPU-native retrieval primitive redesign — Use this pattern when:
• GPU serving stack — TensorRT-LLM + Triton — For ML workloads with autoregressive decoding + beam search + production latency budgets (generative retrieval, LLM inference, sequence-to-sequence), build the serving stack as:
• Graceful leader demotion for planned transitions — When you need to change leaders for planned reasons — software rollout on the current primary, scheduled node maintenance,…
• Graceful propagation before demotion — On a planned leadership change in a lock-based consensus system, have the current leader first ensure that its outstanding requests have reached the new leader's required follower…
• Graceful upgrade via monoversion decoder — Compression configs evolve — new Plans beat old ones as data drifts, new transforms get added to the library, schemas shift.…
• Gradual API-surface rollout — When a rewrite affects behaviour that is consumed through multiple API surfaces (GraphQL, REST, first-party UI, third-party integrations, command-line / SDK clients),…
• Gradual per-endpoint cutover — Gradual per-endpoint cutover is the rollout discipline of migrating traffic to a new implementation one endpoint (operationid) at a time via a proxy rule change,…
• Gradual rollout layered by stack depth — A single operational primitive must cover both ends of a cost- asymmetric spectrum:
• Gradual transpiler-driven language migration — Migrate an entire codebase from source language A to target language B without blocking feature development or taking a one-way-door rewrite risk,…
• Grain-aligned stream split — The grain-aligned stream split is the architectural pattern of replacing a monolithic finest-grain data pipeline with N independent streams, one per natural consumer-grain,…
• Graph-walk SQL generation — Give analysts a concept-level query interface — "I want actors joined with the movies they appeared in and the territories those movies aired in"…
• Graphics API interface layer — A graphics API interface layer is an internal abstraction that sits between the application's rendering code and any specific graphics backend (WebGL, WebGPU, Metal, Vulkan,…
• GraphQL as unified API platform — You have many backend services whose data is consumed by many client applications (web, mobile, internal tools, partner APIs), and you want:
• Grassroots SRE rollout — Grassroots SRE rollout is the bottom-up pattern for introducing Site Reliability Engineering in an organisation: a small coalition of SRE-interested engineers pitches…
• Groundtruth upper-bound benchmark — When a multi-stage pipeline's end-to-end quality is mediocre, a natural question is which stage is the bottleneck — improve stage A or improve stage B? The groundtruth upper-bound…
• Grouped component batched migration — For LLM-driven migrations across many source-components, partition the components into small, semantically-coherent groups and run the migration once per group per file,…
• Grouped linear quantization — Share a scale (and optionally a zero-point) across a contiguous group of tensor elements — typically 32, 64, or 128 — rather than per-tensor (one scale for all elements,…
• gRPC-decoupled driver from client — The gRPC-decoupled driver-client pattern splits a monolithic distributed-compute driver / coordinator from the user's application process,…
• gRPC-over-Unix-socket language-agnostic plugin — Extend a host application with plugins written in any language by running each plugin as a separate OS subprocess, communicating with the host over a gRPC service exposed on a Unix…
• HA set anti-affinity across shared infra — When running a high-availability (HA) set (two or more replicas of a service, or a tightly-coupled HA pair of different services),…
• Hackathon to platform — Start an internal platform from a short, time-boxed hackathon prototype that validates the core value proposition with unpolished code…
• Handler-hook sidecar telemetry — Problem. You want per-query telemetry from a production database — the "what actually happened during this single execution" granularity — at 100% coverage,…
• Hands-free adaptive bot mitigation — Design the bot-management product so that the full loop — detect, correlate, reclassify, mitigate — runs inside the ML backend without customer-authored rule changes,…
• Harden ingestion of internal config — Apply the same input-validation discipline to internally- generated configuration files that you apply to user-submitted input.…
• Hardware-native quantization — Push quantization metadata (scales, zero-points, block-scale exponents) into the matrix-unit instruction itself rather than dequantizing quantized operands in software before each…
• Hardware-software codesign for ML serving — Hardware-software codesign for ML serving is the design discipline of choosing or tuning ML-serving algorithms (decoding strategies, batching policies, attention implementations,…
• Head cache plus tail fine-tuned model — Serve an ML inference workload whose traffic is power-law-distributed over inputs (search queries, URLs, product SKUs) by splitting the traffic into a head and a tail:
• Header-routed mock vs real dependency — Header-routed mock vs real dependency is the pattern of using an L7 routing layer (ingress proxy, service mesh, or sidecar) to inspect an inbound request's headers and dispatch…
• Headless CMS for editorial content — Front editorial and semi-static surfaces with a headless CMS — delegate authoring, content model, validation, localisation, and collaboration to the CMS,…
• Heartbeat absence as alert trigger — Emit a continuous heartbeat through the entire alerting pipeline to an external channel, and page when the rate of heartbeats drops to zero…
• Heartbeat-based replication lag measurement — Replication lag is the time between a write landing on the primary and that write becoming visible on a replica. It is a gap, not an observable on any single server.…
• Heartbeat-derived IP ownership map — Maintain a per-IP list of non-overlapping (workloadid, tstart, tend) time ranges populated entirely from data-plane heartbeats.…
• Hedged observability stack — Split the observability stack across multiple providers such that any single provider's outage produces degraded but functional observability, not a blackout.…
• Heterogeneous cluster provisioning — Heterogeneous cluster provisioning is the EC2-capacity pattern of discovering a set of instance types that can satisfy a workload's resource shape,…
• Heuristic cron emits agent work items — Run a periodic batch job that scans the codebase / system state, applies a heuristic encoding years of human pattern recognition,…
• Hex-comparison flag for iPXE config check — When a configuration substrate reads variables in an encoding the consumer can't compare directly (e.g. iPXE reads UEFI variables as hex, but the expected value is a string),…
• Hibernate unused topics on tiered storage — For workloads a cluster is no longer actively serving but whose history the operator still wants preserved, unmount the topic…
• Hidden agent directive in HTML — Embed a short, human-invisible, LLM-visible imperative in every HTML page that steers an LLM that has fetched the HTML version toward a better representation (usually the page's…
• Hierarchical Multi-Task Geo Prediction — Hierarchical multi-task geo prediction is a pattern for injecting a hierarchical geographic taxonomy (region ⊃ city ⊃ neighborhood …) into a recommender's learned embedding…
• High-cardinality partition key — A streaming workload requires per-key ordering (e.g. CDC per row, per-user event ordering, per-device telemetry). That forces use of the keyed partitioner…
• High dropout on augmented feature layer — When a model architecture has a layer that consumes a feature derived from synthetic / augmented data (especially when the augmentation has a structural label-leakage risk, e.g.,…
• Historical replay with ML outcome predictor — In a feedback-loop system (ad auctions, pricing, recommendation ranking, traffic routing), a small change to the decision function changes the downstream outcome,…
• Historical-usage auto-rightsizing — Pattern: close the feedback loop between a running quota-enforcing system and its own provisioning by (a) capturing enforcement + usage statistics as data-plane telemetry,…
• Historical usage for pickup-spot suggestion — A ride-sharing / on-demand app needs to suggest pickup spots to a rider — meet-spots that are (a) convenient to reach, (b) safe for the driver to stop at,…
• Hook colocation for zero overhead — When a new capability requires the same hook points and similar measurements to an existing extension that already installs those hooks,…
• Horizontally Scale Stateful Tier via Pairs — When you already have a stateful active/standby pair that works well but is hitting a single-pair storage / capacity ceiling,…
• Host-agent metrics API — Run a per-host agent whose job is to locally collect system + database metrics and expose them over a simple HTTP (or similar) API.…
• Host-shell prop API for remotes — In a micro-frontend deployment, the remote bundles need to:
• Hosted MCP ecosystem — Hosted MCP ecosystem is the organisation-scale shape for deploying MCP at an enterprise: many small domain-specific MCP servers, all cloud-hosted (not local-on-laptop),…
• Hot cluster for iterative ML — Keep compute clusters warm and provisioned between ML workflow runs rather than cold-starting a new cluster for each execution.…
• Hot reload over restart replicas — When a cluster's shared state changes (schema update, new index, live-settings tweak), propagate the change to all replicas by having them hot-reload the new state from the state…
• Hot-routing autoscale — Hot-routing autoscale is the pattern of dynamically routing new incoming work units (streams, connections, requests) away from overloaded backend nodes using heuristic-based load…
• Hot-standby cluster for DR — Run a continuously-up secondary cluster in a different region / failure domain, receiving async replication from the primary.…
• Hot-swap retrofit (fleet upgrade in flight) — Upgrade the live production fleet in place, one server at a time, without customer-visible disruption — even when the upgrade involves physical hardware (not just config…
• HTML subset to native UI mapping — You want one UI codebase that renders on web + iOS + Android. Two directions are available:
• HTTP API alongside binary protocol — Ship an HTTP-based version of your database / service protocol next to the native binary protocol, not replacing it. The HTTP API is a first-class citizen — authenticated,…
• HTTP/3 over HTTP/2 for unreliable networks — When given the choice between HTTP/2 (TCP) and HTTP/3 (QUIC/ UDP) for a transport-layer protocol, prefer HTTP/3 when the client-server path is both (a) unreliable — packet loss,…
• Hub / Worker / Dashboard agent service — Productise an agent loop — especially a long-running, multi- agent, multi-step one — as a three-component service:
• Hugging Face checkpoint compat for internal optimized model — Capture the framework-level performance benefits of owning your own optimised model implementation (custom attention, chunked cross-entropy, uniform LoRA extensibility,…
• Human-aligned criteria refinement loop — Bootstrap an LLM-as-judge system to human-grade reliability — and keep it there across updates — by running a continuous calibrate-compare-refine loop against a curated human-rated…
• Human-calibrated LLM labeling — Human-calibrated LLM labeling is the pattern of training a high-volume ML model (a ranker, classifier, preference model, …) on labels generated by an LLM judge that is itself…
• Human-in-the-loop quality sampling — Continuously estimate production quality of an ML / LLM pipeline by periodically drawing a random sample of its outputs and sending them for human review (or LLM-as-judge…
• Hybrid batch + streaming + direct-write ingestion — Hybrid batch + streaming + direct-write ingestion is the architectural pattern of splitting feature (or more generally data) ingestion into three complementary lanes…
• Hybrid classical ER + GenAI — Build an Entity Resolution (ER) pipeline as a two-track composition:
• Hybrid cloud testing — For cloud services that cannot be fully emulated locally, keep cloud feedback lightweight: stand up a minimal dev stack via IaC, exercise it through the AWS SDK (or equivalent),…
• Hybrid CV + LLM Pipeline — A hybrid computer-vision + LLM pipeline decomposes a visual understanding task into two (or more) phases: an early classical-CV / purpose-trained-model phase for geometric /…
• Hybrid lexical+vector interleaving (min-max normalized, exact-match boosted) — Hybrid lexical+vector interleaving is a specific score-fusion tactic for combining results from two independent search indexes (one lexical / BM25-or-fuzzy-match,…
• Hybrid multi-tenant architecture — Provide tenant isolation at the compute cluster level inside shared AWS accounts — each tenant gets a dedicated ECS cluster loading only its tenant's in-memory state,…
• Hybrid offline/online user tower inference — Architect the user (or query) tower of a two-tower retrieval / ranking model so its forward pass splits into an offline-batched portion and an online portion:
• Hybrid single-controller + SPMD RL execution — Support both SFT and on-policy RL (GRPO, PPO) workflows in a single LLM post-training framework without forcing SFT users to pay for RL's orchestration overhead…
• Hybrid time-series store — Prometheus + sharded MySQL — Problem. Telemetry data has two very different shapes: a low-cardinality database-level axis (a few metrics, one per database,…
• Hybrid tree-graph ANN index — Pure graph ANN indices (e.g. HNSW) have state-of-the-art recall / latency when the corpus fits in RAM — their random-access edge traversal is memory-bandwidth-limited.…
• Hyperlink allowlist validation on LLM output — When an LLM generates a response that includes hyperlinks, validate every URL in the output against an allowlist extracted from the retrieved-context articles.…
• IaC rebuild from separate version control — When rebuilding infrastructure during cyber-event recovery, *rebuild from IaC templates stored in a separate, version-controlled repository…
• IAM-policy-gated cold-tier access — Data sitting in S3 Intelligent Tiering's deeper tiers (Infrequent Access / Archive Instant Access) is still readable — IT objects don't require a Glacier-style restore…
• IAM role attribution from S3 access logs — When attributing data access in an AWS-native data lake, naive substrates collapse:
• Idempotency-Key header — Support an Idempotency-Key (or equivalent) header on non-idempotent write endpoints. The caller supplies a unique key per logical operation;…
• Idempotent Athena insertion via self-LEFT-JOIN — You run an INSERT INTO ... SELECT in Athena as part of a retry-safe batch job (for example, raw-to-Parquet log compaction).…
• Identity-to-key binding — When a token attests both a user's identity and a public key, the verifier MUST check that the public key in the token matches the public key actually in use for the session.…
• Idle-state throttler hibernation — When a throttler and its associated metric-generation mechanisms (notably replication heartbeats) go unused for a period, slow or stop their activity to cut self-cost.…
• IDP extended to AI agent tools — The IDP-extended-to-AI-agent-tools pattern is the framing / architectural pattern of taking the Internal Developer Portal (IDP) shape that catalogs human-operated services…
• IdP-group-mapped authorization — Eliminate per-system user lifecycle management (create-user, edit- ACL, remove-user) by making the Identity Provider the single source of truth for group membership and teaching…
• Ignore self-generated shutdown signal — An orchestrator generates shutdown signals (unavailability events) that propagate to all managed services — including the orchestrator's own control-plane services.…
• Image-generation pushdown to storage — Move periodic full page image generation from the compute node's WAL stream into the distributed storage layer's background processing.…
• Implicit prompt cache as platform default — Ship LLM-serving prompt caching as a default-on, zero-configuration substrate property of the serving platform — not as an opt-in request-API feature.…
• In-code annotation as LLM guidance — When using an LLM for code transformation, write the guidance you would otherwise put in the system prompt as in-code comments at the call sites where it applies.…
• In-isolate rule evaluation — In-isolate rule evaluation is the pattern of running configuration / feature-flag / routing-rule evaluation inside the same V8 isolate that is already serving the current request,…
• In-loop decoder for real-time quality metrics — When computing reference visual-quality metrics (PSNR, SSIM, VMAF — see visual-quality-metric) for livestream transcoding where a post-hoc comparison is not possible,…
• In-memory partition actor (actor-per-partition with mailbox) — You have a write-heavy workload where many requests target the same partition concurrently, and you want:
• In-memory vectorstore loaded at container start — For a RAG system serving over a small vector corpus (typically ≤ ~10 MB post-quantization), the vectorstore is loaded entirely into the chatbot container's memory at startup…
• In-place partitioned-to-clustered conversion — Migrating a partitioned table to Liquid Clustering historically required a full table rewrite plus a consumer-cutover dance:
• In-VPC query engine on streaming substrate — Deploy the analytical query engine inside the customer's VPC, colocated with the streaming broker and Iceberg storage, so SQL queries access data in-place without egressing the VPC…
• In-workspace app as decision support — Pattern: deploy a decision-support web application inside the data-platform workspace boundary rather than as a separate web tier that synchronises to the warehouse.…
• Inbound-classify-persist-reply pipeline — An email agent has to do the same five things on every inbound message:
• Inbound / outbound topic pairing — Split Kafka topics along the direction of data flow relative to the processing system, not just along subject matter:
• Incident response calibrated to blast radius — Scale incident-response intensity to the actual scope of harm, not to the conspicuousness of the incident. A loud, public,…
• Incremental AI re-review — When an AI code-review agent runs again on a merge request that already has prior findings, don't treat the new run as a blank slate.…
• Incremental blast-radius validation — Validating resilience to a catastrophic failure (e.g., region-wide power loss) carries significant risk — you need to take risk to address risk.…
• Incremental clustering on write — Periodic full-table re-clustering produces unbounded write amplification at scale. The canonical instance is Z-Ordering: each OPTIMIZE ZORDER BY rewrites entire files (or…
• Incremental operator-by-operator migration — When the source state of a migration is a catalogue of operator types (Airflow operators, code patterns, library calls — N distinct shapes that all need replacing),…
• Incremental S3 backup of immutable files — Back up every state-durability checkpoint (commit, flush, segment-finalize) to S3 by uploading only the files that aren't already in the S3 prefix…
• Independent scaling tiers — A single-tier system has one scaling lever — add more servers. Every server handles every concern: client sessions, cache memory, change-stream processing, schema management.…
• Independent security assessment for hardware peripheral — *Before productising a new class of hardware peripheral on a multi-tenant platform, commission one or more independent external security assessments — from specialist firms,…
• Index from tail-latency pattern — Problem. A query pattern shows a specific time-series shape — rising p95 within each batch, sawtooth between batches, monotonic degradation over a known window.…
• Index JSON key via generated column — MySQL's JSON data type lets you store arbitrary documents in a single column, but the column itself cannot be indexed directly…
• Index-usage per-table diagnostic — Problem. The digest view tells you which queries are slow. It doesn't tell you which tables are being read inefficiently at the storage layer…
• Industry API partner as media engine — Integrate a third-party industry-standard media-processing engine as the core engine inside your pipeline — consumed via the partner's API…
• Inference payload table for audit — Capture the full request and response payload of every model call flowing through an AI gateway as rows in a governed lakehouse-resident table…
• Infinite retry by failure class — Apply a different retry policy per failure class instead of one- size-fits-all retry-with-backoff — so that genuinely transient failures retry forever,…
• Ingress-layer authorization offload — Application services repeatedly re-implement authorization in application code: JWT parsing, scope / role / permission checks, audit logging, metric emission.…
• Init as credential broker — Make the init binary of a VM / micro-VM / container detect credential-requesting environment variables, fetch the required identity material from the platform's metadata service,…
• Initiator / responder role inversion — Cut the connect-setup latency of a symmetric point-to-point handshake by installing state in the opposite role from natural and letting the server side originate the next handshake…
• Injected request-object converter — Injected request-object converter is the pattern where, instead of building a fat cross-framework abstraction layer that tries to unify request shapes across N frameworks,…
• Inner-sourced module extension — Let teams outside the platform's owning team contribute new content types to a CMS-backed delivery platform as self-contained modules…
• Inside-out VM orchestration — Large VM platforms accrete host-side orchestration complexity: a per-host scheduler, a cluster-wide database, a network controller, a storage controller, a log collector,…
• Instance-shape right-sizing for CI workers — *Pick the EC2 (or equivalent) instance type by workload shape — I/O-dominated steps get I/O-optimized instances with multi-SSD and high NVMe throughput;…
• Instant-deploy opt-in — A system has two execution paths for the same operation that differ materially in trade-offs:
• Instant schema revert via inverse replication — A destructive online schema change (e.g. ALTER TABLE users DROP COLUMN title) has completed, cut over, and is running in production.…
• Instruction library prompt composition — Instruction-library prompt composition is the constrained / risk-calibrated alternative to full DSPy prompt rewrites: instead of letting the optimiser restructure the whole prompt…
• Intent-domain-decomposer agentic router — A three-classifier agentic layer sits in front of a fleet of specialist sub-agents (typically: multiple per-domain Genie instances + a RAG agent over an unstructured-document…
• Intent-preserving query translation — When migrating queries (observability dashboards, alert expressions, SQL, etc.) from one system to another, translate what the user was trying to measure to the target system's…
• Intercepting proxy for transparent cache — Deploy a cache as an external service that intercepts requests at an existing routing / load-balancing layer (a Router, Broker, L7 LB, or API gateway).…
• Interleaved ranking evaluation — Evaluate a candidate ranking change faster and more sensitively than A/B testing on CVR uplift can. Use as a screening layer to winnow candidate changes before A/B validation,…
• Intermediate waypoint for context surfacing — A driver (or delivery courier, or any mobile worker) needs a specific piece of context delivered at a specific moment in their journey — gate code as they approach the gate,…
• Internal → external event pipeline — When a control-plane service needs to notify both internal subscribers (for its own state-machine progression) and external subscribers (downstream services in a different domain)…
• Internal vector DB as a service — Internal vector DB as a service is the platform-engineering pattern of standing up an internal, config-driven vector-index platform so that every team building an LLM/RAG feature…
• Interrupt and restart — Interrupt-and-restart is a preemption policy for scheduling: an active job can be interrupted at any point; the partial work done on the interrupted job is lost,…
• Interval-aware query cache — When serving rolling-window time-series queries at scale, don't cache query responses as opaque blobs keyed on (query, interval) — they miss every time the interval shifts.…
• Intra-node parallelism via input/output scaling — For data-pipeline runtimes that expose a broker-style input/output multiplexing primitive — Redpanda Connect, Benthos, NiFi,…
• Intrinsic evaluation of discrete codes — Evaluate discrete-code substrates (e.g. Semantic IDs, BPE token spaces, audio codebooks, learned vector quantizations) directly on the codes themselves…
• Invariant-driven programming — Invariant-driven programming is the discipline of, for every non-trivial piece of code, explicitly naming the invariants the code relies on, writing them down (in comments, types,…
• Invest widely then double down on impact — A reliability program (or any program with a trailing metric) faces two unknowns simultaneously at kickoff:
• Invisible rollout via default-on validation — A platform team is adding fleet-wide correctness enforcement — a new validating admission webhook, a schema linter, a policy check…
• iptables packet counter for rate metric — Use iptables's built-in per-rule packet and byte counters as a lightweight, kernel-side rate-metric primitive. Add a rule matching traffic of interest,…
• IRR-prefix-filtering export policy — IRR-prefix-filtering export policy is the BGP export configuration pattern in which a router's outbound policy toward a given neighbor filters routes against only an IRR-derived…
• Isolate fastest-growing table to own keyspace — When one table in a monolithic database grows much faster than the others, move it to its own dedicated cluster (keyspace) and downsize the cluster holding the remaining tables.…
• Isolated egress proxy for user URLs — When a service must make HTTP requests to URLs supplied by users — webhook senders, URL preview fetchers, image proxies, URL shorteners,…
• Isolated PgBouncer per workload — Isolated PgBouncer per workload runs multiple PgBouncer instances in parallel, each dedicated to a distinct workload class (web app, background workers, analytics, etc.),…
• Isolated reproducer for race condition — After diagnosing a race condition's mechanism from production evidence (logs, coredumps, disassembly), build a minimal, self-contained,…
• Isolated token service — Carve the token-authority database + signing + verification out of the primary API cluster and onto isolated hardware with a deliberately narrow code surface.…
• Issuer / attester / client / origin roles — The RFC 9576 four-role decomposition is the architectural pattern underlying Privacy Pass and its successors ARC / ACT. It splits the "anonymous + accountable" web-protection stack…
• Iterative linger-tuning production case — A Kafka-API streaming cluster is CPU-saturated under heavy produce load. Operators suspect producer-side linger.ms is too low…
• Jinja-templated SQL generation — Use Jinja templates to parameterize SQL metric definitions so that a single core definition generates correct queries across multiple time granularities, dimension combinations,…
• Jira status transition triggers agent workflow — Use a Jira workflow status transition as the trigger for an AI agent run, with the transition's automation passing a custom system prompt to the agent.…
• JIT provisioning on first packet — Install per-peer state in a kernel / data-plane primitive lazily, on the arrival of the first packet from that peer — not proactively, not pushed.…
• Jittered flush for write smoothing — Pattern. When many hosts run identical background flush loops on a fixed interval, a randomised per-host delay on the first flush breaks cohort synchronisation and converts a spiky…
• Jittered job scheduling — When enqueuing many jobs that share a downstream (external API, rate-limited service, shared database), attach a random delay per job drawn from [0,…
• Job of jobs orchestration — The "Job of Jobs" pattern is the orchestration shape used by the Octopus Energy MHHS rebuild to manage the three grain-aligned streams of its margin data pipeline: a parent job…
• JSONL parameters + Base64 payload — Serialise a parameterised binary artefact (a Bloom filter, a trained model, a compact index, a compressed cache) as a two-line JSONL file:
• JSONL streaming child process — Embed an AI coding agent (or any long-running LLM tool) as a child process driven by three choices:
• jsonschema-validated config at commit and CI — A YAML or JSON configuration file with a typoed field name or an unknown key often causes silent semantic bugs: the consuming application reads metadata as missing when the file…
• Judge query-context tooling — Judge query-context tooling is the pattern of giving an LLM judge active retrieval tools (search queries, lookups, knowledge-base access) and letting it research the evaluation…
• JWT tenant-claim extraction — Never accept tenantId from the request. Always extract it from the validated identity token's immutable claim. The request body, URL path, headers,…
• Kafka broadcast for shared state — When every node in a service cluster must converge on a shared, eventually-consistent view of state — and consensus or bespoke gossip would be overkill…
• Kafka entropy repair for multi-namespace writes — Kafka entropy repair for multi-namespace writes is a consistency pattern for systems that must write atomically to multiple stores or namespaces but lack a distributed-transaction…
• Keep infrastructure-specific patches internal — The explicit complement to upstream the fix: when a patch exists to integrate a piece of infrastructure external contributors cannot reasonably test or validate (typically…
• Keep original partition as fallback during split — The discipline of never deleting the source partition after a successful split — leaving the original wide partition as a passive fallback that the read path can divert to when:
• Knowledge graph for MDM modeling — In an MDM project, do not author the logical data model of the golden record directly. Instead, author a knowledge graph whose nodes are:
• Known-issue exclusion in batch selection — The known-issue exclusion in batch selection pattern is a batch-planning discipline for capacity-constrained migrations: when an underlying issue affects multiple jobs (or…
• KPI closed-loop load ramp-up — KPI closed-loop load ramp-up is the pattern of driving a load test's ramp schedule by a closed-loop feedback controller that targets a business KPI (orders-per-minute,…
• Kubernetes-API-driven custom load balancer — Replace the default kube-proxy / round-robin / Service-ClusterIP load-balancing path with a lightweight in-house control plane that watches the Kubernetes API directly for Services…
• Kustomize wraps Helm chart — A single Kustomize kustomization.yaml that composes two responsibilities:
• KV-aware routing — KV-aware routing is the load-balancing pattern for LLM serving in which the router's target-selection decision is driven by which replica holds the warm KV cache for the request's…
• Label-triggered backport — Use a GitHub label applied to a PR as the signal that a bot should cherry-pick that PR onto one or more older release branches.…
• Lambda architecture for fresh and complete sequences — Run two cooperating execution paths over the same logical signal definition:
• Lambda authorizer — A Lambda authorizer is a Lambda function that API Gateway invokes before dispatching a request to the backend. The authorizer:
• Cache in Lambda execution context — Your AWS Lambda function is called frequently enough that warm-start reuse is the common case, and its hot path repeatedly fetches the same (or predictably-cacheable) data…
• Language consolidation for fleet standardization — A large engineering org (1000s of engineers, thousands of microservices) that embraced language heterogeneity early — Python + JavaScript + Java + Go + Ruby + PHP all in production…
• Language-neutral schema abstraction — Pattern: store detailed, language-specific facts underneath, and define language-neutral views over them in the schema language itself,…
• Language rewrite for concurrency — Language rewrite for concurrency is the architectural pattern of rewriting a performance-critical layer in a language whose concurrency model matches the workload,…
• Launch-Minimal Runtime — Launch-minimal runtime is the pattern of shipping a platform or runtime-hosting service with one language / one packaging format / one invocation model first,…
• Layered coding for graphics overlay — Layered coding for graphics overlay is the live-streaming architectural pattern where a codec's multi-layer (scalable video coding) primitive is used to separate main video content…
• Layered gateway architecture — An API gateway serving mobile/web clients across many lines of business drifts into a catch-all layer over time:
• Layered JWT + mesh auth — Layered JWT + mesh auth is the two-layer authorization shape for agent traffic inside an enterprise mesh: an end-user JWT authenticates + coarsely authorizes the human on whose…
• Layered PgBouncer deployment — Layered PgBouncer deployment runs two PgBouncer instances in series — one on the application/client side, one near Postgres…
• Layered testing strategy — Compose a tiered test suite where each layer tests a different scope at a different cost-latency trade-off: cheap + fast at the domain-logic base,…
• Lazy aggregate from monotonic local state — When you need a clusterwide value that depends on the state of every shard — typically a watermark like "safe to delete up to here" or "all shards have processed events through…
• Lazy history on demand — Scale a VCS to monorepo sizes by refusing to download everything up front — pair a cheap, sublinear-size graph-shape index with on-demand fetching of commits, trees, and files.
• Lazy pull pipeline — Compose streaming pipeline stages so that no stage executes until the consumer pulls — every transform, every source read,…
• Leader-based partition replication — Replicate an append-only log across N replicas with exactly one leader at a time per replica set; writes go only to the leader;…
• Learned distribution over point prediction — When downstream decisions are cost-asymmetric in the prediction error, emit a calibrated distribution from the predictor rather than a point estimate.…
• Lex-sorted concatenated edge ID — Lex-sorted concatenated edge ID is a deterministic edge- identifier construction: given a pair of endpoint node IDs, sort them lexicographically, then concatenate.…
• Library fork for DAG id rewrite — When an orchestrator library has no hook point for environment awareness but you need it, fork the library's workflow-definition class (at Zalando: airflow.models.DAG) and rewrite…
• License-independent sandboxed plugins — Structurally isolate plugins so they share no code (and no execution context) with the host platform. Plugins run in their own capability- based sandbox against a stable host API…
• Lifetime-aware rescheduling — After initial placement, continue tracking the workload's lifetime distribution and move the workload when the current placement becomes inefficient relative to the updated…
• LIFO queuing for tail latency — A latency-sensitive serving path queues requests under transient backend slowdowns. With a FIFO queue, every new request arriving during the slowdown waits behind the head-of-queue…
• Lightweight aggregator in front of broker — When the application's required batching semantics are not expressible in a general-purpose message broker's native batching knobs, place a small,…
• Link in non-rendered JSON payload for discovery — Because Googlebot's link discovery works via regex over the initial HTML response body (URL-shaped strings), you can seed URL discovery by embedding link targets in a non-rendered…
• Link Rel Alternate Markdown Discovery — Embed a standard HTML tag in every page's advertising the markdown version of the site's content,…
• Live load test in production — Live load test in production is the ongoing discipline of running simulated user load against the real production system, with explicit traffic-source tagging, abort heuristics,…
• Live visualization of sampled metrics — Live visualization of sampled metrics is the pattern of rendering a streaming time-series directly inside the sampling process using an interactive plot library,…
• Live WAL protocol switch via XLOG_FPW_CHANGE — Roll out a breaking change to the WAL protocol contract between compute and storage on a live fleet without customer restarts by piggybacking on an existing Postgres control record…
• LLM agent offline query plan tuner — Deploy a frontier-model LLM agent as an offline query-plan improver for a database engine. Give it:
• LLM-as-Judge for Search Quality — Evaluate a search stack's relevance quality without relying on user click signal by having a multi-modal LLM judge score every (query,…
• LLM-as-judge multi-level rubric — LLM-as-judge multi-level rubric is the evaluation pattern of scoring a hierarchical generative artefact (a page with sections with items) at each level of its hierarchy using…
• LLM attribute extraction before embedding — Use a lightweight LLM to extract structured attributes from noisy raw product text before passing it to an embedding model.…
• LLM attribute extraction platform — Consolidate structured attribute extraction — turning unstructured product / document / entity data into typed fields — into a single self-serve internal platform driven by LLMs,…
• LLM batch processing service — Consolidate bulk LLM inference workloads — jobs of millions of prompts run offline against an LLM provider's batch API — into a single internal service that exposes a file-in /…
• LLM extraction cache by similarity — Avoid re-running expensive LLM extractions for items that are "similar enough" to ones already extracted, by maintaining a cache keyed by a similarity function (not an exact-match…
• LLM Judge as Inline Pipeline Stage — LLM Judge as Inline Pipeline Stage is the pattern of embedding an LLM-as-judge inside the data pipeline as a first-class stage…
• LLM judge in build-verification test (BVT) — Integrate an LLM-as-judge directly into the build-verification test (BVT) / CI pipeline so every candidate build of a search, ranking,…
• LLM-only code migration pipeline — For bulk code-migration tasks where two APIs, libraries, or frameworks differ in ways a human can enumerate but codemod-authoring would be prohibitively expensive per edge case,…
• LLM output as untrusted input — Problem: An LLM exposed to attacker-controllable input (even well-isolated via untrusted-input-via-file-not-prompt) can still produce output that reflects or carries injected…
• LLM per sub-agent with optimized prompts — LLM per sub-agent with optimised prompts is an agent-design pattern in which a single agent system uses different LLMs for different internal sub-agents (planning, search,…
• LLM-plus-planner validation — LLM-generated database changes (index suggestions, query rewrites, schema mutations) are plausibly correct but sometimes wrong.…
• LLM PR code review — LLM PR code review is the pattern of running every incoming pull request through a two-stage LLM classifier that decides whether the change is benign or malicious and outputs…
• Load-test at scale (before real workloads) — Load-test at scale is the practice of running a synthetic workload on a new platform sized to match the largest real workloads you plan to host there,…
• Local dev loop with remote parity — Provide developers with local build and test environments that mirror the remote production build environment, so iteration happens locally at high speed while the repository…
• Local-emulation-first — Prefer a local emulator over a cloud deployment as the default feedback path for every proposed code change. Escalate to cloud resources only when the change is one the local tier…
• Local-global aggregation split — Execute a cross-shard aggregation query by splitting every aggregate function into a local step (pushed down to each shard and run in parallel by the shard-local query engine)…
• Local mirror of remote API — Serve the same API shape locally that your cloud serves remotely, so every client (CLI, SDK, MCP server, agent) can address local-dev resources with the same code that addresses…
• Local MySQL CI for fast tests — CI pipelines for applications that run on a managed sharded MySQL platform (PlanetScale, Vitess-backed deployments) face a fidelity-vs-speed trade-off:
• Lock-based leader election — Resolve races between multiple electors by making the first elector that successfully acquires an exclusive lock the sole winner,…
• Prefer lock-based over lock-free consensus at scale — A scale-driven architectural recommendation from Sugu Sougoumarane's Consensus algorithms at scale series: for large-scale production consensus systems,…
• Lock-free leader election — Resolve races between multiple electors by making the elector with the newest (highest) proposal number / term number the winner, regardless of which elector started first.…
• Lock timeout for contention telemetry — A lock that's held too long by a writer looks identical in production to a deadlock:
• Logging mode → enforcement mode rollout — When rolling out a correctness-constraint enforcement system (e.g. IFC, an egress firewall, a validation layer), first deploy in logging mode…
• Logical backup engine plug-in — Treat the database backup engine as a pluggable interface rather than a single implementation, so logical-backup and physical-backup engines can coexist inside one cluster,…
• Logit equivalence as agent automation gate — Shorten the time to port a new LLM family from a reference implementation (Hugging Face transformers) into an internal optimised model implementation by making AI coding agents…
• Loopback isolation (find the real bottleneck) — Determine which layer in a stack of queues/drivers is the real bottleneck (or a source of cross-tenant interference) by replacing each layer in turn with a near-zero-latency…
• Low-confidence to human review — Route only the outputs the model is least certain about to human review, rather than sampling uniformly or reviewing everything,…
• Lowest isolation plus explicit locks — Design the application to run at the lowest isolation level the database supports — typically READ COMMITTED — and acquire explicit locks on the specific rows where correctness…
• LSM-emulation on B-tree via composite index — Some index workloads want append-to-value semantics — most canonical example: inserting a new vector into a SPFresh-style posting list that already has thousands of vectors…
• LTX compaction (time-window merge of SQLite page runs) — Represent a database's changes as sorted per-transaction page-range files (LTX), then periodically k-way-merge adjacent time windows into larger files that keep only the latest…
• Machine-native per-request payment — When an agent needs to pay for API usage / data access / per- request tool invocation, human-checkout-shaped payment flows are disqualifying: too slow, too much UX assumption,…
• Machine-to-machine authorization — Reuse the same fine-grained-authorization architecture built for end-user API calls to authorize service-to-service calls,…
• Maintenance train — Once a fleet reaches sufficient size, no single maintenance window can drain the whole fleet — the capacity loss is too large, or the window required is too long, or both.…
• Managed AI document-intelligence pipeline on AWS — A reusable AWS service-composition pattern for document-heavy enterprise workflows — contracts, claims, invoices, regulatory filings,…
• Managed OTel ingestion direct to lakehouse — Managed OTel ingestion direct to lakehouse is the pattern of using a managed serverless OTLP receiver (gRPC + REST) as the only hop between OTel-instrumented clients and a governed…
• Managed replication platform — Instead of each team hand-assembling point-to-point pipelines between a source database and whatever downstream system they need (search, lake, analytics, another database,…
• Managed Services over Custom ML Platform — When a team's in-house ML platform (often Scala + Spark, in use for several years) starts to hurt — framework lock-in, custom code duplicating managed-service functionality,…
• Managed sidecar — Managed sidecar is the pattern where the vendor owns the sidecar container's lifecycle — image, version, crash recovery, resource sizing — on behalf of the customer.…
• Managed table as default storage layer — Use managed tables (catalog-owned storage discipline) as the default storage primitive across the entire data platform — not just for BI-serving Gold-layer tables,…
• Manifest-driven micro-frontend loading — A micro-frontend host needs to decide which remote bundles to load for the current user. Hard-coding that mapping inside the host's Webpack config has two drawbacks:
• Manifest via Raft for fast failover — On each LSM memtable flush, write the updated manifest to durable remote storage (object storage) AND replicate it to all Raft-group followers.…
• Manual span passing over async context — OpenTelemetry's JavaScript SDKs offer two ways to propagate a span across async function boundaries:
• Map-encoded real-world constraint — Ride-sharing and on-demand-logistics apps have a core assumption: the rider's GPS location is a feasible pickup point. For a large class of physical-world constraints,…
• Mapping-driven schema generation — Make the mapping from source schemas to a conceptual layer the authoritative artifact, and derive both (1) the target schema and (2) the transformation code from it.…
• Markdown profile output for agents — Profiling tools (flame graphs, trace viewers) emit their native output in formats optimised for UI consumption — JSON for Perfetto / Chrome chrome://tracing to render flame graphs…
• Market Group isolation for serving API — A single serving deployment for a multi-country platform has a correlated failure profile: a hot-partition event, a bad config push,…
• MCP as centralized integration proxy — Deploy a single MCP server tier in front of the enterprise's internal systems (databases, queues, SaaS APIs, code repos, docs) and make it the mandatory choke-point through which…
• MCP as context bridge — MCP as context bridge is a pattern where Model Context Protocol is used to compose multiple, previously disconnected context sources into a single agent session so that a model can…
• MCP as fallback for shell-less agents — Expose system capabilities via MCP only when the consuming agent cannot run shell commands. For shell-capable agents, prefer:
• MCP tools + skills unified platform — Split the operational-AI platform into two layers — a shared MCP tool layer and a pluggable skills layer — so every new use case is a new skill,…
• Measure idle from last-ACK, not last-send — *When detecting idleness in a bidirectional rate-adaptive protocol, anchor the idle duration on the most recent activity across both directions…
• Measurement-driven micro-optimization — Pick the code worth optimizing by production profiling, not by taste; validate each candidate change against a repeatable benchmark; ship;…
• Memory-safe language for untrusted input — A design rule: any code path that (a) processes untrusted input and (b) runs automatically (without user confirmation / step) should be written in a memory-safe language — Rust,…
• Merchant-of-Record Aggregation — Merchant-of-Record Aggregation is the design pattern where a single intermediary (the Merchant of Record or MoR) sits between N content producers and M consumers,…
• Prefer MERGE INTO over INSERT OVERWRITE (Iceberg row-level updates) — On apache-iceberg (and other open table formats that expose both surfaces), prefer MERGE INTO over INSERT OVERWRITE for row-level updates.…
• Metadata boost at query time — Let query-time business logic (recency, priority, region, tenant tier, language) re-rank already-relevant results, without re-indexing, re-embedding,…
• Metadata-DB + object-cache tier — Architect a globally distributed object store as three independent layers rather than one monolithic service:
• Metadata envelope in durable payload — When a durable engine (workflow engine, queue, scheduler, event log) persists a payload and replays it later, thread routing metadata through an envelope inside the payload rather…
• Metadata + chunk storage stack — A storage system needs:
• Metastore bootstrap from object storage — Design the metadata store so its complete state (manifest + SSTables) exists in object storage at all times. This enables two key use cases without connecting to the source…
• Metric semantic layer as AI knowledge base — Expose a structured, code-friendly metric semantic layer (YAML configurations with deterministic SQL definitions) as the grounding knowledge base for AI agents,…
• Metrics layer for deterministic Genie answers — Pin a Genie (or any structured-data LLM-powered Q&A interface) to a metrics layer — a curated, schema-bound registry of business measures with explicit SQL definitions…
• Middle-tier storage media — Storage architectures at hyperscale settle into media tiers — HDD below, flash above. Over time, each tier's economics shift: HDD areal-density climbs while its BW/TB falls (head…
• Middleware Worker adapter — Middleware Worker adapter is the pattern of placing a thin edge-compute Worker in front of — or in between — an existing application and a set of platform-native services,…
• Migrate function for component downgrade — You bumped a component's major version because you needed to change the type of one of its fields. Old clients in the field don't understand the new shape and can't be forcibly…
• Migration as Agent Skill — Ship migration tooling (source framework → target framework; deprecated API → new API; v1 → v2) as an Agent Skill that runs inside any supported AI coding tool,…
• Migration script travels with application code — The schema migration script for a feature lives in the same git repository, the same git branch, and the same pull request as the application code that depends on it.…
• Minimally-scoped LLM tools — Problem: LLM-powered CI actions give the LLM access to tools (Read, Edit, Bash, gh). Even with prompt-side isolation (untrusted-input-via-file-not-prompt),…
• Minimize VM Permissions — Treat the sandbox VM's own capabilities — its network reach, its attached IAM / cloud-resource permissions, its credential lifetime,…
• Minimum-cut training job placement — Training fabrics for LLM-scale jobs often exceed the size of a single non-blocking AI Zone / pod. The fix is an aggregator layer (ATSW in Meta's terms) that stitches Zones into…
• Mirror-first repack validation — Mirror-first repack validation is the pre-production step for a structural Git-repo rewrite (like a server-side repack) on a managed platform: run the exact target operation…
• Mixed native plus cross-platform mobile stack — A cross-platform mobile framework (React Native, Flutter, Kotlin Multiplatform, etc.) lets a team write most features once and ship to iOS and Android from one codebase.…
• Mixed sync + async replication topology — In a multi-replica MySQL cluster, configure exactly one replica with semi-synchronous replication and the remaining replicas with asynchronous replication.…
• ML anomaly scoring over signature matching — Detect novel attack variants — including those generated by frontier AI models — without requiring a signature for each specific exploit.
• ML Platform as Internal Consulting Team — Split ML ownership between over a hundred product teams that own their own ML work (data scientists + ML engineers embedded in business domains) and a handful of central teams…
• Mock external dependencies for isolated load test — Mock external dependencies for isolated load test is the pattern of deploying service virtualisation / API mocks alongside the services under load…
• Model-agnostic suggestion aggregator — Sit an aggregator service in front of one or more AI / ML / data backends so that the consumer (UI, downstream service) is bound to the aggregator contract,…
• Model as interchangeable component — Design AI pipelines so that the underlying model can be swapped, rotated, or cross-tested without affecting the orchestration logic…
• Model-aware concurrency tuning — Instead of using a fixed, administrator-chosen concurrency limit per pod, let the autoscaler discover each model's optimal concurrency at runtime by observing hardware utilization…
• Model fallback hierarchy with circuit breaker — For every LLM-powered feature, designate a primary model and one or more backup models in a defined fallback hierarchy. Combine with an automated circuit breaker that monitors…
• Model once, represent everywhere — Promote your conceptual model from documentation / tribal knowledge to a first-class control-plane artifact, then project that single authored model into every concrete surface…
• Model registry and object store as hybrid glue — In a hybrid ML platform, compute (training) and serving (inference) run on different substrates. You need a way for training jobs on the compute side to produce artifacts…
• Model-system co-design for ranking — For LLM-scale ranking inference, drive MFU close to hardware peak by co-designing the model with the underlying GPU hardware:
• Model-units utilization autoscaling — Drive LLM-serving autoscaling decisions from the model unit utilisation ratio averaged across pods, with per-replica capacity targets benchmarked per (model, hardware) pair,…
• Modular disaggregated constellation — Modular disaggregated constellation is an architectural-shape pattern for space-based infrastructure: build from many small, interconnected satellites in close formation,…
• Modular rack for multi-accelerator — Hyperscale AI infrastructure must:
• Module as versioned artifact — Every code push to an ML module repository produces a versioned, immutable artifact that can be referenced by downstream workflows.…
• Module-based GraphQL decentralization — You have a large organisation with many teams contributing to a single GraphQL schema, and you want each team to be able to ship changes to their part of the schema without…
• Monthly plus daily dual-cadence integrity check — Run two integrity-check loops at different cadences against the same pipeline output:
• Mount-gated client-only rendering — Pattern. For content that should genuinely differ between server-side and client-side rendering (device-specific banners, viewport-dependent UI, anything that uses navigator.…
• Mountable persistent storage — Mountable persistent storage is the pattern of presenting a durable external store (object storage, network filesystem, blob service) as a local filesystem partition inside…
• MPA-gated restore authorization — Require multi-party approval (MPA) as a hard gate before any restore proceeds from a logically air-gapped vault. The pattern uses a predefined set of approvers (configured via IAM…
• Multi-account AWS isolation — Use separate AWS accounts as the primary isolation boundary to segregate environments by purpose (training / ingest / serving / analytics), not just by tenant.…
• Multi-agent debate evaluation — Evaluate an LLM-generated or chatbot-produced output by running three LLM sub-agents in a structured debate:
• Multi-agent coordination over streaming — In multi-agent systems, agents need to communicate, hand off work, and synchronise. The streaming-broker pattern is to treat multi-agent coordination as a microservices-over-Kafka…
• Multi-agent supervisor routing — A supervisor agent sits at the front of a multi-agent system, classifies an incoming user query's intent and complexity, and routes the query to one of several specialist…
• Multi-attribute / multi-product prompt batching — Amortise shared-context token cost across many LLM extractions by batching multiple attributes per product into a single prompt (send the product's features once,…
• Multi-AZ Vitess cluster — A Vitess cluster (tablets + VTGates + vtctld) on a managed cloud is exposed to availability- zone failures. Single-AZ deployments lose the entire cluster when the AZ goes offline…
• Multi-candidate generation — Generate N candidate outputs per input (instead of one), then let a downstream selector — typically a judge LLM, a rubric, or a user — pick the best.…
• Multi-card sharded embedding serving — When a ranking model's embedding tables exceed single-GPU memory:
• Multi-cloud LLM serving — Run production LLM-powered features against managed model-serving endpoints from two or more independent cloud providers,…
• Multi-cluster active-active redundancy — Multi-cluster active-active redundancy is the deployment shape of running N independent Kubernetes (or equivalent) clusters simultaneously,…
• Multi-endpoint quorum health check — Deploy health-check probes at multiple endpoints (typically across availability zones), and only act on a failure signal when a majority (quorum) of endpoints agree the target…
• Multi-layer normalization strategy — You have multiple independent classifiers / rule sources that each answer the same question ("is this component material?") with different strengths and failure modes:
• Multi-metric throttling — A throttler that keys its admit/reject decision on a single metric is vulnerable to every failure mode that metric doesn't capture. The canonical MySQL example:
• Multi-objective reranking layer — The upstream retrieval + ranking pipeline optimises per-candidate engagement likelihood — each Pin's saves-probability, each video's watch-probability.…
• Multi-platform chat adapter with single shared agent — A factoring of chat-bot architecture in which one agent pipeline is shared across many messaging platforms (Slack, Microsoft Teams, Google Chat, Discord, Telegram, GitHub, Linear,…
• Multi-probe consistent hashing — Multi-probe consistent hashing is a variant of consistent hashing that trades slower lookups for linear space and no virtual nodes.…
• Multi-region Raft quorum — Replicate every partition (or shard) across N replicas distributed across R geographic regions under a per-partition Raft consensus group,…
• Multi-round critic quality gate — Gate AI-generated artifacts (docs, code, context files, release copy) behind multiple rounds of independent critic-agent review with fixer agents applying corrections between…
• Multi-runtime function platform — Multi-runtime function platform is the platform-design pattern of shipping multiple native language runtimes within a single function product,…
• Multi-signal pairwise similarity — Downstream reranking algorithms — DPP, SSD, MMR, slate-level classifiers — all reduce to "how similar are items i and j?" The quality of this similarity bounds the reranking…
• Multi-signal workload-aware gateway routing — Multi-signal workload-aware gateway routing is the pattern of routing requests / queries / workloads at a gateway layer using multiple real-time signals combined into a single…
• Multi-stage extraction pipeline — Converting a raw conversation transcript into durable, searchable memories is not a single LLM call. A naive "summarise this to a list of facts" prompt produces:
• Multi-stage LLM pipeline over large context — When reasoning about a large document corpus with LLMs, chain multiple narrow single-objective LLM stages rather than stuffing all documents into a single large-context prompt.…
• Multi-stage vulnerability discovery harness — Coordinate AI-driven vulnerability research at coverage by splitting it into a stage pipeline of independent agent populations,…
• Multi-step LLM extraction pipeline — Decompose a large-scale LLM-driven information-extraction job into a sequence of narrow LLM invocations, each with a focused prompt over a focused input slice,…
• Multi-step RCA workflow — Problem. On-call engineers investigating a service degradation or outage need to (a) pull the relevant telemetry, (b) interpret each signal,…
• Multi-strategy compaction — Instead of a single compaction heuristic, run N strategies concurrently over disjoint segments of the volume (or run/SSTable/fragment) fill-level distribution.…
• Multi-tenant GraphQL runtime — You have:
• Multilayered alarm validation — Turn noisy per-frame detections into auditable alarms by composing multiple filtering layers, each cheap + independently tunable,…
• Multimodal content understanding — Multimodal content understanding is the ingestion-time pattern of routing each content type to its own specialized extraction path — documents, images, PDFs, audio,…
• Multipart upload / ranged-GET parallelism — To maximize throughput against a massively-parallel object store, push parallelism to the client:
• Multiplex many database connections over one HTTP connection — When a database protocol is tunneled over HTTP/2 or HTTP/3, make one HTTP connection carry many logical database sessions — each session is just an HTTP stream.…
• Multiprocessing runtime for CPU-bound serving — Run multiple RPC server processes per pod, each preparing and dispatching work to the GPU in parallel, instead of the standard single-process serving loop.…
• Multiprocessor signal as API — Expose a fraud-detection network's predictive signals as a B2B API decoupled from the underlying payment-processing service,…
• MySQL-compatible differential fuzzing — You're building a SQL engine that must be bug-for-bug compatible with MySQL — a MySQL-protocol proxy, a MySQL-wire-compatible clone,…
• Namespace-backed storage routing — Namespace-backed storage routing is the pattern of using a logical namespace identifier as the central configuration unit that maps a workload to its physical storage…
• Narrow-scoped agent task — When dispatching an agent into a find-something task on a large surface, constrain the per-task prompt to one specific question with explicit scope hints…
• NAT router for static-IP ingress — NAT router for static-IP ingress is the composite AWS architecture for giving an external SaaS (or any external caller with an outbound firewall allowlist requirement) access…
• Native Hybrid Search Function — Expose hybrid retrieval — combined lexical + vector search with fusion — as a single first-class primitive in the database / search engine's query API,…
• Native Postgres roles for non-Databricks-aware partners — Pattern. When integrating Lakebase with a non-Databricks-aware partner system that connects via standard Postgres protocol,…
• Native-side lifecycle for hybrid component — When a React Native component whose native peer is manipulated by a separate native module (the classic example: a WebView that a Mobile Bridge native module swaps out to intercept…
• Near-atomic multi-change deployment — Traditional multi-ALTER deployment on MySQL has a nasty shape: the engine serialises DDL, and individual ALTERs on large tables take hours.…
• Near-realtime replica via L0 polling — A read-replica of an object-store-backed database stays approximately current by polling the writer's finest-grained compaction level (L0) for newly-uploaded change files…
• Negative example prompting — Include explicit anti-examples in an LLM prompt — examples of the wrong pattern, paired with the correct rejection — to suppress failure modes where positive examples alone aren't…
• Negative Trust Anchor for TLD outage — When a TLD registry publishes broken DNSSEC data — bad signatures, missing DNSKEYs, inconsistent DS records — a validating resolver is obligated by spec to return SERVFAIL…
• NER-clustered Query Sampling from Production — Construct a representative search-QA test set by sampling production queries clustered by NER-tag set (intent), ranked by traffic share,…
• Nested composable workflows — Build complex ML pipelines from smaller, reusable sub-workflows via nesting and joining. Each sub-workflow is a self-contained pipeline that can be developed, tested,…
• Nested Elasticsearch for multimodal query — Index a collection of per-record heterogeneous multi-annotation payloads (different modalities, different schemas) into Elasticsearch such that:
• Network intermediary flow resolution — Network intermediary flow resolution is the pattern of combining the inbound and outbound flow records of a network intermediary (load balancer, NAT gateway, API gateway,…
• No-downtime cluster upgrade — No-downtime cluster upgrade is the deployment discipline of upgrading one or more clusters in a fleet without breaking the client-facing endpoint…
• No hybrid data models — Prevent confusing, inconsistent situations where some products within a domain use combined data tables while others use separate tables,…
• Noise over HTTP — Use the Noise Protocol Framework as the cryptographic envelope for a security-critical RPC channel, running it over HTTP (not directly over TCP, not over TLS).…
• Noisy simulated evaluation environment — When replaying an evaluation label against a candidate agent, reconstruct a simulated world that is deliberately noisy — populated with signals, components, metrics,…
• Nominal-bitrate admission control — When a server admits variable-bitrate (VBR) sessions based on current observed traffic, a long low-bitrate phase (easy-scene content) tricks the admission controller into seeing…
• Nonce-indirection bulk eviction — An invalidation-based cache indexed by query shape typically evicts exactly one cache entry per invalidation — perfect for "easy" (equality-predicate) query shapes where a row…
• Non-disruptive migration (live tenant relocation) — Move a live tenant's state between servers, hardware generations, or on-disk formats without customer-visible disruption — so the fleet underneath them can be rebuilt, upgraded,…
• NoSQL-to-NewSQL deprecation — A structured five-reason framework for retiring a load-bearing NoSQL store in favour of a NewSQL successor, rather than a one-off "we switched databases" migration.…
• Notebook-driven elastic compute — A notebook cell is the unit of work; the cluster is elastic capacity behind it. The user writes code locally; the runtime spins up compute nodes on demand, streams results back,…
• Notion four-step sharding migration — Notion's four-step framework for migrating from an unsharded database to a sharded one is Justin Gage's canonical pedagogy framing of a dual-write-plus-verify cutover,…
• NOWAIT lock for cascade-select — When application-level cascade orchestration issues the initial SELECT ... FOR UPDATE to lock parent rows before cascading child-side changes,…
• OAuth-granted access to user wallet — Use standard OAuth 2.0 (not a wallet-specific consent surface) for the initial handshake in which a consumer grants an AI agent the right to request scoped spends…
• Object store as CDC log store — Pattern: when the CDC-changelog consumer is batch-oriented (warehouse sync, periodic snapshot rebuild, offline analytics), use immutable object storage — Amazon S3,…
• Object-store batched write with Raft metadata — On the write path of a streaming broker, accept producer records into an in-memory multi-partition staging buffer; on a batch trigger (time or size),…
• Object tagging for lifecycle expiration — You need to delete millions of individual S3 objects on a schedule that varies per-object — for example, source raw-text logs immediately after they have been compacted into…
• Observability as code — Treat every vendor-managed observability resource — dashboards, alert rules, SLOs, synthetic checks, recording rules, contact points — as files under version control,…
• Cortex → object-store observability-DB rearchitecture — Cortex → object-store rearchitecture is the shared architectural transition that Grafana Labs has now applied three times…
• Observability SDK as company-specific OpenTelemetry wrapper — Adopting OpenTelemetry fleet-wide means every service team has to configure exporters, register auto-instrumentations, pick semantic conventions,…
• Observer-vs-actor animation — In real-time collaboration, render the same edit twice against different rendering contracts:
• Offline compute / online lookup for learned config — You need the output of an expensive analysis in a latency-sensitive runtime hot path, but:
• Offline fusion via event bus — A write-heavy transactional store persists data that needs complex cross-record fusion (temporal intersection, aggregation,…
• Offline teacher → online student distillation — Run an expensive, high-quality offline inference pipeline (typically a frontier LLM + RAG + domain-specific context) not only to serve production head traffic via a cache,…
• Offline train, online resolve (compression) — Format-aware compression requires picking the right transform sequence + parameters for each data shape. If this picking happens in the hot path (at encode time, per-frame),…
• Offset-preserving async cross-region replication — Maintain a hot-standby clone of a streaming cluster in a second region by asynchronously replicating every record with the source's offsets preserved.…
• OIDC + device posture access gate — Credential-based authentication (LDAP, basic-auth, even SAML) answers "who is this user?" but does not answer "is the device they are using trusted?".…
• OIDC role assumption for cross-cloud auth — A workload running in platform A (Fly.io, GitHub Actions, a Kubernetes cluster, etc.) needs to call a service in platform B (AWS, GCP,…
• On-behalf-of (OBO) agent authorization — When an AI agent makes a tool call on behalf of an authenticated human user (or a calling service), the tool-invocation boundary (typically an MCP server) forwards the call…
• On-demand Serializable read — Run the application's default transactions at a low isolation level (READ COMMITTED or REPEATABLE READ / SnapshotRead) for the contention-free throughput…
• On-the-fly async sequence packing — Eliminate FSDP straggler stalls from long-tail sequence-length distributions in LLM training — without paying the offline-preprocessing + dataset-staleness cost of offline…
• Oncall analyzer — Purpose-built tool that pulls cross-system signals on alert, applies custom logic to narrow the root cause, and hands the oncall a probable diagnosis plus mitigation options…
• One model invocation per task — Replace a single mega-prompt trying to drive a complex multi-step process with a sequence of separate model invocations, each with:
• One-shot secure aggregation — Design the secure-aggregation cryptographic protocol so each participating client submits a single message with their encrypted contribution and is then done…
• Oneof over enum-plus-field — When a protobuf message has a variant nature — different kinds carry different payloads — model it as a oneof tagged union rather than as a discriminator enum plus a grab-bag…
• Online + offline feature store parity — ML systems that serve both batch predictions (cheap, high-throughput) and online what-if predictions (interactive, low-latency) need a dual-mode feature store: one tier for cheap…
• OOM-aware VM-restart autoscaling — OOM-aware VM-restart autoscaling is the pattern of instrumenting the autoscaler with a task-level out-of-memory detector that triggers vertical scaling (larger VM) for the affected…
• Open codec consortium — Open codec consortium is the governance pattern where major streaming services, browsers, chipmakers, CDNs, and OS vendors form a joint standards organisation to develop…
• Open governance as technical constraint — For an open-source platform whose value proposition depends on long-lived interoperability and user ownership, move the project into a non-profit foundation with an ownership-…
• Open hardware for AI scaling — AI training and inference workloads are scaling faster than any single vendor's hardware roadmap can keep up with:
• Open issuer ecosystem — Open issuer ecosystem is the governance pattern required to make anonymous attribute proof schemes — Privacy Pass, ARC, ACT — viable on the open Web.…
• Open protocol over proprietary exchange — When building a cross-organisation data or service exchange layer (partner data access, supplier API integration, customer-facing analytics feed),…
• Open-source for security-response agency — When a critical security vulnerability is discovered in infrastructure software you operate, the speed-to-mitigation becomes bounded by your vendor's response time if that software…
• Open-source library wrapped by production system — A new platform needs domain expertise from two or more subgroups whose stacks barely overlap. Classic instance: a data-scientist team (Python, statistics PhDs, Jupyter notebooks,…
• OpenAPI schema as agent tool contract — Declare the set of tools an agent can invoke as a collection of OpenAPI schemas, and let a runtime gateway handle auth, request / response validation, retries,…
• Operational burden as vendor opportunity — An open-source distributed-systems substrate is available that's genuinely valuable and genuinely hard to operate. Most prospective adopters never get it into production…
• Operator-scheduled cutover — A staged-then-sealed migration (staged-then-sealed-migration) completes its copy phase whenever the shadow tables finish backfilling…
• Opportunity-to-PR AI pipeline — Turn a proposed performance-optimization opportunity into a review-ready candidate fix, delivered directly into the engineer's editor,…
• Opt-in driver-level LSN flush — When a driver-layer feature (a client driver advancing server state based on wire-protocol cues the application layer never sees) is safe for some deployments but breaks…
• Opt-in performance interface — A platform-level performance instrumentation system (see base-class-automatic-instrumentation) can run at every screen automatically,…
• Optimise for common-case frequency asymmetry — When a system has two classes of operations whose frequencies differ by orders of magnitude, optimise aggressively for the common class and accept higher per-operation cost…
• Optional non-capturing tail regex — A log line has a fixed non-user-controlled prefix followed by user-controlled tail fields with unescaped, adversarial, or otherwise parse-breaking content (spaces, quotes,…
• Orchestrated multi-agent entity resolution — Decompose the GenAI side of an Entity Resolution pipeline into role-specialised agents that collaborate, instead of a single monolithic model that tries to do everything.…
• Orchestrator-provider-agent trust triangle — Describe the three-role trust topology that makes the agent-provisioning protocol work. Not an algorithm — a role decomposition that agent-facing integrations across multiple…
• Ordered commit without 2PC — When a cross-shard DML must update an authoritative data table and one or more dependent tables (like routing indexes), order the commits across separate connections…
• Org-wide GitHub rulesets — Problem: Per-repository branch protection and workflow permissions require correct configuration everywhere; any repo missing the required setting is an attack surface.…
• Organization-owned sparse profile — Check sparse-checkout configuration into the repository as named profiles owned and maintained by the organization — not by individual engineers.…
• OTA fleet public key distribution — For services whose hardware fleet evolves faster than the client-app release cadence, do not hardcode fleet public keys in the client binary. Instead:
• Outbound Worker proxy for agent egress — Place a Cloudflare Worker in the outbound network path of every agent sandbox, so that every HTTP request the agent makes is intercepted, policied,…
• Package Rule auto-generation — When a security tool's allowlist depends on content hashes (SHA-256 of a binary, of a package artifact, of a container layer), every upstream upgrade invalidates the rule.…
• Page performance quality gates — Once a frontend platform is shared by many teams and many features, any one contributor can ship a regression that the whole site eats: a heavier component, a new dependency,…
• Pair fast-small cache with slow-large backing storage — The foundational caching pattern — applicable at every layer of every computing system: pair a small amount of expensive fast storage with a large amount of cheap slow storage,…
• Paired scheduler–reconciler — For every async job FooJob, install a companion scheduler job ScheduleFooJobs that runs periodically, queries the authoritative database for records implying FooJob should run,…
• Parallel DCNv2 + MLP cross layers — Compose DCNv2's explicit feature-crossing network and an MLP deep network in parallel on the same raw input, rather than stacking them sequentially.…
• Parallel Docker image (prod vs test) for patched library rollout — When rolling out an experimental patch to a transitive library (driver / framework / SDK), build two Docker images from the same source tree: one with the unmodified library,…
• Parallel integration test suite for context switch — Parallel integration test suite for context switch is the discipline of *reusing an existing integration-test corpus by running it under a different context…
• Parallel investigation / validation / rebuild — Run three recovery activities in parallel — investigation timeline construction, recovery-point validation, and infrastructure rebuild…
• Parallel multi-slice query — Fetching multiple graph data slices (adjacency lists, property sets) in parallel rather than sequentially, specifically to reduce latency for high-fanout graph traversals where…
• Parallel narrow agents over exhaustive — When a task is find-something or audit-something over a large surface, achieve coverage by running many agents on narrow tasks in parallel…
• Parallel pre-retrieval classifier pipeline — Before any retrieval or generation runs, fan out the user question to multiple small classifiers in parallel — safety gate, scope gate, source selector, keyword generator.…
• Parallel retrieval fusion — No single retrieval method works best for all queries. The distribution of query shapes looks like:
• Parallel rewrite with differential testing — A safe language rewrite of a security-critical library where the new implementation is developed in parallel with the original — both compile, both run,…
• Parallel run pattern — The parallel run pattern (Sam Newman, Monolith to Microservices) is a migration technique where, instead of switching traffic from the old implementation to the new one,…
• Parallel S3 download for bootstrap — Saturate available network bandwidth during a cold-start bootstrap by downloading many files from S3 concurrently rather than serially,…
• Parallel staging pipeline for production verification — Run a second copy of a data pipeline — the staging pipeline — alongside the production pipeline. The staging pipeline consumes the same production data the production pipeline…
• Parallel sub-agent execution for latency — When a multi-agent orchestration breaks a task into N sub-agent calls that are data-independent, invoke them in parallel rather than sequentially.…
• Parallel trajectory sampling and aggregation — Parallel trajectory sampling and aggregation is the agent-design pattern of running an agent's full reasoning trajectory N times in parallel over the same query and aggregating…
• Parent-child pipelines for CI parallelism — Split a single CI pipeline into one parent pipeline and N child pipelines that the parent fans out to in parallel. Each child is its own pipeline file (first-class CI artefact),…
• Partial cache hit with tail fetch — When a cache holds a decomposable time-series response as independently-keyed fragments (e.g. granularity-aligned buckets),…
• Partial materialized views (push-on-write, not pull-on-read) — Instead of planning how to fetch the data on every read (the default relational-DB model), plan how to process the data on every write, so that reading becomes essentially free.
• Partial-restart fault recovery — On a failure in a distributed job, restart only the affected resources — the specific pod, rank, or shard that failed — rather than restarting the whole job.…
• Partial return on SLO breach — Partial return on SLO breach is the server-side pattern of aborting an in-flight read mid-execution when the request has already breached its configured latency SLO and returning…
• Partition marking stops CDC bleeding — The partition marking stops CDC bleeding pattern bounds the CDC bad-data propagation hazard by annotating bad partitions in metadata rather than treating all landed data…
• Partner managed service as native binding — Integrate a third-party managed service (database, vector store, inference provider) into a platform such that customer code consumes it through the same binding mechanism…
• Password manager as phishing guardrail — Use a password manager's browser plugin as a secondary phishing control: the plugin will only autofill on a URL that matches the domain the credential was saved against.…
• PDU doubling for power headroom — When per-rack power draw exceeds the rack's nominal power budget but the upstream power distribution has unused capacity,…
• Peer debugging (scaling the senior engineer) — When a single senior engineer becomes a bottleneck on every hard problem in an org, move to a format where their systems knowledge is pooled with others…
• Peerlock sanity check — Peerlock sanity check is the operator-side BGP-filter pattern of rejecting routes that cannot possibly be legitimate given the observed AS path — specifically,…
• Per-Boot Ephemeral Key — Per-boot ephemeral key is the pattern of generating a unique encryption key inside an ephemeral compute instance on every boot,…
• Per-cgroup rate limiting in eBPF — Rate-limit event emission from an eBPF program per attribution dimension (e.g. cgroup ID) per CPU, inside the kernel, by maintaining a (cgroupid,…
• Per-client slow-query dashboard — A per-client slow-query dashboard is a dashboard that breaks the slow-query log down by caller identity, surfacing "which caller produced how many slow queries,…
• Per-database availability attainment — Measure database reliability per individual database (not as a fleet aggregate) and report what percentage of databases in the fleet met a given availability bar during a defined…
• Per-developer database branch paired with code branch — When a developer creates a git feature branch, automatically provision a matching database branch off production (or a golden baseline).…
• Per-domain adaptive config learning — You need per-domain configuration for a classifier, normaliser, or behavioural policy, and:
• Per-instance embedded database — Colocate a single, embedded database (typically SQLite) with each logical unit of compute — one DB per actor / object / tenant / Machine / session…
• Per-market Parallel TaskGroup DAG — Run the same logical pipeline — test-query generation, result retrieval, evaluation — for N markets in parallel inside one Airflow DAG,…
• Per-partition maintenance — Per-partition maintenance is the operational pattern of running table-wide maintenance operations — bulk deletion, backup, index rebuild,…
• Per-partition RSM for GC tracking — When a sharded system needs each shard to publish a per-shard garbage-collection watermark M(p), embed the GC state machine into the shard's existing replicated consensus log…
• Per-partner feature trimming for auction latency — In a multi-tenant ML serving system that runs real-time auctions under tight latency budgets — typically a retail-media or ad platform…
• Per-Platform Deployment Bulkhead — You have:
• Per-PR Airflow environment via DAG versioning — Give each pull request its own isolated pipeline environment on a shared Airflow server (not a per-PR server) by:
• Per-region read-replica routing — When a globally-deployed application has regional read replicas in several regions, have the application choose which replica region to read from based on where the application pod…
• Per-repo budget cap — Allocate fleet-scanning compute budget per repository rather than per run, because cost varies wildly across repos — allowing productive repos to receive more investment while…
• Per-request isolate per plugin — When a plugin hook fires, spawn a fresh V8-style isolate (e.g. a Dynamic Worker) dedicated to that plugin, execute the plugin's hook handler, return the result,…
• Per-service config aggregator — Per-service config aggregator: when a central infrastructure service is configured by many tenant teams, shard the configuration into one file per tenant service owned…
• Per-session ephemeral sandbox — In a multi-user agent system, spin up a fresh isolated sandbox (micro-VM, container, isolate) for each user session on first filesystem/shell access.…
• Per-slot iptables in namespace — Shape: when a multi-tenant Linux host accumulates O(tenants × rules-per-tenant) iptables rules in the root network namespace,…
• Per-tenant OAuth2 exchange endpoint — A cross-company B2B data-exchange pattern: each tenant in a shared multi-tenant SaaS publishes their data-exchange API as an individually-addressable endpoint that accepts only…
• Per-tenant policy store — In a multi-tenant SaaS using Amazon Verified Permissions, instead of putting all tenants' policies in one shared policy store and scoping every rule by tenantid,…
• Per-tenant retention via partition-key extension — In a multi-tenant analytics or storage system that uses partition-based retention (drop partitions older than N days), let different tenants apply different retention policies…
• Per-tenant workspace in third-party SaaS — You have:
• Per-tool authorization decorator — Per-tool authorization decorator is the pattern of enforcing fine-grained, per-operation authorization in-process inside an MCP server via a small decorator (or equivalent…
• Per-topic storage tier within one cluster — Let each topic in a streaming cluster pick its own storage substrate (NVMe / tiered / object-storage-native / lakehouse- native),…
• Performance comparison with scientist — Run old (control) and new (candidate) implementations of a critical code path side by side on a sampled fraction of production traffic using a harness like GitHub's scientist…
• Periodic sampling memory profiler — Periodic sampling memory profiler is the pattern of repeatedly polling an instantaneous-state counter table at a fixed interval and retaining a sliding window of samples…
• Persistent process for serverless PHP DB connections — On AWS Lambda (or analogous serverless compute), deploy PHP code behind a persistent-process request handler (Laravel Octane / Swoole / RoadRunner / FrankenPHP — under Bref,…
• PGO for frontend-bound application — A large C++ (or other compiled-language) application with many hot code paths spread across a large binary, exhibiting:
• Phase-gated investigation progression — Gate a long-running agent loop's behaviour on explicit named phases (e.g. discovery → trace → conclude) rather than encoding the multi-step methodology in a single prompt.…
• Phase-gated planner rewriter — When two otherwise-correct query-planner rewriters interfere — one wedges the tree into a shape that blocks the other — resolve the interference by gating one rewriter behind…
• Phased automated JWK rotation — Run the six-phase signing-key rotation lifecycle as a scheduled, fully automated loop over a JWKS endpoint, so that planned rotations are invisible to downstream verifiers…
• Phased CDN rollout — passthrough → managed → auto — Phased CDN rollout: passthrough → managed → auto is the pattern in which a CDN launches a new protocol-level feature in three cumulative phases,…
• Phased evolution — all-hands engineering to fleet operations — A four-phase organizational scaling playbook for any high-stakes, on-call-heavy production system: start with engineers-run-everything,…
• Phased framework migration — When migrating a large codebase from one framework to another, sequence the migration into phases that each decouple one orthogonal axis of coupling at a time.…
• Phased migration with soak times — Phased migration with soak times is the migration pattern where a fleet-wide change is rolled out in discrete stages (environments, cohorts, clusters, tenants),…
• Phased mobile rollout with stability tiers — For a production mobile rollout of a change that can't be gated by a remote feature flag — a new framework architecture, a new native SDK,…
• Phased rollout across release channels — An infrastructure change that is valid in CI and that passes schema validation and ChangeSet preview may still have unintended effects at runtime…
• Phased rollout of read mode — A read-path migration discipline that introduces multiple named read modes (e.g. OFF / SHADOW / COMPARISON / EXEC / ON), advances one dataset (or namespace) at a time through these…
• Phased SKU rollout for a new channel — When introducing a new sales channel (in-store → site → mobile → agentic), don't flip the switch on your entire catalog at once.…
• Phishing-resistant MFA behind IdP — Every internal application is a downstream relying party of a single identity provider (IdP). The IdP — and only the IdP…
• Pilot-component language migration — When considering switching a significant codebase to a new systems language (a "one-way door" decision), do not start with the hardest or most critical component. Instead:
• Pilot light deployment — DR deployment tier where the data tier in the secondary environment is running and replicated, but the compute tier is stopped (or minimally provisioned).…
• Pilot to platform via internal demand — When a single team successfully deploys a novel capability for its own use case, let inbound interest from other internal teams serve as the validation signal that the capability…
• Pipe-syntax query language — Pipe-syntax query language is a query-language surface shape where every query is composed as an ordered sequence of transformations over a source table,…
• Pipeline stage as discrete job — Pipeline stage as discrete job is the pattern of decomposing a multi-step backend workflow (ingest, enrichment, transformation,…
• Pipeline step consolidation — When "more steps" becomes a tax instead of a speedup, group related hermetic build/test actions into fewer, larger CI steps so the per-step overhead (VM warm-up, cache hydration,…
• Pipeline with open-ended passes — Structure a long-running transformation — code migration, static-analysis rewrite, format conversion — as an ordered sequence of named phases where any phase may accumulate…
• Pipelined produce with position guarantee — Pipelined produce with position guarantee is the broker-side write-pipeline technique in which a produce request is released for downstream processing as soon as its position…
• Plan-cost-times-k estimator — To make a pre-execution admission-control decision about a database query — before any rows are read, any locks are taken,…
• Plan-Mode-then-implement agent loop — Unattended coding agents working on production-critical code — performance optimisation, refactors in widely-used infrastructure,…
• Plan-then-apply agent provisioning — When an LLM-driven agent is wired to a cloud control plane through MCP tools, gate mutations behind a plan-then-apply flow…
• Planner / Coder / Verifier / Router loop — Build an agent that solves open-ended problems by planning, executing, judging, and refining a plan iteratively, with an explicit add-or-fix decision when the judge rejects.…
• Platform-adaptive component rendering — A cross-platform UI-composition pattern in which structured content (tables, cards, modals, buttons) is declared once using a high-level component API (e.g.…
• Platform engineering investment — To make architectures that demand large amounts of structural complexity (account-per-tenant, multi-cluster, multi-partition) work with a constant-size operations team,…
• Platform retrenchment without customer abandonment — *When a product line doesn't hit product-market fit, scale back forward investment (no v2, no new hardware purchases, no roadmap growth) while keeping the existing product running…
• Platform security at the application layer — *Apply infrastructure-security techniques — continuous monitoring, sampling-based detection, centralized telemetry pipelines,…
• Platform-specific TS file resolution — In a cross-platform UI component library, some components need different implementations per target platform (iOS, Android, web). Naive approaches:
• Playbook metadata integrated with app reviews — Make incident playbooks a first-class part of the application-review workflow by emitting a structured metadata file alongside the rendered playbook docs,…
• Playbooks as markdown with CODEOWNERS — Manage a fleet-scale corpus of incident playbooks (hundreds to thousands of documents, written by dozens to hundreds of teams) using Markdown files in a git repository rendered…
• Pluggable cache handler — A framework's caching layer exposes a single setter (setCacheHandler(impl) or equivalent) that accepts any implementation of a small cache interface,…
• Pluggable component architecture — Pluggable component architecture takes microservices-style independently-deployable-components thinking and applies it inside a single in-process algorithm.…
• Pluggable durability rules — Pluggable durability rules is an architectural pattern in leader-based consensus systems where the durability requirement ("how many followers / which set of followers must ack…
• Pluggable state backend — A factoring in which a system's state needs — key-value cache, distributed locks, thread / session subscriptions, TTL-based expiry,…
• Pluggable Zod tool definition — Extend an agent's tool surface by adding a single short JS / TS config block that pairs (a) Zod-typed input schema, (b) a plain-English description for the model,…
• PodOperator-encapsulated Evaluation Job — Ship each evaluation-pipeline stage as a Docker image run via KubernetesPodOperator, so that:
• Policy-as-UC-function attached to MCP — Express agent-tool-call admission control as catalog-managed code (a UC function) that is attached to the registered MCP server, not the calling agent.…
• Policy gate on provisioning — Gate every infrastructure-provisioning request at admission time against a central policy catalog. Non-compliant manifests are rejected before any resource is created…
• Policy proof-of-concept branch — When rebuilding an authorization engine — or any system whose correctness is defined by an accumulated corpus of existing rules…
• Policy static analysis in CI — A CI-time linter that walks every authorization policy and rejects the PR if any policy matches a known-buggy pattern. Complementary to — but distinct from…
• Policy testing via database branching — Use copy-on-write database branching to test new governance policies against real production trace/telemetry data in an isolated environment.
• Polymorphic usage tables for multi-tenant scale — When a multi-tenant SaaS needs to store per-tenant metadata or usage data for many entity types (fields, options, roles, schemes, work types, …),…
• PoP densification — A global edge / CDN / DNS / DDoS network wins on latency by being close to users — specifically, close in Internet topology to the last-mile network each user is on.…
• Positive security model API validation — Neutralise the advantage of automated exploit generators (including frontier AI models) by only permitting traffic that matches a known-valid schema,…
• Post-inference verification — 1. An AI component (LLM, agent, generator) produces an output y for input x. 2. A mechanical reasoner (SAT/SMT solver, theorem prover,…
• Postgres extension over fork — When building a database product on top of Postgres — even one that replaces core subsystems (replication, concurrency control, durability, storage,…
• Postgres queue on same database as application — An application needs a job queue to track asynchronous work (sending emails, generating reports, running invoicing). Using an external queue (SQS, Kafka,…
• Power of Two Choices (P2C) — Power of Two Choices (P2C): instead of picking one backend uniformly at random, pick two at random and route the request to the one with fewer active requests / lower observed…
• PQC migration ladder — Structure a multi-year PQC migration programme as a laddered set of reachable milestones rather than a single "migrated yes / no" binary.…
• PR-bot auto-deploy-request — Separating code-deploy from schema-deploy ( decoupled deploy) is architecturally correct but operationally expensive:
• PR-deployed renderer testing in debug app — A demo harness for SDUI (like Appcraft Browser) gives you a fast inner loop for renderer development — but it deliberately omits:
• PR/FAQ Writing (Amazon Working-Backwards Doc) — PR/FAQ is Amazon's internal practice of authoring a new product or service as a mock press release (what would we announce, to whom,…
• PR preview of CloudFormation ChangeSet — Pull requests that edit CloudFormation templates show a text diff of the template, but the operationally important question is what will actually change when this is applied.…
• Pre-create all network slots at boot — Shape: instead of creating network namespaces, tap/veth/bridge devices, and tunnels on demand during per-request handling,…
• Pre-disclosure patch rollout — Sequence the security-remediation timeline so the patch is already deployed to the managed-service fleet before the CVE is publicly disclosed.
• Pre-flight / flight / post-flight upgrade stages — Decompose a datastore / fleet upgrade into three explicit stages — pre-flight, flight, post-flight — each with a well-defined state-transition contract.…
• Pre-human agent review — Put agent-driven review in front of human review. By the time a human sees the PR, the obvious issues have been caught by automated reviewers…
• Pre-inspection / post-inspection route tables (TGW) — Pre-inspection / post-inspection route tables is the routing pattern that implements centralised network inspection on top of AWS Transit Gateway using two separate TGW route…
• Pre-select AI suggestions with visual disclosure — When an AI system produces suggested values for fields in a UI, pre-populate the fields with the suggestions so the default user path is accept rather than enter,…
• Pre-silicon validation partnership — Ship a workload-representative benchmark suite to CPU / SoC / accelerator vendors and collaborate with them on pre-silicon simulations and early-silicon bring-up…
• Pre-token-generation hook — A pre-token-generation hook is a function an identity provider invokes between authentication success and token signing, allowing the app to fetch and inject custom claims into…
• Pre-allocated bare-metal pool with vertical-autoscaling virtualization — Pre-provision a pool of large (often bare-metal) cloud instances with provisioning headroom, then run a purpose-built vertical-autoscaling virtualisation layer that schedules…
• Precompute then API-serve — Compute predictions in a scheduled batch job. Store them in a low-latency KV store. Expose a thin API that does lookup + request-specific composition.…
• Precomputed agent context files — Extract the knowledge AI coding agents need — module purpose, modification patterns, non-obvious failure modes, cross-module dependencies,…
• Precomputed relevance graph — Precomputed relevance graph is the pattern of building a cross-source knowledge graph + ranking model offline — before any query arrives…
• Precomputed sketch column in Delta table — Analytical dashboards need percentiles, distinct counts, top-K, and distinct-plus-metric aggregations over time windows that users select at query time.…
• Preemption-safe compiler emit — When a language runtime supports async preemption at any instruction boundary and the runtime's observers (GC, scheduler,…
• Preemptive low-severity incident for potential impact — *Declare a low-severity incident (SEV4 / SEV5) before any customer impact is observed, on the basis of elevated risk from an external event…
• Preemptive refund on early fraud warning — When a fraud-detection system predicts that a transaction is likely to trigger an early fraud warning (EFW) from the card network,…
• Preload-on-request hint (warm the backend before the client connects) — Preload-on-request hint is a pattern that attacks latency on a two-step client connection:
• Preloaded view flow for predictable navigation — You have an SDUI surface where the user is likely to navigate through a predictable sequence of related views — a wizard, an FAQ menu, a multi-step form,…
• Presentation Layer Over Storage — Presentation-layer-over-storage treats an application-facing data interface (filesystem, SQL table, vector index, message queue) as a presentation of canonical data that physically…
• Previous version as dictionary — Previous version as dictionary is the specific compression pattern in which the previously cached version of a resource — app.bundle.v1.js,…
• Price Header Negotiation (reactive + preemptive) — Price Header Negotiation is the HTTP-level design pattern for per-request paid-content access: a seller expresses a price in a response header (or acknowledges one in response…
• Primary-standby WAL replication — A two-cluster deployment topology where both clusters hold a full copy of the data and are kept in sync via write-ahead-log (WAL) shipping between them:
• Primitive mapping — Kubernetes API to cloud primitives — Pattern. When building a managed Kubernetes offering on top of an existing cloud compute platform, map each Kubernetes primitive to a pre-existing cloud primitive 1:1 rather than…
• Prioritised refresh by utilisation threshold — When a multi-tenant SaaS computes per-tenant pre-computed reports asynchronously (see asynchronous-precomputed-report-batch-framework),…
• Prioritized black-box health check — Detect silent hangs in multi-process inference engines via periodic minimal-end-to-end black-box probe requests, but assign those probes the highest scheduling priority inside…
• Priority-differentiated load shedding — Uniform load shedding — "drop N% of incoming work under pressure" — treats all work as equally valuable. Production systems rarely have this property.…
• Private origin DNS toggle — Enable private-origin routing by setting a boolean flag on a standard proxied DNS record, rather than requiring separate network infrastructure, load balancer pools,…
• Proactive cache of daily batch predictions — A B2B recommendation / optimisation product has two access shapes:
• Proactive customer outreach on elevated error rate — *Reach out to affected or at-risk customers before they contact you when your managed-service observability shows elevated error rates…
• Probabilistic feature store over KV — A production recommender system enriches each request with historical user-item features pulled from a key-value feature store (Redis-class, Dynamo-class).…
• Probabilistic forecast + percentile objective — Decision-under-uncertainty systems (inventory, capacity, pricing, bidding) face two orthogonal axes:
• Probabilistic rejection prioritization — Prioritise one client identity over another by configuring per-client rejection ratios that the throttler applies as a dice roll on each check,…
• Problem type for customer-actionable errors — When the only party that can recover from a failure is the end user (the Customer), model that failure as a schema-level Problem type…
• Process-per-connection database — Process-per-connection is a database server architecture where each client connection is served by a dedicated OS process spawned via fork() at connection time,…
• Product feedback to eval labels — Embed evaluation-label creation in the product surface itself. Every user interaction with a deployed agent — thumbs-up, thumbs-down, free-text correction,…
• Product-specific vs. generic identifiers — Tie identifier naming conventions to the modeling choice so that the data model approach is self-documenting at the column level and table joins are reliable across the warehouse.
• Production code as submodule for simulation — A simulation / back-testing framework needs to exercise the actual production code path — not a re-implementation — so that results generalise to production behaviour and bugs…
• Production qualification criteria upfront — Before a fleet-wide upgrade / migration begins, write down the criteria the post-upgrade state must meet — latency, throughput, functional equivalence, security posture,…
• Profiler orchestrator — Profiler orchestrator = a platform shape where production-host profiling is centralised behind a single scheduler + coordinator + safety-enforcer + symbolization-frontend that sits…
• Progressive cluster rollout — In a multi-cluster fleet where each cluster is a failure domain for a different tenant workload, how do you roll out a change (config, binary,…
• Progressive configuration rollout — Progressive configuration rollout is the same staged-deployment discipline usually applied to code — canary → small cohort → large cohort → fleet,…
• Progressive data loading — An evaluation optimization for systems that combine (a) a declarative expression language with statically extractable data dependencies and (b) an engine that owns data fetching…
• Progressive hydration (per-Renderer opt-in) — A server-rendered React page paints quickly but is not interactive until every component in the tree has been hydrated — hydrate() walks the whole tree and attaches event handlers…
• Progressive tool disclosure meta-tools — Avoid paying the context-window cost of hundreds of tool schemas by collapsing each product namespace into two meta-tools — one for schema discovery and one for execution…
• Projection partitioning over managed partitions — In Athena / Glue, partitioned tables can track their partitions in two ways:
• Prometheus effective-batch-size dashboard — Streaming-broker operators need a single Grafana dashboard that exposes effective batch size, request rate, scheduler backlog,…
• Promotion is merge not redeploy — The promotion-is-merge pattern replaces environment promotion (shipping schema changes from staging to production) with a git merge whose downstream effect is a database branch…
• Prompt-cache-aware static/dynamic ordering — For batch LLM pipelines where a large static context (system prompt, examples, reference material) precedes a smaller dynamic payload per request, order the prompt static-first,…
• Prompt iteration as offline methodology discovery — When preparing a frozen prompt for a production LLM pipeline, run a small, hypothesis-driven sequence of experiments offline…
• Prompt layer ordering for cache hits — Assemble every LLM prompt from most stable to most volatile layers so that the longest possible byte-identical prefix stays unchanged between consecutive calls,…
• Prompt optimizer flywheel — Prompt optimizer flywheel is the pattern of closing a feedback loop between an LLM judge, a structured representation of judge-vs-human disagreements, and a prompt optimizer (e.g.…
• Prompt template library — Ship a centralised library of per-application prompt templates — complete with few-shot exemplars, default parameter settings,…
• PromQL-to-SQL over Delta tables — Build a translation layer that accepts PromQL from Grafana (or any Prometheus-compatible tool) and executes the query as SQL against a Delta Lake / Iceberg lakehouse,…
• Proof by compile-and-run — Validate a model's claim about runtime behaviour — most notably the claim "this is an exploitable bug" — by giving the agent a per-task scratch environment in which it writes…
• Property-Based Testing — Property-based testing is a testing pattern where, instead of asserting outputs on specific inputs (traditional example-based unit tests), you:
• Protobuf cross-entity constants via custom options — Attach string (or other primitive) constants to enum values via custom protobuf option extensions on google.protobuf.EnumValueOptions,…
• Protobuf validation rules — Declare field- and message-level validation constraints inline in the .proto file using protoc-gen-validate (PGV) or its stable successor protovalidate.…
• Protocol-agnostic commerce layer — When a domain is serviced by multiple emerging protocols that are actively changing — new RFCs, new transport mechanisms,…
• Protocol algorithm negotiation — Protocol algorithm negotiation is the protocol-design pattern where each side of a connection advertises its supported algorithms (by name, in preference order),…
• Protocol-compatible drop-in proxy — Build the proxy tier so it speaks the native wire protocol of the backend it fronts (Redis RESP, MySQL, Postgres, HTTP, gRPC,…
• Prototype before production — Prototype before production — before committing to an architectural choice that will be expensive to revisit, build a standalone simulator that exposes the choice space cheaply…
• Prototype the path — Prototype the path is Slack's named methodology for executing a large re-architecture: build a barely-working prototype of the new architecture,…
• Provisioned Throughput with On-Demand spillover — Reserve dedicated Provisioned Throughput (PT) capacity for high-volume, latency-sensitive features that need consistent performance,…
• Proxy Autostop for GPU Cost Control — Proxy autostop for GPU cost control delegates start/stop of an expensive GPU inference Machine to the layer-7 proxy in front of it.…
• Proxy-based entrypoint encapsulation — When you need consistent, platform-side interception of every call across an FFI boundary (e.g. Rust↔JS through WebAssembly) but you don't yet have an upstream fix in the binding…
• Proxy layer for external SaaS — Wrap an external SaaS dependency in an internal proxy service so that the rest of the internal API platform — specifically the aggregation tier that serves user-facing traffic…
• Proxyless service mesh — Proxyless service mesh delivers service-mesh capabilities — service discovery, L7 load balancing, health-aware routing, mTLS,…
• Public ID alongside BIGINT PK — An application must expose opaque, stable, URL-friendly identifiers in its public API — so that:
• Publish binary digest ledger — For any service whose trust depends on "this specific server binary is running" — TEE-based inference, signed releases, supply-chain-critical binaries…
• Publish deployment evidence for transparency — For infrequent, high-stakes infrastructure rollovers — HSM-fleet provisioning, TEE-image releases, signing-key rotations,…
• Pull-on-demand replacing push — Replace a push-from-control-plane-to-data-plane provisioning flow with a pull-from-data-plane-to-control-plane flow triggered by demand signals.…
• Purpose-built control plane for stateful TSDB — Replace generic Kubernetes automation (HPA, StatefulSet rolling update controller, pod lifecycle hooks) with a dedicated control plane that understands the quorum invariants,…
• Push-pull gossip — Push-pull gossip is the gossip spread strategy in which, on each round, a node sends its known updates to a random peer and simultaneously requests the peer's updates…
• PySpark preprocessing to Python transformation split — Feature-engineering pipelines need to do two different things:
• Python DSL Wrapping CloudFormation — When a large engineering org has a recurring domain-shaped infrastructure need (ML pipelines, data pipelines, standard microservices,…
• Quarterly Internet disruption review — Pattern: On a recurring quarterly cadence, an Internet-observability team (one that owns a large-scale traffic vantage point — CDN, reverse proxy, DNS resolver,…
• Query comment tag propagation via ORM — Pattern: instrument the ORM (or the ORM-adjacent middleware layer) to automatically attach a structured SQL comment to every query emitted during a request or unit of work,…
• Query gateway — Query gateway is the architectural pattern of placing a proxy / load balancer in front of a heterogeneous fleet of SQL-query clusters, giving clients a single connection URL,…
• Query language as agent tool — Query language as agent tool exposes a declarative query language (typically SQL) as the primary tool surface for data retrieval, instead of wrapping each REST endpoint as a tool.…
• (query, product) Evaluation Cache — Deduplicate the expensive operations of an offline (query, product) evaluation pipeline — product-data/image fetches and LLM-judge score emissions — by caching on (query,…
• Query rewrite to pre-aggregated materialization — When a consumer issues a query against a semantic-layer metric (e.g. MEASURE(revenue) over a date range), the query engine transparently rewrites the query to read…
• Query routing proxy with health-aware pool — Decompose a database-protocol proxy tier into two processes plus a shared state store:
• Queue batching amortizes DB write throughput — A high-frequency periodic write (heartbeat, state update, telemetry sample) lands directly on a transactional DB at a per-row cost (~1 ms/row).…
• Raft log as LSM WAL — Replace the traditional file-based write-ahead log of an LSM database with a Raft consensus log. Writes to the LSM are submitted as Raft proposals;…
• RAG candidate pruning cascade — RAG candidate pruning cascade is a two-LLM cascade where the first LLM emits freeform concepts from its universal knowledge,…
• RAG over Hardware Documentation — An LLM-based code-generation agent must produce correct + performant kernels for accelerator hardware whose documentation is either (a) not in its pretraining corpus (proprietary…
• RAG side-input for structured extraction — When an LLM has to perform a structured extraction / tagging / segmentation task on a short input (a search query, a product name),…
• RAII-to-explicit-closure for lock visibility — Rust's default lock-guard idiom uses RAII — acquire the guard in a local, release implicitly when the scope ends. The lock's hold interval is determined by scope boundaries,…
• Rapid fleet-patching via managed service — When a security vulnerability ships in software the vendor also operates as a managed service, use the managed-service deployment substrate itself as the primary remediation…
• Rate controller for asymmetric media — Some storage media have read throughput substantially higher than write throughput on the same device. The archetype is QLC flash…
• Raw-to-columnar log compaction — A continuous log producer (S3 Server Access Logs, CloudFront access logs, Lambda request logs, ALB access logs, application request logs) writes many small raw-text objects…
• RBAC + JIT as agent safety net — When the safety net for correctness shifts away from manual code review (because agents are writing the code), access-control primitives become the remaining enforcement layer…
• Reactive-plus-proactive stream processing — A stateful stream processing pattern where a single processor class implements two distinct execution paths:
• Read-aside cache with dual invalidation — Read-aside cache with dual invalidation is a caching pattern for high-read-amplification storage workloads. The system maintains a read-aside cache (read-through-on-miss,…
• Read-only curated example filesystem — Instead of leaving the LLM to rely on its parametric knowledge of a library — or to fetch examples via web-search RAG (exposing the pipeline to the telephone game)…
• Read-recursive as desperation probe — Every theory you have about a concurrency bug has been refuted by evidence. The code isn't deadlocked (core dumps show no owner). Lock timings don't reveal a slow holder.…
• Read replica as migration source — A zero-downtime migration reads huge amounts of data from the source database over hours, days, or weeks. Even when the read pattern is maximally polite (primary-key-ordered…
• Read replicas for read scaling — When a single primary can no longer serve the read workload, add read replicas and split reads from writes at the application layer — writes to the primary,…
• Read the code for partial-failure bugs — When debugging failures in a distributed or orchestrated system, read the source code of the components involved rather than relying on documentation, architecture diagrams,…
• Read-through object-store volume — A VM's disk needs to be:
• Read-time schema translation — Read-time schema translation is a zero-migration pattern for evolving the semantics of an existing schema: add an adapter layer at every read site that translates legacy stored…
• Real Docker container over in-memory fake — For integration tests that cross a system boundary (database, AWS service, HTTP peer, queue, cache), run the real server as a Docker container via testcontainers rather than…
• Recipient per partner, Share per dataset group — Deploy a cross-organisation data-sharing surface using a three-primitive model that separates what to share (a Share — logical container of tables),…
• Reciprocal active-passive via parallel shadow links — Deploy two streaming clusters in two regions, each configured with a single unidirectional shadow link reading from the other, such that:
• Record pipe links, resolve at sink — In a streaming API where pipeThrough returns a new stream and pipeTo terminates the chain at a sink, don't start piping when pipeThrough is called.…
• Record-replay DSL — You want to apply a user-supplied JavaScript transformation to each element of a promised remote array, and you want it to happen server-side in one round trip…
• Redundancy for heat — Treat replicas and erasure-coded shards as I/O-steering degrees of freedom, not only as durability mechanisms. Every read request has multiple valid sources;…
• Redundant hash-plus-value predicate — Pattern: when using a generated hash column for equality lookups, write the WHERE clause with both the hash-equality predicate (which drives index use) and the original-column…
• Redundant ISP absorption of partial outage — Pattern: In a region with multiple independent ISPs, a catastrophic failure at one ISP does not fully take the region offline — traffic from the other ISPs continues,…
• Refactor-for-seccomp-filter — When a program needs dynamic access to a sensitive syscall (openat, connect, execve) during the processing of untrusted input,…
• Reference-based copy optimization — Reference-based copy optimization is a compaction/merge-side pattern for copy-on-write systems over immutable object storage: when a merge produces a new snapshot,…
• Reference hardware for software ecosystem — When your software platform has a hardware dependency whose variability makes contributor onboarding unpredictable (wildly different microphones, sensors, CPUs,…
• Reference-table materialization via VReplication — Push a small, read-mostly lookup table out to every shard via a continuous-replication materialize workflow, so joins between the lookup table and the sharded data execute locally…
• Region fallback on queue backlog — A regional allocation control plane is fed by a regional batch queue (queue-batching-amortizes-db-write-throughput). Under burst load — or when the consumer Worker degrades…
• Regional forwarding on CIDR trie — When state is partitioned by region but a minority of queries cross regions, avoid global state replication by combining:
• Regional pre-warmed DO+Container pair pool — DO-enabled Containers place a Durable Object near the request, but the Container the DO connects to may spin up "on the other side of the world".…
• Reinitialize on unrecoverable error — When a sandbox or runtime reaches a state that cannot safely be used for the next operation — and the failure mode can't be unwound…
• Release train rollout with canary — Staged rollouts come in two shapes, each with a well-known failure mode:
• Remote config model routing — Decouple the model-routing decision from the code running the AI workload so operators can flip a switch at the control plane and have every running agent re-route within seconds…
• Remote MCP server via platform launcher — A platform CLI (flyctl, a Cloudflare-analog, a hypothetical Render/Railway/Fly competitor) ships a single subcommand that takes an existing local / stdio-style MCP server command…
• REPLACE USING and REPLACE ON for selective overwrite — Selective overwrites — "replace the rows matching this predicate with these new rows, atomically" — were historically tied to partitioned table layouts.…
• Replication restart as liveness probe — When holistic detection shows orchestrator cannot reach the primary, replicas can reach it, but replica lag is growing, do not trust the replicas' reachability signal.…
• Repo health monitoring — Repo health monitoring = standing up continuous measurement of a Git repository's infrastructure-health indicators (size, growth rate, clone time,…
• Report agent self-validates schema — The terminal stage of an AI pipeline is a reporting agent that takes the upstream findings and writes them against a predefined schema…
• Reproducible benchmark publication — When publishing benchmark numbers — especially vendor-produced benchmarks that compare your product to competitors — make the methodology auditable and falsifiable by shipping…
• Request-centric inference architecture — When serving a ranking model over many candidates per request (recommendations, search, ads), shift the unit of inference from (user, candidate) pairs to (request) events:
• Request-level user-embedding broadcast — On the serving side of a candidate-scoring ML model, deduplicate per-user embedding lookups at the batch level: fetch each unique user's embedding once,…
• Request-state-propagated presentation context — In a micro-frontend architecture, many independently-owned renderers each query a shared GraphQL BFF for their slice of the page.…
• Require access before reachability — Prevent newly deployed or misconfigured applications from being reachable on the network before an explicit access policy is attached…
• Research-to-production algorithm adoption — Adopt algorithms from the published academic literature into a production system by reading adjacent-domain papers regularly,…
• Reserved-host repro environment — Reserve a small fleet of hosts, taint them so normal workloads skip them, run synthetic but realistic load with a constant resource footprint,…
• Reshard online via VReplication — Resharding an already-sharded keyspace is a repeatable, online operation via the Vitess Reshard workflow: new shards are provisioned empty,…
• Resilient edge uploader — Move captured data from an edge device to the cloud without impacting the device's primary workload or the network it lives on,…
• Response sampling for authorization detection — Sample a configurable fraction of outbound API responses. Extract identifiers of permission-gated resources from the response body.…
• Response status as content policy — Use the HTTP response status-code surface as the protocol for per-client-class content policy. When an origin operator wants different policy for different client classes (AI…
• REST gateway for compute-engine job submission — Place a single REST gateway between job-submitting clients (orchestrators, services, scheduled tasks) and the heterogeneous mix of compute engines the org actually runs…
• Result union type for mutation outcome — Model a mutation's return type as a GraphQL union of a Success type and a Problem type, so the Success and the failure payload are equal first-class members of the schema:
• Retrieve-then-rank with an LLM — A two-stage cascaded-inference pattern for applying LLMs to large candidate populations:
• Retry on 5xx, not 4xx — Retry client-side on 5xx responses and on timeouts. Do not retry on 4xx responses. The HTTP status-code class encodes whether the failure is likely transient (5xx…
• Reusable subscriber constructs — Package subscriber-side infrastructure for an event-driven system as a versioned IaC construct library so consuming teams provision their subscriber stack from a few lines of code.…
• Reuse runtime logic on admission path — A control-plane resource (Kubernetes Ingress / RouteGroup, a CRD, a config-map) carries a domain-specific DSL in an annotation, string field, or opaque payload.…
• Reverse replication for rollback — A well-prepared zero-downtime database migration (data copied, continuous replication live, VDiff clean) can still go wrong after cutover for reasons that only manifest under real…
• Risk-based sequencing — Risk-based sequencing is the migration-ordering pattern where independent migration units are ordered by ascending risk — lowest-risk environments, tenants, or workloads first;…
• RN as consumable npm Entry Point — You want to integrate React Native into an existing large native iOS/Android app without:
• Rollback-capable migration tool — A rollback-capable migration tool is a bespoke automation tool where the reverse transition is a first-class command — not an emergency escape hatch,…
• Rolling instance upgrade — Upgrading a stateful database fleet (new version, new instance class, new kernel) without downtime + without the 2× cost penalty of blue/green.
• Rollout-budget anytime plan search — Bound an iterative plan-search algorithm by a rollout count (not wall-clock, not quality threshold). Each rollout is one end-to-end candidate evaluation: propose → execute →…
• Rollout escape hatch — A time-bound, individual-scope safety valve that users flip themselves when a new enforcement blocks them during rollout — reverts their node to the prior,…
• Rotating framework-upgrade team — A fast-moving application framework (React Native, Next.js, Rails major versions, Spring Boot, etc.) ships a new major/minor release every few months.…
• Route-tagged query isolation — Pattern: tag every database query with the HTTP route (endpoint pattern) that triggered it, via middleware injection at request-acceptance time,…
• Routing rule swap cutover — After a long, careful, verified zero-downtime migration, the final step is still risky in most architectures: switching the application's queries from the old database to the new…
• Routing rules as config — Routing rules as config is the pattern of expressing load-balancer / gateway routing decisions as human-readable, individually-named,…
• RQ-VAE codebook as product vocabulary — Replace atomic item IDs as the recsys vocabulary substrate with short codeword sequences from an RQ-VAE-learned hierarchical codebook.…
• RUM-validated dictionary selection — RUM-validated dictionary selection is the pattern in which a CDN auto-selects candidate compression dictionaries from observed traffic patterns,…
• Runnable-plan pipeline — Design a query-planner optimisation pipeline such that every pipeline stage — and every rewriter step within a stage — produces an executable plan.…
• Runtime-adaptive in-memory index — Problem. A primary index structure (B+tree, skip list, LSM) is already optimised for the general case, but under production workloads a small subset of keys gets hit…
• Runtime backend swap on failure — A runtime backend swap on failure pattern treats mid-session backend failure as a first-class recovery event: when the current backend fails fatally,…
• Runtime capability dispatch — pure-Java SIMD — A service wants the performance of SIMD-accelerated math kernels but can't assume the SIMD capability is available at deploy time:
• Runtime change detection — Runtime change detection is the pattern of continuously observing production state and diffing it against an authoritative declared state, alerting on any delta.…
• Runtime-fetched credentials and config — The target platform's API for injecting credentials, environment variables, config, or hyperparameters into a container cannot match what the source platform provided:
• Runtime governance enforcement layer — Place an enforcement layer between the agent workflow and every system it touches. Every proposed action — tool invocation, dataset access,…
• Runtime information flow enforcement — Enforce privacy/security constraints as data flows through code at runtime — not at rest via ACLs, not via post-hoc audits.…
• Runtime orchestration toward unidirectional flow — A client runtime that has grown by accretion — layout engines, variable resolvers, constraint enforcers, instance resolvers, rendering pipelines, each evolved independently,…
• Runtime-provisioned per-tenant search index — Make a dedicated search index per tenant (agent, customer, session, language, region, …) a runtime-cheap primitive — created on first appearance, destroyed on tenant eviction,…
• Runtime Vulnerability Prioritization — Runtime vulnerability prioritization is the pattern of augmenting each vulnerability finding from a registry / image scanner with real-time runtime context…
• Rust replacement of dynamic-language hot path — A structural rewrite of an edge / request-path service from a dynamically-typed implementation (Lua-on-nginx, Python, Ruby, JavaScript) to Rust,…
• S3 access-based retention — A multi-tenant S3 bucket (or a bucket of complex systems) accumulates objects over years. Some are actively read; many are not.…
• S3 as policy-bundle source for availability — Your policy engine (OPA or equivalent) in the data plane needs to fetch policy bundles from somewhere. The natural answer is "from the policy control plane" (Styra DAS,…
• Safe by default — Safe by default is the principle that security-critical behaviors should be enabled out of the box, requiring operators to explicitly opt out for the narrow cases where…
• Safe midpoint computation — When computing the midpoint of two indices low and high (both non-negative) in a divide-and-conquer algorithm, do not write (low + high) / 2…
• Saga over long-running transaction — Decompose a logically-atomic multi-step workflow from a single long-running database transaction into a sequence of short local transactions connected by compensating actions,…
• Same React code for Web and Native via custom reconciler — A product is delivered as both a Web site and Native iOS/Android apps. The two experiences share most of the user journey — the same catalogue pages, the same product views,…
• Sandbox organization for SCP testing — Run a second AWS Organization dedicated to preflight-testing of SCPs, OU restructurings, and other organization-wide governance changes before applying them to the primary…
• SBOM as queryable data-lake asset — Treat every application's Software Bill of Materials as a first-class dataset in a central data lake, not as a per-repo compliance file or per-deploy artifact buried in an object…
• SBOM-driven dependency bloat audit — Use the fleet-wide SBOM corpus to discover applications with anomalously heavy dependency footprints — particularly apps that import entire umbrella libraries (e.g.…
• Scale up first, then scale out (GPU) — Use this pattern when:
• Scan planning as policy enforcement point — The architectural pattern of using the catalog's scan-planning request as the chokepoint at which governance policies are evaluated and a filtered scan plan is returned…
• Scenario minimalism for probe reliability — Scenario minimalism for probe reliability is the pattern of keeping the e2e test probe suite deliberately small — a handful of scenarios,…
• Scheduled cron-based scaling — Scale a workload's capacity up and down on a clock, not on a signal, using Kubernetes CronJobs (or external schedulers) to mutate the workload's replica count on a fixed daily /…
• Scheduled cron-triggered load test — Scheduled cron-triggered load test is the pattern of running load tests on a recurring schedule via a cron scheduler (typically a Kubernetes CronJob) that calls the same…
• Scheduler tracepoint-based monitoring — Attach an eBPF program to a pair of Linux scheduler tracepoints that bracket a state transition; record a timestamp at the leading edge keyed by task identifier;…
• Schema-aware traversal planning — Schema-aware traversal planning is a query-planning pattern for graph databases: the runtime maintains the graph schema as an in-memory metadata graph (built once at server…
• Schema-driven interface generation — Generate every interface surface a product exposes — CLI, SDK, IaC provider, MCP server, Workers bindings, configuration file schema, documentation,…
• Schema iteration via load testing — Treat schema design as an empirical optimization problem — each candidate schema is held up against a fixed hardware envelope under a production-representative load and measured…
• Schema Registry backward-compat — Integrate a Kafka Schema Registry into both source (producer) and sink (consumer) connectors of a CDC pipeline, and configure it in backward compatibility mode.…
• Schema transpilation from domain model — Treat your conceptual domain model as the authored source and transpile it, mechanically + semantically-faithfully, into every concrete schema language your organisation uses…
• Schema validation before deploy — Analyse database migration SQL before it's applied to the production database, to catch schema changes that would break in-flight records on downstream CDC pipelines.…
• Schema validation pre-upload via mapping API — Before every bulk upload to a third-party system whose schema you don't own, fetch the third-party's current field mapping via a REST introspection API and validate the outbound…
• SCM workflow state machine — An SCM workflow state machine is a pattern where source-control operations (branch creation, PR preparation, CI validation,…
• Scoped migration with fast-follows — Scoped migration with fast-follows is the pattern of deliberately constraining a migration's scope to only the substrate being swapped…
• Score-driven standard adoption — Publish a Lighthouse-style per-site scorecard for an emerging set of web standards — free, public, easy to run, with per-check actionable guidance…
• Scream test before destructive delete — A cleanup pipeline or supertool is about to permanently delete a resource (AWS account, DNS zone, S3 bucket, database, VPC, …).…
• Screen-by-screen RN migration — You have a large existing native app (90+ screens in Zalando's case) that you want to move to React Native. Big-bang rewrite fails:
• Seccomp-bpf container composition — Compose the independent Linux isolation primitives — namespaces + cgroups + capability dropping + seccomp-bpf — into a single sandbox.…
• Secondary index for high-cardinality attributes over object storage — When a log (or log-shaped) system's base index is deliberately kept cheap and low-cardinality — indexing only labels like service, cluster,…
• Secure tunnel to managed compute — Give a developer's local workstation an interactive / port-forward connection into an otherwise-isolated managed-compute environment without:
• Seed-node bootstrap — The seed-node bootstrap pattern addresses one specific problem in gossip-based clusters: "How does a freshly-booting node find anyone?"
• Seed-Recorded Failure Reproducibility — Seed-recorded failure reproducibility is the developer-experience discipline that every failing randomized test records enough state to be replayed exactly,…
• Segment-level Relevance Dashboard — Present LLM-judge relevance scores to engineers at segment-level aggregate granularity (NER-tag set, market, brand, category) rather than per-query,…
• Sandboxed domain-specific expression language — When users need to inject logic into a shared process (workflow orchestrator, admission controller, policy engine, configuration evaluator),…
• Selective indexing heuristics — Selective indexing heuristics is the pattern of applying rule-based filters to shrink the set of documents/frames/records that make it into a search index,…
• Selective mixed-precision quantization — For quality-sensitive inference workloads where blanket low- precision casts (FP8, INT8) degrade task metrics unacceptably:
• Self-maintaining context layer — Keep precomputed AI-agent context files in sync with the code they describe without routine human intervention, by running an automated refresh loop on a bounded cadence…
• Self-referencing metamodel bootstrap — Design the metamodel so that:
• Self-reflection LLM evaluation — Improve an LLM judge's verdict by running two sequential passes with the same agent:
• Self-service block approval — When a default-deny enforcement layer (binary authorization, egress firewall, sensitive-data-access gate, device-admission control) blocks a legitimate request,…
• Self-update with independent fallback cron — A system X that is responsible for its own updates has a classic chicken-and-egg failure mode: if the running version of X has a bug that prevents X from triggering itself,…
• Semantic code as catalog audit — When a learned-from-features Semantic ID system produces clusters that disagree with the existing taxonomy label of a product,…
• Semantic-context-grounded search index — Semantic-context-grounded search index is the discovery pattern of building search indices over a workspace's existing data assets (tables + dashboards + notebooks + documents +…
• Separate annotation from requirement — In an IFC / policy-based system where data carries labels, keep the annotation schema and the per-requirement flow rules as two separate, independently-evolving layers:
• Separate data-plane controller for hot-path operations — When a subset of the control plane's verbs runs on the synchronous request path of customer requests (because of agentic / serverless / scale-to-zero workload shape),…
• Separate edge links from properties — Separate edge links from properties is a graph-storage layout pattern: the link (the existence of an edge between two nodes) and the property bag (everything attached to that edge)…
• Separate AWS Organization per regulated division — Run one AWS Organization per regulated business division, subsidiary, or newly-acquired company when the isolation requirement is legally mandated entity-level segmentation,…
• Separate revoke from establish in leader election — Traditional majority-quorum consensus algorithms (Paxos, Raft) perform revocation of the previous leader and establishment of the new leader as a single atomic action…
• Separate routing from model selection — Separate routing from model selection is the architectural move of splitting the Objective → model decision (model selection) from the model → cluster VIP decision (routing),…
• Separate vs Combined Index (hybrid search topology) — The core architectural choice when deploying hybrid retrieval (lexical + vector): do you keep keyword and vector data in separate indexes,…
• Sequential node cordoning — Sequential node cordoning is the node-replacement pattern where nodes are cordoned one at a time (not in parallel), and each cordon is followed by a verification checkpoint before…
• Sequential numbered migration files — Schema changes in a versioned-migration paradigm need to be applied in a specific order — column A must exist before the index on column A,…
• Sequential primary key — A clustered-index database (MySQL InnoDB, InnoDB-alike) stores the whole table in a B+tree keyed on the primary key. The primary-key choice therefore determines the physical…
• Serve-stale over SERVFAIL — When a DNS recursive resolver cannot fetch a fresh authoritative answer — because the upstream nameserver is down, returning broken DNSSEC signatures,…
• Server-beacon pairing for render measurement — To measure the end-to-end rendering delay of a client (browser, crawler) that you don't control, inject a unique request identifier into both:
• Server-hydrate visible only — On a server-side-rendered page, hydrate only the portion of the page currently visible in the viewport. Mirror the client-side window virtualization choice at the SSR layer so…
• Server-side Git repack — Server-side Git repack is the pattern of permanently fixing a Git repo's pack-file size on a managed Git host (e.g. GitHub) by running an aggressive,…
• Serverless driver-worker pattern — Decouple image / event processing into a driver that orchestrates work distribution + workers that process each unit concurrently,…
• Serverless function for media processing — Dispatch per-clip / per-sub-segment media-processing work as stateless serverless functions — Docker-packaged workers invoked by an orchestrator to do one unit of work and shut…
• Service worker cache-hint header — A pattern that extends a client-side cache across hard- navigation boundaries by using a service worker to:
• Session affinity for MCP SSE — When a multitenant MCP server fleet accepts long-lived Server-Sent-Events (SSE) connections from LLM clients, the routing tier must guarantee that every SSE connection from a given…
• Session-affinity header — Session-affinity header is the LLM-serving pattern of asking clients to carry a per-session opaque token as an HTTP header on every turn,…
• Session cookie for read-your-writes — When the database architecture is read-write split (writes to primary, reads to replica pool) and the replica pool is eventually consistent,…
• Set algebra on Theta sketches — Marketing measurement, audience analytics, and incrementality testing routinely ask questions shaped like:
• Settings-aware connection pool — A settings-aware connection pool is a connection pool whose entries are indexed by the session-settings profile they carry, rather than treated as fungible.…
• Severity-gated violation reporting — A team is launching a new automated-check class (accessibility, security scanning, perf budget enforcement) that produces severity-tagged violations (critical / serious / moderate…
• SFTP for bulk daily upload — For bulk, daily, multi-hundred-thousand-record uploads to a third-party system, pick SFTP over REST API. Three named axes from Yelp's 2025-05-27 decision: reliability,…
• Shader source translator pipeline — A shader source translator pipeline maintains shader source in one canonical language / dialect and emits equivalent shaders in every target language the runtime backends need.…
• Shadow application readiness — Use live production traffic as the test oracle to pick the supported subset of an API surface, before committing application code to it.…
• Shadow migration (dual-run reconciliation) — Shadow migration (a.k.a. dual-run with reconciliation) is the pattern of running the new engine in parallel with the old, feeding both the same inputs, producing both outputs,…
• Shadow-mode alert before paging — Shadow-mode alert before paging is the pattern of deploying any new alerting source — a new monitor, a new probe, a new symptom rule…
• Shadow-mode bytes comparison — A read-path validation pattern that runs the old read path and the new read path in parallel during a phased rollout, compares the bytes returned by each,…
• Shadow-table online schema change — MySQL's native ALTER TABLE is often too blocking to run against a production table. Some schema changes qualify for ALGORITHM=INSTANT (a metadata-only flip, e.g.…
• Shadow-then-reverse-shadow migration — The shadow-then-reverse-shadow migration pattern is a three-phase migration shape for two parallel implementations of the same CDC pipeline (legacy + new),…
• Shadow traffic + reindex Blue/Green for stateful-datastore major upgrade — Upgrading a stateful datastore (search engine, database, key-value store) across a major version boundary where:
• Shadow validation of a derived dependency graph — Shadow validation of a derived dependency graph is the pattern of running a new, derived data structure (typically a graph or index) alongside an existing authoritative data path…
• SHAP attribution as governed Delta table — Pattern: when a regulated ML decision-support system makes a prediction, write the prediction's Shapley-value attribution to a governed Delta table in Unity Catalog…
• Shaping vs building — *Separate the shaping phase — cheap exploration of possible solutions — from the building phase — polishing and deploying the chosen solution to production.…
• Shard key aligned with query pattern — Choose the shard key so that the dominant query's predicate contains the shard key. The single-most-common query routes to exactly one shard;…
• Shard-parallel backup and restore — At multi-TB scale, both backup and restore become wall-clock-bounded by the database-size / per-server-bandwidth ratio. A 20 TB backup at 100 MB/s is ~63 hours;…
• Shard replication for hot keys — Shard replication for hot keys is the auto-sharder pattern for hot-key relief: when a single key (or small set of keys) attracts disproportionate load,…
• Sharded views over unsharded DB — Use database views to represent logical shards against a still-unsharded physical database, so horizontally-sharded read/write semantics can be rolled out…
• Sharding as IOPS scaling — When a database's IOPS or throughput demand approaches the per-volume cap of the cheap storage tier (e.g. AWS gp3 at 3,000 IOPS / 125 MiB/s default, 16,000 / 1,000 MiB/s max),…
• Shared ALB with path-based multi-cluster routing — Use one internet-facing Application Load Balancer (with an ACM certificate terminating HTTPS) to serve applications running in many different virtual clusters on a shared host EKS…
• Shared execution engine with pluggable executors — Build a single execution engine that handles all runtime concerns — IO substrate, concurrency, retries, backpressure, configuration parsing…
• Shared host cluster with virtual clusters — Run one physical Kubernetes cluster (e.g. EKS with Auto Mode as the node provisioner) as the host cluster, and partition it into many lightweight virtual Kubernetes clusters…
• Shared kernel resource coordination — Shared kernel resource coordination is the pattern of treating certain kernel-object namespaces — TC priorities and handles, cgroup program attach ordering, XDP program slots,…
• Shared lock for read-only metadata — When a critical section in a hot path only reads metadata under a mutex, use a shared (read) lock — allowing multiple readers concurrently…
• Shared-nothing storage topology — On a cluster where all nodes share a storage fabric (e.g. EBS on AWS), one node's storage failure is correlated with other nodes' storage failures — see correlated-ebs-failure.…
• Shared PrivateLink endpoints at tier level — Establish AWS PrivateLink interface endpoints once per tier, inside the tier's infra-group VPCs, for each downstream service the tier consumes.…
• Shared state store as topology unifier — Attach a single Kafka Streams state store to two (or more) otherwise-disjoint processing branches specifically to force the framework to merge their sub-topologies into a single…
• Shared static container across tests — Hold a Testcontainers container in a public static field on an abstract base test class, start it once in a static initialiser,…
• Shared UI-kit as internal npm package — In a micro-frontend deployment, each remote is owned by a different team. If every team re-creates primitive UI components (buttons, modals, inputs, typography, form controls),…
• Shed load during capacity shortage — During a capacity-provisioning outage (e.g. EC2 launch failure), the fleet is frozen at its current size and a peak-traffic window is approaching.…
• Shed low-priority under load — Under a capacity-exhausting load spike (viral event, bad deploy, DDoS), every query contends for the same finite resources (CPU, I/O, connections, worker processes).…
• Shim for dual-stack A/B testing — Migrate a deeply-embedded library dependency (e.g. an internal fork of an OSS project years behind upstream) without a one-shot upgrade,…
• Short-lived OIDC credentials in CI — Problem: CI workflows need credentials to talk to cloud providers (AWS, GCP, Azure), package registries (PyPI, npm), and even GitHub itself.…
• Short-term + long-term forecaster (two-forecaster architecture) — Deploy two forecasters on the same metric at different timescales, with the long-term forecaster self-gating so the short-term forecaster absorbs the non-seasonal case.…
• Sibling fork for scope deviation — Prevent a hyper-focused agent from wandering off-task when it encounters an interesting but out-of-scope code path — instead,…
• Side-by-side runtime validation — Side-by-side runtime validation is the rollout-risk discipline for replacing a foundational runtime component in a client or server where behavioral differences (execution order,…
• Sidecar agent — Run a small helper process in the same pod / network namespace as the main service, handling a cross-cutting concern (config fetch, service-mesh proxy, log shipping,…
• Sidecar eBPF flow exporter — Deploy a per-host sidecar (or host-level daemon set) that uses eBPF attached to TCP tracepoints to observe socket state changes.…
• Signal-based publish/subscribe step triggering — In a workflow orchestrator, unify inter-workflow triggering and intra-workflow step dependency behind a single signal primitive.…
• Signal-triggered fleet config apply — Fleet-wide configuration-management substrates (Chef / Puppet / Salt / Ansible-pull) traditionally run on a fixed cron — every node runs the config agent every N hours,…
• Signal-triggered heap snapshot-diff — You suspect a memory leak in a long-running server process in production. Restarting the process loses the leaking state.…
• Signed Bot Request (Ed25519 + JWK directory + RFC 9421) — Signed Bot Request is the design pattern for giving an automated client (crawler / bot / agent) a cryptographic identity that an origin can verify per-request,…
• Signed commit as device attestation — Use the device-trust X.509 certificate already installed on corporate laptops as the Git commit signing key, then verify signatures on push to cryptographically prove each commit…
• Signed embed URL with role mapping — Signed embed URL with role mapping is the canonical pattern for embedding a BI provider's dashboards inside a host application,…
• Signed reply-routing header — When an agent sends an email and expects a reply, the inbound side needs to route that reply back to the exact agent instance that sent the original message…
• Sigstore bundle attestation — Sigstore bundle attestation is the pattern of shipping a signed artifact's integrity receipt as a Sigstore-format bundle rather than in a platform-proprietary signature envelope,…
• Simian Army shape — The Simian Army shape is the architectural pattern Netflix introduced in the 2011 TechBlog post "The Netflix Simian Army": a fleet of narrowly-focused agents,…
• Single-ack completion with wider election reach — Configure a consensus-backed system so the request path ack's the client after a single replica ack (k = 1) while the election path scans all possible nodes that could have…
• Single-bus multi-account — Split ownership of an event-driven system along two orthogonal axes: one shared event bus lives in a central account owned by a platform / DevOps team,…
• Single extractor, multi call-site — Build one parser. Run it in N independent places. The places have different jobs (CI, runtime boot, post-boot validation), but they share one parser,…
• Single-function forced package split — When a single function in an otherwise-shared package drags an entire dependency tree into binaries that don't need it, move that function into its own package so only binaries…
• Single HTTP request over chatty WebSocket — A multi-step RPC flow is implemented over a long-lived WebSocket between a worker and a remote endpoint. The worker sends instructions one at a time…
• Single JSON spec to multi-platform codegen — You have a shared UI component, RPC message, or API interface that multiple platforms (iOS, Android, web, backend) all need to encode / decode in matching shapes.…
• Single-loop agent orchestration — Replace a hierarchical multi-agent system (coordinator + specialist sub-agents) with one LLM, one context, one iterative loop.…
• Single-Node Cluster per App Replica — Deploy one single-node storage cluster on each application replica host and link those per-host clusters together via store-level replication,…
• Single parser for security boundaries — Inside a cryptographic verification — or any security decision that combines multiple pieces of structured input — use one parser end-to-end,…
• Single-region DO fan-out from distributed writers — Separate the write path from the real-time broadcast path: let globally-distributed stateless compute write to a central transactional DB, then have a single,…
• Single SageMaker training job train-and-infer — The textbook ML serving stack has a clean separation between training (produces model artifact, writes to S3) and inference (SageMaker endpoint / hosted model server / batch…
• Single-source service definition — Single-source service definition defines a service's entire deploy shape — image, env vars, scaling, ingress rules, resources, health checks, IAM — in one place,…
• Single SQL interface over heterogeneous sources — A data-platform pattern in which a single SQL query engine exposes a unified query interface over multiple heterogeneous storage tiers (object-store-backed Iceberg tables,…
• Single-Threaded Control + Offload Pools — Single-threaded control + offload pools is a concurrency pattern where:
• Single top-level event handler — Replace N per-component event handlers with one top-level handler that dispatches on DOM data-attribute values. Trades an O(1) data-attribute inspection per event for eliminating N…
• Single ValueState over Chained Joins — Single ValueState over chained joins is the pattern of representing an enriched per-key record as one POJO in one ValueState[T],…
• Single VARIANT UDF for multi-type masking — Write one column-masking UDF that accepts and returns VARIANT, not type-specific signatures, so that a single UDF can mask INT, DOUBLE, DECIMAL, STRUCT,…
• Singular vs distributed throttler — A throttler — the service that rejects / accepts client requests based on system-health metrics — can be deployed as one monolithic process (singular) or as many collaborating…
• Sink connector as complement to broker-native integration — A streaming platform ships two integration surfaces for the same downstream system: (1) a broker-native integration optimised for the platform's own protocol and offering zero-ETL…
• Situation room for peak event — A situation room (or NOC / control center / war room) is a time-bounded, physically- or virtually-colocated observation post staffed during a peak event by representatives from key…
• Sixty-second performance checklist — When responding to a Linux host's performance issue, run a fixed, known-order, known-cost sequence of 10 stock shell commands in the first 60 seconds before reaching for deeper…
• Skip completion for late followers — Once a request has reached the durable stage of the two-phase tentative-then-complete commit path, save one round-trip per lagging follower by sending the complete message directly…
• Skip on missing allowlist for safety — A producer in a Send-What-You-Use serving path needs an allowlist (per consumer, per version) to trim its payload. What should happen when the allowlist is missing or unknown…
• Skip the intermediate representation — When a multi-stage pipeline stages its data through a format that is structurally lossy for the pipeline's end goal, and that lossy format is both the only thing downstream stages…
• Sliding-window rollup aggregation — A service needs to serve an aggregate metric (count, sum, histogram) over an ever-growing event log with low read latency, high write throughput,…
• SLO-aware early response — SLO-aware early response is the server-side pattern of stopping work mid-request — flushing a partial response plus a continuation token…
• SLO-derived alert rule generation — SLO-derived alert rule generation is the pattern of deriving alert window lengths and burn-rate thresholds automatically from an operation's SLO,…
• Slotted counter pattern — Per-entity counters (downloads, page views, likes) in a relational database typically map to UPDATE counters SET count = count + 1 WHERE id = ? on a single row.…
• Slow-start ramp-up (new-pod warmup) — Slow-start ramp-up: when a newly registered backend appears in the load-balancer's pool, cap its share of traffic at a low fraction and ramp it up over a warm-up window…
• SM partitioning (producer / consumer thread groups) — Inside a single GPU kernel, split thread groups into dedicated producer roles (HBM→SMEM transfer via TMA into a circular buffer) and dedicated consumer roles (compute-from-SMEM…
• Small frequent releases for risk reduction — Small frequent releases is the operational pattern of deploying production changes in small, frequently-shipped increments rather than batched into large, infrequent releases.…
• Small shards, wide fleet — Problem. A sharded cluster can be built out of few large machines (each holding a large shard) or many small machines (each holding a small shard).…
• Snapshot-based warm-up (EBS snapshots for CI agents) — Preload CI agent caches into an EBS snapshot. New agents boot from the snapshot with caches already populated, so the first build or test action doesn't pay a cold-cache startup…
• Snapshot plus catch-up replication — Copying a live database's data to another system without taking the source offline has a fundamental tension:
• Snapshot-replay agent evaluation — Capture snapshots of production-state inputs (queries, tool responses, intermediate state) from real agent runs, then replay them through candidate agent configurations (new…
• Snapshot reuse from legacy during migration — The snapshot reuse from legacy during migration pattern is a CDC-specific optimisation for migrating between two CDC systems that share a source: reuse the legacy system's most…
• Snapshot sync from Postgres to repo — Run a durable background orchestrator (e.g. Vercel Workflow) that transforms live source-configuration state (in Postgres) into a derived, versioned,…
• Snapshot sync mode for batch rebuild — Pattern. When a managed sync pipeline offers both snapshot (full replace) and triggered (incremental upsert) modes, choose snapshot mode whenever the per-cycle delta exceeds ~10%…
• Sort by request ID for columnar compression — In a recommendation-system training dataset, each row looks like [user, request, item, label]. For a single request, the user features (especially long user-history sequences…
• _source field slimming with external re-fetch on update — source field slimming with external re-fetch is the OpenSearch / Elasticsearch-specific pattern of:
• Source Plus Transformation Feature Decomposition — Spark ETL pipelines tend to sprawl into monolithic scripts: one pipeline.py file with hundreds of lines of DataFrame reads + successive transformations + final writes.…
• Source queue as overflow buffer — When an ingestion layer throttles to protect a downstream from overload, the un-consumed work has to go somewhere. Three bad places to put it:
• Spatial prefetch on access — When a data item is accessed, speculatively load neighbouring items into the cache as well — on the assumption that spatial locality holds for the workload,…
• Spec-version negotiation for backward compat — Your backend emits structured interface objects (UI components, RPC messages, API responses) that multiple generations of clients — old and new app versions, in the field,…
• Specialized agent decomposition — Build per-domain agents (storage, databases, client-side traffic, network, …) that each carry a small, well-scoped toolset,…
• Specialized reviewer agents — Instead of one LLM reviewing every axis of a code change, run N domain-specific sub-reviewers, each with a narrow prompt, narrow tool surface,…
• Specialized workflow router with LLM intent detection — An LLM classifies inbound user requests into one of N pre-defined workflows; each workflow has its own specialised handler independently designed to do the work.…
• Spend-request approval before credential issuance — Let an agent initiate a payment on a user's behalf without ever holding a reusable payment credential, by requiring the user to approve each proposed spend before any credential…
• Split bug-and-reachability questions across agents — Don't ask one agent "is this a vulnerability?". Split the question into two narrower questions, asked of two separate agents with different scopes:
• Split cluster by market for load isolation — Incident-time (not steady-state): when an Elasticsearch cluster is saturated and the cluster serves multiple market groups (country subsets),…
• Split environment per AZ for blast-radius — A shared configuration-management environment (a Chef environment, a Puppet env, a SaltStack env, etc.) is the blast-radius target of any bad configuration promotion.…
• Split llms.txt per subdirectory — For a large documentation site (thousands of pages), publish one llms.txt per top-level directory rather than one global file.…
• Split sharded + unsharded keyspaces — Split an application's table set across two keyspaces in the same Vitess cluster: a sharded keyspace holding the write-hot / large tables (each sharded by a common key)…
• Split source selection from keyword generation — When a single LLM pass is doing two distinct decisions — "which sources to consult?" and "what search terms to use against them?" — split it into two small fine-tuned models.…
• Spurious-wakeup metric — Emit a cheap metric — a counter or an event — whenever a poll-driven state machine wakes up but makes no forward progress,…
• SQL-Native Multimodal LLM Inference — SQL-Native Multimodal LLM Inference is the pattern of exposing LLM (including multimodal) inference as a callable function inside SQL / DataFrame / streaming queries so model calls…
• SQL-to-intent encoding pipeline — SQL-to-intent encoding is Pinterest's three-step pipeline that converts raw historical SQL queries into a semantically searchable intent index.
• SQLite-keyed stage persistence — Provide crash-tolerant, resumable persistence for multi-stage agent pipelines by writing all state to a single SQLite database keyed by a composite key — typically (run_id, repo,…
• SQLite + LiteFS + Litestream — Use SQLite as the primary storage engine, LiteFS as the distributed primary/replica filesystem layer (subsecond replication + primary failover),…
• SQS DLQ + cron requeue — SQS DLQ + cron requeue is a two-layer retry pattern for best-effort event publication: an AWS Lambda (or equivalent consumer) first performs in-process retries with exponential…
• SRE team per Product Cluster — SRE team per Product Cluster is the organisational shape that positions one SRE team at the granularity of a Product Cluster (a grouping of 5–20 delivery teams working on a related…
• SSD over DPP for diversification — DPP-based feed diversification is the 2018-2022 industry default but has three production pain points that grow with scale:
• SSH certificate extension smuggling — Use an existing protocol's extension field to carry orthogonal data, so the new capability ships without any changes to the protocol, the client binary, or the server binary.…
• SSO with ephemeral SSH keys — Replace long-lived SSH keys (the ~/.ssh/idrsa file that users copy between machines and that accumulates in authorizedkeys indefinitely) with short-lived SSH keys minted…
• SSTable to object store with write-through cache — Store LSM-tree SSTables in object storage (S3, GCS, ADLS) for durability and scale, while maintaining a write-through local cache so hot reads never pay the cloud-latency tax.…
• Stage-level query profiling — Problem. A single query takes ~700 ms. You need to know what it's slow at — optimising? opening tables? executing the plan? waiting on a lock? waiting on handler commit?…
• Staged model unification — When consolidating N surface-specific / workload-specific ML models into a unified model, sequence the unification by serving-cost profile (CUDA throughput on GPUs,…
• Staged rollout — Progressively roll out a change — code, config, feature flag — starting in a limited scope and expanding only if health signals stay green.…
• Stager downloads agent for remote control — A small shell snippet (the stager), sent over an already-established transport (typically SSH), bootstraps the installation of a full-featured agent…
• Staging caught mitigation failure — Staging caught mitigation failure is the pattern of treating an incident-response mitigation exactly like any other code or config change and rolling it through the staging…
• Stale-while-revalidate from IndexedDB — A client-side cache pattern that pairs the stale-while-revalidate semantic with IndexedDB as the persistent storage substrate,…
• Standalone developer app for RN — In a brownfield RN integration, every RN contributor has to build the full legacy native app to iterate — even for tiny RN-only changes.…
• Standardize observability SDK per language — Standardize observability SDK per language is the pattern of shipping language-specific observability SDKs — one for each major language on the engineering Tech Radar…
• Standards convergence over vendor extension — A standards-body discipline where a new protocol capability is introduced by simultaneously publishing (a) the generic extension mechanism and (b) a named canonical default…
• Standards-driven automation — Standards-driven automation is the pattern of choosing public, cross-vendor interchange standards as the contract between pipeline stages,…
• Starlark configuration DSL — Use Starlark (Bazel's Python-subset configuration language) as the authoring surface for system configuration, evaluated at init-time in a VM to produce a Protobuf-structured…
• Start-fast / create-slow Machine lifecycle — Expose two distinct Machine-lifecycle primitives through the compute API:
• Start with a single AWS Organization by default — For an enterprise adopting AWS, begin with a single AWS Organization containing all accounts and rely on OUs + SCPs for internal governance.…
• Startup-time fail-fast on config non-compliance — When a service is configured to run under a compliance or security policy that requires its deployment environment to hold a specific external state (OS-level flag,…
• State-eviction cron — Keep the hot-set of kernel / data-plane state bounded by running a periodic cron job that ruthlessly evicts stale state, where "stale" is defined by an idle-time or last-use…
• State machine as query lifecycle manager — Build a distributed-query engine's query lifecycle manager — the component that schedules, tracks, cancels, and tears down in- flight queries…
• State transfer on reshard — State transfer on reshard preserves per-key in-memory state when an auto-sharder reassigns a slice from one pod to another.…
• State validation with auto-reapply and reboot — When applied configuration may be wiped by an out-of-band event (e.g. firmware upgrade), keep the live state converging on the declared state by (1) validating after every change,…
• Stateful GitHub Actions cron — Run a bot as a scheduled GitHub Actions workflow for compute, but keep persistent state in an external database rather than re-deriving state from PRs / issues / comments on every…
• Stateful LLM session routing — *Route each LLM workload's requests to a dynamically-assigned subset of replicas (not the full fleet), preserving the session-to-subset binding across requests via an auto-sharder.…
• Stateless invalidator — An invalidation-based cache fed by a CDC stream needs to translate row mutations → invalidation messages for affected queries.…
• Static allowlist for critical rules — When an enforcement tool pulls its ruleset from a central sync server, there's a dependency chain: network → sync server → complete ruleset delivery → local enforcement.…
• Static analysis as cross-repo impact discovery — Use static-analysis rules running in every consumer's CI build — not as enforcement gates, but as discovery instruments. The library author writes a rule that detects callsites…
• Static content pages via CMS over hand-coded templates — For static and semi-static pages (awareness campaigns, category inspiration pages, informational pages like "About Sustainability"),…
• Static pipeline generation — *Generate the CI pipeline YAML ahead of time — not at commit-arrival on the critical path. Move any per-commit conditional evaluation (what targets to run,…
• Static prompt chain over agent loop — Problem. You need to build an LLM-backed application for a domain where precision matters, the step structure is known in advance,…
• Static site via ingress proxy to S3 website — You need to serve a static site (engineering blog, docs site, marketing page) with a custom domain and TLS. The textbook AWS answer is CloudFront distribution fronting an S3…
• Static type-specialized bytecode — Dynamic languages type-switch inside every opcode at runtime — ADD has to check whether operands are ints, floats, decimals, or strings, and branch accordingly. Type switches are:
• Stealth crawler detection fingerprint — When a crawler operator evades identity-layer enforcement (UA spoofing, IP rotation, ASN rotation), build an ML classifier over content-independent request features that produces…
• Stealth-on-block fallback — A crawler operator runs a declared, robots.txt-compliant crawler by default. When that declared crawler is blocked by an origin (via WAF rule, network-layer block,…
• Stewardship reset for foundational OSS — When a highly-leveraged foundational open-source project effectively has a single-vendor steward, the stewarding org's short-term product incentives can quietly corrode long-term…
• Sticky routing for aggregator state — A stateful stream-aggregation tier holds in-memory running state per input key — counters, percentile reservoirs, histogram buckets.…
• Sticky-session scatter-gather — You have a write-heavy API where requests carry a partition key, and you want each partition's processing to localize on one app instance…
• Storage-forwarded redo-log replication — Traditional MySQL / Postgres clusters replicate by having each replica hold its own full copy of the data and tail the primary's binlog (or WAL) to stay current.…
• Stream-connection-as-ordering-unit — Stream-connection-as-ordering-unit is the pattern of binding message ordering guarantees to the logical identity of a producer's network connection (stream) rather than to a fixed…
• Stream processor for real-time medallion transitions — Problem. The canonical Medallion Architecture implementation has Bronze→Silver→Gold transitions as scheduled batch jobs — SQL transformations authored in dbt,…
• Stream rebatch for downstream batch API — You have:
• Stream Union + KeyedProcessFunction — Stream Union + KeyedProcessFunction is the Flink DataStream-API pattern of replacing N chained stateful joins with a single keyed operator:
• Streaming broker as lakehouse Bronze sink — Problem. Most organisations running a Kafka-class streaming broker for operational data also run a lakehouse with a Medallion Architecture for analytics.…
• Streaming CDC to relational buffer — Streaming CDC to relational buffer is the pattern of landing a change-data-capture stream from a source-of-truth system directly into a PostgreSQL (or other relational) database…
• Streaming in-place tensor update — Use this pattern when:
• Streaming k-way merge (compaction) — A compaction pattern for lsm-compaction over columnar-storage-format fragments whose inputs live in high-latency, high-bandwidth object storage (S3, GCS, ABS).…
• Streaming markdown-to-native conversion — An adapter-layer pattern for chat platforms that do not natively stream rich markdown: the adapter receives a live markdown token stream from the LLM,…
• Streaming output rewrite — Manipulate an LLM's token stream as it is being emitted, applying find-and-replace rules, long-token compression, and embedding-resolved symbol rewriting…
• Streaming re-encoding reclamation — Use an existing on-the-fly encoder (typically an erasure-coder) as a streaming reclamation pipeline. Live data from severely-under-filled source units is fed continuously into…
• Structural-deterministic, logical-LLM split — A migration pattern where a heterogeneous code-migration problem is decomposed into two sub-problems with very different cost and correctness profiles,…
• Structured output grammar for valid plans — When an LLM agent must produce a structured object with correctness constraints beyond well-formedness — e.g. a query plan, a scheduling decision,…
• Sub-addressed agent instance — A single agent class on a single domain needs to host many distinct per-conversation / per-ticket / per-tenant agent instances,…
• Sub-field scoping for role trust — Structure your OIDC IdP's sub claim as a hierarchy of identity components separated by a delimiter (e.g. ::,…
• Subscribe-notify for updatable resource — Subscribe-notify for updatable resource is the MCP-server pattern for streaming live content (logs, metrics, notifications,…
• Subscriber switchover (per-consumer migration cutover) — Subscriber switchover is the cutover pattern where consumers of a dual-running pipeline are moved from the old engine's output to the new engine's output one at a time,…
• Supervisor + sub-agent KYC orchestration — A regulated-compliance-grade variant of multi-agent orchestration in which:
• Supplier co-development — Enter into a long-horizon engineering partnership with a hardware supplier — share your workload profile, performance telemetry, and design-year targets;…
• Suppress hydration warning for unavoidable mismatch — Pattern. For content whose server-rendered value and client-rendered value are semantically guaranteed to differ (timers, time-deltas, "seconds remaining", live-clock displays),…
• Surface-specific checkpoint export — Train one unified multi-task model jointly on combined multi-surface data, then export N separate checkpoints — one per surface — from the same training run.…
• Surface-specific tower tree — Within a unified multi-surface ML model, give each product surface / view type its own tower tree — a surface-routed subnetwork above the shared trunk,…
• Surrogacy two-step LTE estimator — In a multi-sided marketplace, estimating the long-term effect (LTE) of a resource-allocation decision (pricing, incentive budget reallocation) is structurally hard:
• Survey-trained closeness model — Train an ML model for a latent relationship quantity (closeness, trust, real-world tie strength) against a refreshed survey label that asks users about that quantity directly,…
• Suspend routine capacity churn during dependency outage — Running fleets continuously perform routine capacity churn — draining and terminating old instances, replacing them with new ones, retiring hosts past a lifespan threshold,…
• Suspense Boundary (progressive rendering) — A Suspense boundary is a declarative "this subtree may not be ready yet" marker placed in a component tree. The renderer commits everything outside the boundary immediately,…
• Swarm of discovery agents for context prebuild — Run many parallel AI agents against a customer's data-surface-area (telemetry, codebase, document store) as a background task,…
• SWC plugin three-mode transform — SWC plugin three-mode transform is the pattern where a single compiler plugin is parameterised by a mode axis and emits different output artefacts depending on the mode,…
• SyncBatchNorm for correlated batches — Standard Batch Normalization computes the batch mean and variance independently on each device's local mini-batch. Under the IID assumption this is fine…
• Synthetic data generation — Use a controllable generative model (diffusion / image-to-image / grounded text-to-image) to produce training data with ground-truth annotations automatically embedded,…
• Synthetic pseudo-context from label — When a model needs to consume a request-time-only feature that is not present in logged training data, synthesise a training-time pseudo-version of the feature derived…
• System prompt role + output format constraint — A system prompt that asserts the model's role (expert developer, domain specialist, etc.) and fixes the output format contract (opaque fence, structured schema,…
• T-test over bootstrap for production significance testing — Replace the general-purpose but computationally expensive bootstrap percentile method for confidence intervals and significance testing with a CLT-backed t-test when:
• Tag-driven attribute-based access control — Author one access-control policy that names a tag, not the tables it applies to. Tags propagate from a managed taxonomy via a mix of human stewards and automated classifiers;…
• Tagged storage routing — Tagged storage routing dispatches each request for a named piece of data (configuration, cache entry, blob) to the storage backend best suited to that data's access pattern…
• tc-latency injection for geo-distributed simulation — To benchmark a multi-region cluster without the expense of actually deploying across regions, deploy all brokers in a single AZ and use Linux tc (traffic control,…
• TDD layer over SCM baseline — The TDD layer over SCM baseline pattern is an opt-in test-first discipline that layers on top of a mandatory SCM workflow.…
• Teacher-Student Model Compression — Teacher-student model compression is the engineering pattern of wrapping knowledge distillation into a production deployment shape: pick a model class that solves the task…
• TEE-for-private-AI-inference — Run large-model server-side inference for private user content inside a Trusted Execution Environment (TEE) — typically a Confidential Virtual Machine (CVM) +…
• Telemetry to Lakehouse — Telemetry to Lakehouse is the pattern of landing operational / tool / agent telemetry directly into governed open-table-format tables (typically Delta Lake or Iceberg) instead…
• Telemetry-to-RAG pipeline — Build a streaming pipeline that continuously ingests operational telemetry (logs, events, metrics, traces) into a vector store so that an LLM-driven investigation agent can…
• Template deployment via CI/CD metadata file — You have:
• Template project nudges consistency — A platform / infrastructure team wants every new service at the company to ship with the "right" defaults: observability wired up, AuthN/AuthZ configured, CI pipelines, linters,…
• Temporal bucketed intersection — Compute the intersection of continuous-time annotations from independent producers (multiple ML models, multiple modalities) in a way that is efficient to ingest, store,…
• Temporary SAN for fleet drain — Turn a draining worker's locally-attached storage into a network-accessible block device for the duration of the drain, so that target workers elsewhere in the fleet can pull…
• Tenant features plus network data fraud model — Train and deploy a per-tenant custom fraud model that combines:
• Tenant-per-application mapping — In a large multi-tenant internal platform (observability, storage, compute), each tenant needs to map to some unit of ownership so that:
• Test-case generation from spec — Given a formal specification (typically in TLA+ or a model-checkable spec language), enumerate its behaviours using the model-checker and emit one unit test per behaviour…
• Test category classifier then specialist skill — Before dispatching an agent to fix a flaky test, classify the test type (unit / integration / visual regression / …) and load a category-specialist orchestration skill rather than…
• Test the ambiguous invariant — Test the ambiguous invariant is the discipline of writing automated tests for behaviour that your code-base de-facto relies on even when the relevant spec does not formally require…
• Tests as executable specifications — Treat the test suite not just as a regression net, but as the behavioral specification of the system — a corpus of executable assertions that both human reviewers and AI agents…
• Thanos Receive groups with memory-retention tiers — Run two (or more) Thanos Receive groups with different memory-retention windows, each tuned for the lifespan of the workloads whose metrics it ingests.…
• Thin event plus source-of-truth hydration — The thin-event-plus-source-hydration pattern is an ingestion shape where:
• Thin library on top of OSS compute platform — Deliver ML-platform capabilities by building a thin, opinionated library on top of an off-the-shelf stack of open-source components (PyTorch + Ray + vLLM + Verl) sitting…
• Third-party-caveat strip for service token — Design user tokens with a third-party authentication caveat — but for service-token use (tokens stored alongside running code), expose an authority API that:
• Third-party countersignature for trust anchor — Require two independent organisations' cryptographic signatures on any artifact that bootstraps client trust in a new root-of-trust — a fleet public key, a binary-digest release,…
• Third-party dependency quantum assessment — When planning a post-quantum migration, scope assessment must explicitly cover third parties the organisation depends on — not only direct cryptographic counterparties,…
• Third-party OHTTP relay for unlinkability — Route client traffic to your gateway via an OHTTP relay operated by a party independent of the service provider, so that:
• Thread-per-connection database — Thread-per-connection is a database server architecture where the server runs as a single OS process (e.g. mysqld) and serves each client connection via a dedicated thread inside…
• Three-account cyber-recovery topology — Use three distinct AWS accounts inside one AWS Organization to host a cyber-resilient recovery design:
• Three-channel context architecture — In a long-running multi-agent loop (planner + N experts + critic), provide each agent with a tailored view of the investigation state via three complementary context channels,…
• Three-layer agent control (permissions / policies / guardrails) — Compose three non-overlapping runtime control surfaces between an agent and the resources it acts on, each keyed on a different decision input, each with a different granularity:
• Three-layer graph merge on query — Three-layer graph merge on query is the architectural pattern of building multiple physically separate graphs from independent capture substrates,…
• Three-layer O/O diagnosis — When an ML model shows clear offline wins that don't translate to online A/B wins (online-offline discrepancy), don't hunt for one bug…
• Three-mode rollout — off / shadow / exec — Roll out a new component that sits on the critical path — especially a control-plane or request-routing component — through a three-position configuration flag rather than…
• Three-phase LLM productionization — Go from "we want to try an LLM for task X" to "LLM-powered task X serves all production traffic cost-effectively" via a disciplined three-phase playbook:
• Three-pool-size budget allocation — Three-pool-size budget allocation is the PgBouncer sizing pattern of configuring three independent size dials — defaultpoolsize, maxuserconnections,…
• Three-stage flow aggregation pipeline — Three-stage flow aggregation pipeline is the architectural pattern of decomposing a large-volume flow-log aggregation into three sequential stages, each separately partitioned,…
• Three-stage ingest-fusion-index pipeline — You have raw ML-model output (annotations, detections, embeddings) that needs to be searchable at second-granularity across many models of different modalities at media-catalog…
• Three-way merge for schema changes — In a branch-based database schema workflow (branch-based-schema-change-workflow), many developers fork their own working branches from main and propose schema changes concurrently.…
• Three-workspace parallel agent workflow — Run N parallel checkouts (three, in the canonical instance), each on its own branch, each with its own agent working. The human is a dispatcher — reading each agent's thinking,…
• Throttler as observability substitute — Introducing a throttler into a production system changes the behaviour you were trying to observe. The change is of the same shape as the multithreaded- debugging gotcha where…
• Throttler-per-shard hierarchy — Deploy one throttler per host / tablet, and let the shard-primary's throttler act as the aggregator for its shard's metrics. Clients then target one of two scopes:
• Tier / cell / infra-group hierarchy — Structure a multi-tenant AWS deployment as three nested levels of scaling hierarchy, each addressing a different AWS quota boundary:
• Tier-tagged query isolation — Pattern: in a SaaS application with differentiated subscription tiers, tag every database query with the authenticated user's tier (e.g.…
• Tier topology as long-running branches — The tier topology as long-running branches pattern replaces separate database instances per environment (prod, staging, UAT, QA, perf,…
• Tiered state management — Memcache plus DB — When a workflow or batch process produces both short-lived intermediate state (live for the duration of one job) and long-lived persistent state (live across many job runs),…
• Tiered storage to object store — Split a stateful-broker system's storage into two tiers: a hot local tier (disk, pagecache) holding the most-recent data, and a cold remote tier (object storage — S3, GCS,…
• Time-bounded throttler rule — Every operator-configured throttler rule — exemption, prioritisation, de-prioritisation, stricter threshold, routing override — carries a TTL.…
• Time-bucketed tcpdump capture — Use tcpdump's -W N -G S -w 'strftime_template' flags to capture traffic into a rolling window of N fixed-size pcap files each covering S seconds, named by timestamp.…
• Time-limiter wrapping chained calls — When a caller with its own SLA fans out to two or more sequential downstreams, set each per-call timeout to the downstream's p99.9 and wrap the whole chain in an outer time limiter…
• Time-partitioned MergeTree for time series — Store high-volume time-series data (IoT telemetry, access logs, audit events, CI/CD metrics) in a columnar analytical store with:
• Time-window aggregator for temporal graph — Time-window aggregator for temporal graph is the pattern of storing time-windowed accumulated aggregates of a continuously- mutating graph instead of per-time-slice snapshots,…
• Timeline assembly from scored findings — After a critic has scored per-finding credibility, run a separate task that assembles those findings into a consolidated chronological narrative with explicit consolidation rules,…
• Timer-driven heartbeat emission — A stream-processing pattern where processing-time timers fire on a fixed schedule to emit output records (heartbeats, keep-alive signals,…
• TLS-first PQC rollout as blueprint — A deployment pattern where a new cryptographic primitive rolls out to TLS first, validates the construction + installed-base + performance profile at Internet scale,…
• TMA-guided optimization target selection — A team has a CPU-bound service or binary that needs performance work. The engineering cost of each optimisation pass is high (developer time, stability risk,…
• Toggleable hybrid-precision quantization — Design the inference engine so that any layer group can be toggled on/off into FP8 (or any lower-precision format) independently, via a flag,…
• Token-budget pagination — Token-budget pagination cuts a tool's response after a fixed token count (not a record count) and returns a cursor for continuation.…
• Token-limit-aware feature prioritization — *When the input fed to a language model can exceed the model's context window, order the input features by importance before serialisation so that if truncation happens,…
• Tokenized-token broker — A tokenized-token broker is a hardware-isolated intermediary that holds the real credential (OAuth token, API key, refresh token,…
• Tool-call loop minimal agent — A tool-using LLM agent is, in its simplest form, a single function that appends to a context array and calls one LLM endpoint in a loop:
• Tool-decoupled agent framework — Define agent tools as ordinary code functions + signatures + a short docstring, and let the LLM infer input format, output shape, and interpretation from the signature.…
• Tool-surface minimization — Tool-surface minimization is the discipline of keeping the number of tools an agent sees small, because (a) tool-calling accuracy degrades as the tool inventory grows (arXiv…
• Tool-tagged query attribution — When an MCP server (or equivalent agent-facing broker) brokers AI-agent access to a database, tag every SQL statement at the broker layer with the identity of the originating tool…
• Top-down cascaded page generation — Top-down cascaded page generation is the architectural pattern for building an entire personalized content page (discovery feed, recommendation surface,…
• Topic-level granular DR failover — Expose DR failover at both link granularity and per-topic granularity, so operators can match the failover tool's blast radius to the outage's blast radius:
• Torchvision over PIL image processing — For multimodal LLM serving, explicitly select the Torchvision-based image processor at model-load time when both PIL- and Torchvision- backed processors are available.…
• Trace-checking — Trace-check a production implementation against a formal specification: instrument the impl to log state transitions, collect execution traces from real / stress / randomized…
• Traffic-aware pre-rendering — Instead of pre-rendering every page (Next.js's generateStaticParams()) or none (pure SSR), query the CDN's traffic record at deploy time and pre-render only the URLs that actually…
• Transactional DB over eventually-consistent KV for claim — An exclusive-resource allocation hot path is backed by an eventually-consistent KV store. Under demand spikes, the store's convergence time exceeds the rate at which resources…
• Transactional Outbox — The Transactional Outbox pattern decouples a durable state change from publishing the corresponding event by writing both atomically into the same data store…
• Transient Databricks cluster per run — Databricks clusters can be shared (interactive clusters, long-lived) or transient (job clusters, one per run). Shared clusters:
• Translated-query NER-parity Check — Validate that translated search queries preserve intent across languages by running the NER engine against both the source and translated queries and diffing the extracted tag…
• Transparent chunking for large values — Transparent chunking is the pattern of splitting a single logical value into multiple physical chunks inside a KV / document store,…
• Transparent hot+cold tier query — Read live streaming records (hot tier) and historical Parquet/ Iceberg records (cold tier) in a single SQL statement against a single logical table,…
• Tree Search over LLM Candidates — One-shot LLM code generation produces one candidate and stops. For problems where the search space is combinatorial (kernel authoring, query plans,…
• Tree-structured conversation memory — Persist an agent's conversation history not as a flat list of messages but as a tree, where every message has a parentid.…
• Tri-modal embedding fusion — Fuse three modalities (video + audio + text) into a single per-unit embedding by running each modality through its own pre-trained encoder, concatenating the three output vectors,…
• Tri-mode opt-in test execution — A team is adding a new test class (accessibility, visual regression, slow integration tests, flaky-but-useful checks) to an existing CI pipeline. The team wants:
• Triangulate RSS growth from metrics — RSS is a per-process metric, not a per-query metric. When Postgres RSS climbs toward memory-pressure limits, the operator needs to know which queries are responsible…
• Trigger-based edge capture — Collect production data from an edge fleet only when a meaningful event is detected on-device, rather than continuously streaming or uniformly sampling all sensor traffic.…
• Trimmed-automaton predicate filter — A per-file (or per-row-group) approximate set-membership filter built by:
• Trip Classification — Trip classification is the pattern of running each trip (or trip-segment) through a classifier that assigns it to a discrete category,…
• Turbo Module + DI contract for native interop — In a brownfield RN integration, some features span the RN/native boundary: RN code needs to trigger effects in the legacy native app (e.g.…
• Two-axis horizontal + vertical autoscaling — Combine request-based horizontal scaling (add/remove replicas instantly as traffic shifts) with resource-based vertical scaling (adjust per-replica concurrency as the workload's…
• Two-connection profiling setup — Two-connection profiling setup is the pattern of using one MySQL connection to run the workload under test and a separate connection to observe it.…
• Two-flavor codebook precision vs discovery — Run two parallel codebooks that share the same RQ-VAE quantization machinery + contrastive-loss training but differ in their upstream embedding substrate,…
• Two-level regional/global state — A single global state-distribution cluster covering every region at once has two failure properties that get worse with scale:
• Two-loop parallel async build — You are composing a response from N independent units (features, widgets, panels, …) where each unit needs to call upstream services,…
• Two-monolith architecture — A product has two fundamentally different workload shapes that don't fit one monolith well:
• Two-pass API migration — Two-pass API migration is the discipline of migrating each API across two explicit passes: a first pass that makes the API work well enough for internal dogfood users (typical…
• Two-Pass Classify-Then-Deep-Extract — Two-Pass Classify-Then-Deep-Extract is the document-pipeline shape where the corpus is processed in two phases at different cost profiles:
• Two-pass PII classifier with agentic second pass — A PII / data-classification pattern that layers a fast per-column classifier with an agentic full-table-context classifier.…
• Two-phase framework integration pattern — Two-phase framework integration pattern is the reusable template for onboarding a cross-framework SDK (durable workflow, auth, telemetry, feature flags,…
• Two-phase tentative-then-complete — Separate receipt from materialisation in a consensus commit path so that:
• Two-stage evaluation — Two-stage evaluation is the pattern of splitting a per-event match/decision pipeline into:
• Two-stage forecast + optimisation pipeline — Decision-making systems under uncertainty (inventory / replenishment / capacity / pricing) have two distinct ML workloads with different cost structures and cadences:
• Two-stage pre-training — contrastive then masked — Train a visual foundation-model encoder in two sequential stages to learn complementary signals that a single-stage pre-training regime cannot acquire together:
• Two-tier connection pooling — Two-tier connection pooling is the architectural pattern where connections between application code and a database pass through two distinct pools with different responsibilities:
• TypeScript as code-gen source of truth — Use TypeScript types as the primary source of truth for code-generating APIs, CLIs, SDKs, configuration schemas, MCP servers, Terraform providers,…
• UI-wrapped workflow primitive — Multi-step infrastructure operations — database sharding, cross-cluster migration, schema deployment, backup-restore — typically have two surfaces:
• Unified application services for all origins — Apply the same security, performance, and programmability stack (WAF, bot management, rate limiting, caching, edge compute,…
• Unified billing across providers — Unified billing across providers is the cost-management pattern of routing all LLM / AI traffic — first-party inference capacity, BYO external provider keys,…
• Unified Feature Extraction for Training and Serving — Write feature extraction once and use the same artefact in both training and serving. Avoid the canonical bug where training preprocessing and serving preprocessing are two…
• Unified GraphQL Backend-For-Frontend (UBFF) — You have:
• Unified image generation platform — Consolidate all of an organisation's internal image-generation use cases behind one shared service that owns model access, parameter normalisation, prompt-template defaults,…
• Unified inference binding — A unified inference binding is an SDK / runtime-binding surface where one function call with one signature invokes any model from any provider,…
• Unified library for fleet telemetry — Pattern. Add telemetry inside a company-wide monoculture library rather than expecting every service to instrument itself.…
• Unified MCP deployment pipeline — Unified MCP deployment pipeline is the platform-engineering pattern of building one shared deployment + scaling substrate for all MCP servers in an enterprise,…
• Unified multi-surface model — Consolidate N surface-specific ML models (one per product surface / view type / traffic segment) into one unified model with a shared trunk plus surface-aware specialisation (tower…
• Unified multi-task over multi-head — Move from a multi-head architecture — where multiple task-specific heads sit on top of shared encoders and are trained with distinct losses,…
• Unified operator for cloud and self-managed — A vendor offering both a managed cloud service and a customer-Self-Managed deployment of the same product on Kubernetes faces a choice for its Kubernetes Operator: ship one,…
• Unified preference model for cross-client state — Unified preference model for cross-client state is the pattern of canonicalising a single preference hierarchy that applies across all clients (desktop, iOS, Android,…
• Unified PyTorch model as retrieval system — Use this pattern when:
• Unified retrieval tool — Unified retrieval tool is the pattern of replacing N source-specific retrieval tools (one per app, one per index, one per schema) with one tool backed by a pre-built index…
• Unified SRE team over federated — Unified SRE team over federated names the structural choice to consolidate multiple SRE teams from different departments / reporting chains into a single team under one reporting…
• Unified typespace consolidation — When two (or more) subsystems independently define parallel type definitions for the same conceptual types (boolean, number, color, …),…
• Uniform buffer batching — A uniform buffer batching pattern amortizes GPU-memory allocation and upload costs across many draw calls by collecting per-draw uniform data into a single buffer upload,…
• Untrusted input via file, not prompt — Problem: LLM-powered CI actions ( anthropics/claude-code-action and similar) assemble their prompt from attacker-controllable fields (issue body, PR title, diff content).…
• Upload-then-poll indexing — Collapse the write → indexed → searchable latency path into a single awaitable API call that returns once the document is fully indexed and ready to query…
• Upstream collaboration as migration unblock — When a migration or platform-level infrastructure project hits the ceiling of what can be accomplished outside the core tool…
• Upstream contribution parallel to in-house integration — When you need a new capability that doesn't exist in an upstream open-source project, and you cannot afford to wait on the upstream maintainer's merge timeline,…
• Upstream fixes to community — When a large adopter of an open-source framework finds bugs that only appear at their scale — because smaller adopters can't exercise the code paths hard enough to trigger them…
• Upstream the fix — When a performance / correctness / security issue lives in a shared ecosystem primitive (language engine, standard library, OSS framework),…
• Usability-first VCS CLI — Design a VCS command-line interface so that usability is the first-class design concern, not an afterthought left over once scalability and feature completeness are handled.
• Usage-driven migration prioritisation — Migrating a large analytics-table fleet to a new storage / table / catalog format (Apache Iceberg in Yelp's case) is a multi-quarter backlog with a long tail of tables.…
• User-level negative masking for InfoNCE — In two-tower retrieval training, in-batch negatives are the standard cheap negative-sampling trick: each row's positive item serves as a negative for every other row's anchor.…
• Userspace FTL via io_uring + ublk — The Flash Translation Layer (FTL) in an SSD translates host LBAs to physical NAND addresses, performs wear-leveling, garbage collects, and manages bad blocks.…
• Userspace port of kernel primitive — inherited-bug risk — When porting a kernel-space primitive to user space, the callback / event boundaries available in the kernel are rarely available one-for-one in user space…
• Utilization / Saturation / Errors triage — For every resource in a system, measure three orthogonal dimensions — utilisation (busy fraction), saturation (queue depth / wait time),…
• Validate against the future state of main — Before merging a PR, materialise a temporary branch that combines the PR with every other accepted PR ahead of it in a queue,…
• Validated backup via restore-replay — Backups that are written to durable storage but never actually restored fail silently. The failure modes are legion: silent corruption, missing files,…
• vCluster fast test-environment provisioning — Expose vCluster virtual-cluster creation as a self-service operation to QA / test engineers so they can provision isolated Kubernetes environments on demand, in under 5 minutes,…
• VCS undo tooling — Treat VCS undo as a first-class subsystem, not a recovery procedure. Provide named, idempotent, discoverable commands for undoing every destructive operation,…
• VDiff verify before cutover — A zero-downtime migration has three parts: copy the source to the destination, keep the destination in sync via continuous replication, then cut over traffic.…
• Vector index inside storage engine — Vector similarity search is increasingly a first-class feature of production systems (semantic search, RAG, recommendation).…
• Vendor abstraction service layer — You have:
• Vendor-to-internal graph migration — A structured approach to replacing a third-party managed graph database with an internally operated solution, using shared query language compatibility (both support Gremlin)…
• Verification cache with revocation feed — Combine a high-hit-rate local verification cache with a revocation feed subscription from the token authority. Clients:
• Verified-bot delisting — A platform that operates a Verified Bots program — a curated allowlist of bot operators whose traffic is treated as known-good by default…
• Version per request to resolve conflicts — Attach a totally-ordered, time-based version to every in-flight request in a consensus system so that a later elector encountering multiple conflicting incomplete requests can pick…
• Version-skew sensitivity check — Before launching a new two-tower model family, explicitly sweep embedding version skew — fix one tower's checkpoint, vary the other across a realistic range,…
• Version-specific images per Git branch — During a major version migration of a fleet-wide system, ship both old and new major versions as parallel, independently deployable artifacts by publishing version-specific images…
• VFS Range GET from object storage — Run a database engine "hot off an object storage URL" by intercepting its I/O layer with a VFS / filesystem extension the application links,…
• View over copy for test data environment — When creating a new data environment (e.g. per-PR test env), don't copy rows from the source environment — emit SQL views that point at the source environment's tables.…
• View placeholder async embed — You are rendering a server-driven page where:
• View-tree walk for readiness detection — A modern UI screen is composed of many elements (images, text, videos, chrome). The user's "is the screen ready" predicate — what Pinterest calls Visually Complete…
• Virtual filesystem over container — Agent harnesses need durable filesystem access (read, write, grep, diff). The default solution — a full container per agent…
• Virtual handler via Nitro for bundlerless frameworks — Virtual handler via Nitro for bundlerless frameworks is the pattern used to integrate a cross-framework SDK with bare-HTTP frameworks (Express, Hono, Fastify,…
• Virtual Kubelet provider — Pattern. Implement a cloud's managed-Kubernetes offering by registering a Virtual Kubelet provider that turns each Pod-create request into a call against the cloud's own compute…
• Virtual nodes for load balancing — Virtual nodes (vnodes) assign each physical node multiple positions on the hash ring by hashing its identifier through distinct hash functions.…
• Virtual policy instance per application — You embed a policy engine in a single host process (ingress proxy, service mesh filter, API gateway) that needs to enforce different policies for many tenants.…
• Visibility before enforcement rollout — Visibility before enforcement rollout is a two-gate deployment discipline for rolling out any runtime enforcement mechanism — a firewall rule, an LSM hook denial,…
• Visual eval-grading canvas — Visual eval-grading canvas is the pattern of building the human-labeling UI inside the product itself — reusing the product's own visualization primitive and extension API…
• Visual-fingerprint-based parameter classification — You need to decide whether each query parameter on a given URL pattern affects the content of the returned page. Metadata signals ( tags, documentation,…
• Visual-First Document Extraction — Visual-First Document Extraction is the pipeline shape where scanned-document pages are rendered as images and sent directly to a multimodal LLM as the first processing step…
• Visual graph for business-engineering alignment — When designing a data model that must be co-authored by engineers and non-technical domain experts, use an auto-generated graph visualisation as the primary communication artifact…
• Visual parity screenshot gate — For UI-framework migrations where the behavioural contract is "identical rendering", use a deterministic screenshot test to (a) baseline the pre-migration UI,…
• Vite hotUpdate directive-triggered rebuild — Vite hotUpdate directive-triggered rebuild is the HMR integration pattern where an SDK plugin hooks into Vite's hotUpdate lifecycle to trigger a secondary build only when the saved…
• VLM-assisted pre-labeling — Replace human-from-scratch annotation with a two-stage pipeline where a Vision-Language Model + internal teacher models generate high-quality pre-labels,…
• VLM evaluator as quality gate — Interpose a vision-language-model-based evaluator between an image-generation model and ship-to-user, so that only images passing a project-specific rubric reach the downstream…
• VM + AST dual-interpreter fallback — A statically-typed VM is fast because it eliminates runtime type dispatching. But some operations have value-dependent types…
• VMAF rung-matched ladder tuning — When a streaming service changes its encoder rate-control mode — e.g. CBR → capped VBR — and blindly re-uses the existing bitrate ladder's per-rung nominal bitrates,…
• Vocab pad to kernel boundary — Avoid a CUDA kernel-selection performance cliff (cuBLAS → CUTLASS fallback with ~3× slowdown on the LM-head layer) by automatically padding user-controlled tensor dimensions…
• VPAT-driven a11y triage — VPAT-driven a11y triage is the end-to-end engineering workflow that turns a third-party VPAT (Voluntary Product Accessibility Template) audit report into an a11y remediation…
• Vulnerability fleet-sweep via SBOM query — When a critical CVE lands in a widely-used library (Log4Shell, Spring4Shell, OpenSSL preannounced advisories), the remediation window is measured in hours, not days.…
• WAL before lakehouse publish — WAL before lakehouse publish is the pattern of interposing a latency-optimized write-ahead log between the ingestion endpoint and the final lakehouse storage layer (e.g.,…
• WAL-tied in-memory index mutation — Hybrid ANN indexes keep a small in-memory structure (e.g. an HNSW graph over centroids — the head index in SPFresh) for fast query navigation,…
• Warehouse-unload bridge — Warehouse-unload bridge is the pattern for moving OLAP-computed results back into an OLTP-friendly serving store. OLAP warehouses like Snowflake aggregate billions of rows fast…
• Warm node pool for cold-start reduction — Maintain a pre-provisioned pool of Kubernetes nodes with the base runtime image already pulled, sized by a predictive algorithm. When the autoscaler needs to add a replica:
• Warm pool, zero-work create path — A VM / compute primitive has a user-visible create operation, and the DX requires it to feel instantaneous — sub-2-second, ideally sub-second.…
• Warm standby deployment — DR deployment tier where the secondary environment runs the full stack at reduced scale. Unlike pilot-light, the compute tier is not stopped;…
• Warn on drop if recently queried — At deploy-request review time, before executing any destructive schema change (DROP TABLE, DROP COLUMN, table rename), cross-reference the target object against the platform's…
• Watchdog bounce on deadlock — A concurrency bug (deadlock, livelock, resource exhaustion) in a long-running process can wedge the process indefinitely.…
• Developer Portal as ML Pipeline Control Plane — Build the ML-pipeline observability surface (pipeline execution state, per-run metric evolution, model cards) as a plugin inside the organisation's existing internal developer…
• Webhook-triggered verifier Lambda — On every event of interest at a SaaS (a Git push, a PR update, a build completion), trigger a stateless verification function that:
• WebSocket relay over logical replication — You want to deliver database-sourced events to browser clients in real time. Browsers can't subscribe to a Postgres replication slot directly…
• Weekly batch forecast + daily batch optimise cadence — In a two-stage forecast + optimise pipeline, the forecast is the expensive ML workload (model training + batch inference over all entities) and the optimiser is the cheaper…
• Weekly Operational Review — Reliability compounds only if failures are learned from across the organisation, not just fixed in the service that produced them.…
• Weekly reconciliation check — Run a lower-frequency, full-sweep audit that verifies the invariants the primary (fast-path) automation is supposed to maintain, and surface any violations for human triage.…
• Weekly refresh cadence for agent context — Rebuild an AI agent's precomputed context corpus on a weekly background cadence, with a manual-trigger escape hatch for deliberate refresh after planned infrastructure changes.…
• Weight-only vs activation quantization — When deploying quantized attention models on GPU Tensor Cores, choose between weight-only quantization (A16W4-style: high-precision activations,…
• Weighted DNS traffic shifting — Weighted DNS traffic shifting uses DNS records with integer weights (e.g. AWS Route 53 weighted records) to split client resolutions between two (or more) backends proportional…
• Weighted-sum strategy migration — Weighted-sum strategy migration: when gradually migrating between two algorithms that produce the same shape of numeric output (e.g.…
• Well-known endpoint discovery — Publish a protocol-known metadata resource at a fixed /.well-known/ path so any client — human, automation, agent — can locate it without out-of-band configuration,…
• Whole-article retrieval via metadata segments — For a RAG system over a corpus of short, well-titled, header-structured documents (support articles, FAQ entries, knowledge-base pages),…
• Whole-AZ network partition drill — Run a chaos drill against a single cell in which the network of one availability zone is programmatically disconnected from the rest of the cluster while a real workload mix runs.…
• Wildcard config match for vendor string drift — When a configuration target is identified by a vendor-specific string that varies across OEMs even when the underlying configuration target is identical,…
• Workflow-orchestrated pipeline provisioning — When a platform needs to provision multi-step data-plane infrastructure repeatedly — each instance composed of N precise configuration steps that must all succeed or roll back…
• Workflow primitives as annotated classes — Expose durable-workflow primitives (workflow method, state fields, signals, actions, compensation, checkpointing) as annotations on plain Java / Kotlin classes,…
• Workflow step breakpoint — Add an IDE-style pause-at-step primitive to a workflow orchestrator. Users set breakpoints on specific steps; when a workflow instance reaches a breakpoint,…
• Workload-aware LLM prompting — LLMs are asked to solve database-tuning problems by looking at schemas and query text alone. Two consequences follow:
• Workload-aware runtime selection — Workload-aware runtime selection is the customer-side pattern that pairs with multi-runtime function platforms: choose the runtime for each workload based on its dominant cost…
• Workload-class resource budget — A database cluster runs multiple workload classes concurrently: high-priority transactional traffic, medium-priority user-facing analytics, low-priority scheduled reports,…
• Workload-representative benchmark from production — When existing public benchmarks don't represent your production workload shape — and procurement, capacity planning, or vendor co-optimization decisions depend on that shape…
• Workload-segregated clusters — Workload-segregated clusters is the operational pattern of running dedicated clusters per workload shape instead of a single "one-size-fits-all" cluster handling every workload…
• Workload-specific datastore migration — Rather than swap a general-purpose substrate for another general- purpose substrate in a single big-bang migration, decompose the workloads riding on it by access pattern…
• Wrap CLI as MCP server — Expose an existing CLI as an LLM tool surface by writing a thin MCP server that:
• Wrapper over heterogeneous stores as serving layer — Wrapper over heterogeneous stores as serving layer is the pattern of exposing a single SDK / API surface to callers while internally routing each request to one of several…
• Wrapper-script arg injection — A caller tool with a pluggable-program interface invokes your program with statically-configured arguments (a key id, a path, a profile name).…
• Writable VFS with buffered sync — Extend a read-side object-storage-backed VFS (vfs-range-get-from-object-store) to serve writes too, by:
• Write-aside cache for edge links — Write-aside cache for edge links is a graph-store caching pattern: cache the existence and last-write timestamp of edge links for a short TTL,…
• YAML-config-driven metric definitions — Codify business metric definitions as YAML configuration files declaring metadata (owners, data sources, allowed dimensions, time granularities,…
• YAML-declared experiment config — A back-testing / simulation / benchmark harness has many parameters: time range to evaluate, candidate parameter space, search strategy (Bayesian / grid / listed),…
• YAML-Declared Feature DAG with Topology Inferred — ETL pipelines need configuration that:
• YARN Distributed Shell as universal shell executor — When a heterogeneous workload mix has REST submission for framework-typed jobs (Spark via Livy, Hive via HiveServer2, SQL via warehouse REST) but lacks one for arbitrary shell…
• Zero-allocation cache payload — On a low-latency JVM serving tier, GC pauses directly become tail latency. A 50 ms young-generation pause on a Netty NIO thread freezes every channel that thread owns.…
• Zero-code-change platform migration — A platform team needs to move hundreds of user workloads from one execution substrate to another (K8s → managed serverless, VMs → containers, on-prem → cloud, etc.).…
• Zero-copy protobuf decoding — Zero-copy protobuf decoding is the pattern of parsing Protocol Buffer messages by traversing the wire-format bytes in a single pass without allocating intermediate memory objects…
• Zero-copy sendfile at broker — When a messaging broker ships records from the tail of its on-disk log to a consumer's socket, use the OS's sendfile (or equivalent zero-copy primitive) to have the kernel copy…
• Zero-downtime reparent on degradation — When the health monitor (see automated-volume-health-monitoring) classifies an EBS volume as degraded, the database process attached to that volume is also degraded…
• Zero-incident LLM migration — Migrate production LLM serving from one substrate to another through a four-step playbook — Compliance → Capacity → Quality → Rollout…
• Zero injection for sparse counters — A transparent fix for Prometheus' silent undercounting of sparse counters under rate() / increase(). The aggregation tier, on the first flush of each counter series,…
• Zero-trust re-verification — Zero-trust re-verification re-runs the authorization check at each trust boundary that handles a privileged request, using the same policy engine…
• ZKP capability disclosure — Prove possession of a dangerous capability using a zero-knowledge proof instead of publishing the capability itself. Defenders update their threat models on the verified existence…
• Zonal reparenting to healthy AZ — A partial network partition between availability zones has left some database primaries connectable from the Internet but unable to communicate with their replicas,…
• Zone-affinity routing (with spillover) — Zone-affinity routing prefers in-zone / in-region backends over cross-zone ones for latency and cost. With spillover (the version that actually works at scale): fall back to remote…