Glossary
Plain definitions of the terms this library teaches, each one linked to the lesson that goes further. Free, and no account needed.
327 terms
A
- Abuse, Moderation & Account SafetyAbuse, moderation and account safety is the product and infrastructure work that limits harmful behaviour, handles reports, enforces policy, and recovers from mistakes or takeovers.
- Access Control at the Data LayerAccess control at the data layer is authorisation enforced where records are read or written, so every query is constrained by the authenticated user, tenant, or role.
- Account Changes, Merging & RecoveryAccount changes, merging and recovery are the lifecycle operations that keep a user’s durable application account and owned data intact while login methods, emails, providers or duplicate accounts change.
- Account You Cannot GetAn Account You Cannot Get is a payment account that a lawful business is unable to obtain because the provider, acquirer, scheme or bank will not underwrite its refund, fraud, dispute, sanctions or regulatory risk.
- Activation QuantisationActivation quantisation is the conversion of a model’s intermediate tensors, not just its stored weights, into low-bit numeric formats during inference.
- Activation States & Re-engagementActivation states and re-engagement are a way to persist a user’s progress through onboarding as explicit fields on the user record, then use state changes and timers to decide when to contact them.
- Activation, and Why It Beats Acquisition VolumeActivation is the first behaviour or behaviour pattern showing that a new user has reached real product value and is therefore more likely to retain.
- Admin Panels & User OperationsAdmin panels and user operations are the internal control plane used by staff to find an account, inspect its state, and perform tightly scoped support actions.
- Agent WorkloadAgent workload is the serving pattern created when one user task becomes a long sequence of LLM calls over an ever-growing transcript, tool outputs, retrieved context, and state.
- Agents Acting on Behalf of UsersAgents acting on behalf of users are AI or automated actors with their own system identity and limited delegated authority from a user or organisation.
- Agents per MegawattAgents per Megawatt is a capacity metric for LLM agent serving that counts how many end-to-end agent sessions a power budget can sustain while meeting latency SLOs.
- Agents That Spend MoneyAgents that spend money are software agents authorised to make payments through a constrained delegation, not by receiving a user’s card, wallet seed, or full account credential.
- AI Support Agents & Human HandoffAI support agents with human handoff are customer-support systems that let a model handle routine conversations through a limited set of approved actions, while escalating uncertain, risky, or out-of-policy cases to a human operator.
- AI Visibility Tools: What a Score Is WorthAn AI visibility score is a sampled measurement of how often, where, and in what form an organisation appears in AI-generated answers under a tool’s chosen test conditions.
- Airflow DAG AuthoringAirflow DAG authoring is the practice of defining a scheduled workflow in Python for Apache Airflow: its tasks, dependencies, runtime settings, retry behaviour, and failure handling.
- AlertingAlerting is the production mechanism that turns selected telemetry into an interruption for a human operator when immediate action can reduce user-visible harm.
- Amdahl and the CeilingAmdahl and the Ceiling is the use of Amdahl’s Law to find the maximum possible speedup of a workload from its serial fraction.
- Amount Must Never Come From the BrowserAmount Must Never Come From the Browser is a checkout security rule: payment amount, price, plan, discounts and buyer identity must be derived on the server, not accepted from client request fields.
- Answer Engines, and Whose Index Each One UsesAnswer engines are AI search products that generate responses from retrieved web sources, usually by querying existing search indexes rather than crawling the web at question time.
- Answer-First Landing PageAn answer-first landing page is a landing page whose first visible section states the product category, intended audience, and promised outcome before persuasion or atmosphere.
- Apache Spark DataFramesApache Spark DataFrames are distributed, table-shaped datasets with named columns, where operations build a logical query plan that Spark optimises and executes across a cluster.
- Architecture of a User SystemArchitecture of a user system is the decomposition of user-related capabilities into explicit components: identity, authorisation, profile, notifications, and support.
- Arithmetic IntensityArithmetic intensity is the amount of computation a kernel performs per byte it moves across its limiting memory interface, usually expressed as FLOP per byte.
- Authentication Is Not AuthorizationAuthentication is proving which identity is making a request; authorization is deciding what that identity is allowed to do.
- Autoscaling and Cold StartsAutoscaling and cold starts are the capacity policy and startup delay involved in adding inference replicas under changing traffic.
- Autoscaling as a Control LoopAutoscaling as a control loop is the view of an autoscaler as a feedback system: it measures service behaviour, compares that measurement with a target, and changes capacity to reduce the gap.
- Availability Is MultiplicationAvailability is multiplication is the rule that a path requiring several components is available only when every required component is available, so their probabilities are multiplied only if those component events are independent.
B
- BackpressureBackpressure is a control mechanism that prevents fast producers from pushing more work into a system than slower consumers can finish.
- Benchmarking Your ServerBenchmarking your server is a controlled load test that measures how an inference server behaves under a specified request mix, concurrency limit, and cache state.
- BigQuery for Large-Scale AnalyticsBigQuery for large-scale analytics is the use of Google’s serverless columnar data warehouse to scan, filter, join, and aggregate very large datasets without managing storage or compute nodes.
- Brand Demand: The Asset That Survives the ClickBrand demand is the accumulated intent that makes people look for your company, product, or named idea specifically, rather than only for a generic problem.
- Budgets and circuit breakersBudgets and circuit breakers are run-scoped guardrails that prevent an agent or LLM workflow from exceeding allowed cost, time, calls, tokens, retries, or tool use.
- Build one, properlyBuilding one properly means shipping a narrow, production-ready agent as a bounded service: it accepts a defined request, uses explicit tools, runs a controlled loop, records its behaviour, and is evaluated against realistic cases before users rely on it.
C
- Cache ArithmeticCache arithmetic is the memory calculation for a transformer’s KV cache: key and value tensors saved for each processed token, layer, KV head, and head dimension.
- Cache-Aware RoutingCache-aware routing is a serving policy that sends an LLM request to the replica most likely to already hold valid KV cache blocks for its prompt prefix.
- Calibration and QualityCalibration and quality is the practice of choosing representative data to set quantisation ranges, scales, and clipping behaviour, then measuring how much the served model changes.
- Cascading FailureCascading failure is a distributed-system failure mode where one slow or broken component causes other, initially healthy components to fail by consuming shared capacity.
- CDNs and the EdgeCDNs and the edge are distributed proxy layers that terminate user traffic near the user, route it with anycast, and serve cached responses when a request matches a configured cache key.
- Change Data CaptureChange Data Capture is a data integration pattern that records row-level inserts, updates, and deletes from a source database and emits them to another system, usually a stream.
- Chargebacks & the Evidence That WinsChargebacks are card-network disputes in which an issuer reverses a card payment and the merchant must answer the specific reason code with rule-matching evidence.
- Chunked PrefillChunked prefill is an LLM serving scheduler technique that splits a long prompt’s prefill work into bounded token chunks, then batches those chunks alongside decode steps from other requests.
- Compaction without losing the threadCompaction without losing the thread is the practice of replacing a long agent interaction history with a smaller working state that still preserves intent, constraints, decisions, evidence, tool results, failures, and pending work, so the next model call can continue the task correctly rather than merely recall a vague summary.
- Connections Cost SomethingConnections Cost Something means a network connection’s throughput is limited not just by link bandwidth, but by how much data the protocol is allowed to keep in flight while waiting for acknowledgements.
- ConsensusConsensus is a protocol pattern that lets a group of replicas choose one ordered history of state changes despite crashes, message delays, and network partitions.
- ContainersA container is a process run with isolated Linux namespaces, cgroup resource controls, and a packaged root filesystem.
- Context BudgetA context budget is the maximum number of tokens an inference service can keep active for a model request or batch, limited mainly by KV cache memory and prompt prefill compute.
- Context CompactionContext compaction is a serving-time rewrite that replaces a long agent prompt with a shorter surrogate before the next model call.
- Context is the budgetContext is the budget means treating an LLM’s context window as a limited working-memory allowance shared by instructions, chat history, retrieved text, tool schemas, tool results, and the model’s reply.
- Context rotContext rot is the degradation in an LLM’s answers caused by adding too much surrounding text, especially irrelevant, stale, duplicated, or conflicting material.
- Continuous BatchingContinuous batching is an LLM serving policy that reschedules the active batch after every decode step, adding newly arrived requests and removing completed ones as tokens are generated.
- Contract Tests for PipelinesContract tests for pipelines are executable checks that verify a data producer still satisfies the agreed expectations of its consumers before a pipeline change is released.
- Core Web Vitals: LCP, INP and CLSCore Web Vitals are Google’s field metrics for page experience: LCP measures when the largest visible content finishes rendering, INP measures the worst typical delay from user input to the next visual update, and CLS measures unexpected layout movement.
- Correlated FailureCorrelated failure is a reliability failure mode where supposedly separate components stop working together because they share an underlying dependency, limit, operator action, or failure domain.
- Cost and Resource ManagementCost and resource management is the practice of modelling, measuring, and controlling the compute, storage, transfer, and orchestration resources consumed by a data pipeline.
- Cost Curves and CrossoversCost curves and crossovers are a way to compare deployment options by modelling how their costs change with traffic.
- cost of a committeeCost of a committee is the total overhead introduced by replacing one agent call with several coordinated agent calls.
- Cost per Million TokensCost per million tokens is the unit-economics measure that converts the cost of running an inference fleet into separate prices for input tokens and output tokens.
- Cost per Solved TaskCost per solved task is an inference metric that divides the cost of an attempt policy by the probability that the policy actually produces a correct result.
- Crawler: Frontier, Budget and PolitenessCrawler frontier, budget and politeness are the scheduling rules that decide which discovered URLs a search crawler fetches, how much crawling a site receives, and how gently requests are sent.
- Credentials an agent can reachCredentials an agent can reach are all secrets, tokens, keys, service identities, and delegated permissions available to the agent’s runtime, directly or through its tools.
- CTEs for Readable TransformationsCTEs for readable transformations are SQL common table expressions used to split one complex query into named, ordered intermediate results.
- Curve, CollectedThe collected curve is the recurring queueing shape where latency, backlog, and retry load grow like 1/(1-utilisation) as a shared resource approaches full use.
D
- Dagster Software-Defined AssetsDagster software-defined assets are data objects declared in code, with their dependencies, partitioning, metadata, and validation checks attached to the object rather than hidden inside a task sequence.
- Data Contracts and GovernanceData contracts and governance are the practice of treating datasets as owned, versioned interfaces with explicit rules for shape, freshness, quality, privacy, and downstream use.
- Data Curation for Foundation ModelsData curation for foundation models is the engineering process that turns raw document collections into training-ready datasets by filtering for quality, language, source, licence, safety, and domain relevance.
- Data Drift DetectionData drift detection is the monitoring of how production feature distributions differ from a selected reference dataset.
- Data Mesh and Domain OwnershipData mesh is an organisational architecture for data systems where business domains own and publish their own data as dependable data products.
- Data Platform Reference ArchitectureA data platform reference architecture is a shared blueprint for how data flows from operational sources into storage, transformation, machine learning datasets, serving paths, and monitoring.
- Data Quality DimensionsData quality dimensions are categories for turning vague data concerns into explicit, measurable checks.
- Databases Under LoadDatabases under load are database-backed systems where request rate, connection limits, and connection hold time determine capacity as much as query speed.
- Databricks and Unified AnalyticsDatabricks and unified analytics is a lakehouse platform pattern where data engineering, analytics, data science, and machine learning run against shared storage and execution infrastructure.
- Dataset Versioning PrinciplesDataset versioning principles are rules for making each data artefact in a machine learning pipeline uniquely identifiable, reproducible, and traceable.
- dbt Models for ML Transformationsdbt models for ML transformations are version-controlled SQL select statements that turn raw warehouse data into tested, documented staging, intermediate, and feature datasets.
- Decay, Refresh and ConsolidationDecay, refresh and consolidation is the SEO maintenance process for finding pages whose performance or usefulness is declining, then deciding whether to update them, merge them into a stronger page, or remove them.
- Decode-Heavy WorkloadA decode-heavy workload is an inference request where generated output is far longer than the input prompt, so latency and GPU traffic are dominated by repeated autoregressive decode steps.
- Deduplication and Contamination ControlDeduplication and contamination control are dataset hygiene practices for removing repeated training examples and preventing evaluation material from leaking into training.
- Defences that survive contactDefences that survive contact are prompt-injection mitigations that still work when an agent reads hostile text, because they reduce authority, constrain actions, or verify effects outside the model.
- Delivery, Retries & Provider FailuresDelivery, retries and provider failures are the reliability mechanics around sending work to an external service that may be slow, throttled or unavailable.
- Designing a tool the model can useDesigning a tool the model can use means exposing a code capability as a clear natural-language contract: what it does, when to call it, what arguments it accepts, and what it returns.
- Designing the First-Value JourneyDesigning the First-Value Journey is the practice of mapping the shortest path from account creation to the first moment a user gets the outcome they came for, then removing or delaying every step that does not help that moment happen sooner.
- DeterminismDeterminism in model inference is the property that the same input, model, and serving conditions produce the same output.
- Digital PR and the Earned MentionDigital PR is the practice of earning editorial coverage by giving publishers something genuinely worth citing, such as data, expert analysis, tools, or timely commentary.
- Directing & Auditing an Agent That Builds AuthDirecting and auditing an agent that builds auth is the practice of giving a coding agent an explicit security specification for identity, sessions, permissions, and recovery, then reviewing the generated system for failures that would let users impersonate, persist incorrectly, expose secrets, or access data they do not own.
- DisaggregationDisaggregation is an inference-serving architecture that runs prompt prefill and token decode on separate GPU pools.
- Discovery Operating SystemA Discovery Operating System is a repeatable team cadence for turning market, customer, and product uncertainty into decisions.
- Distributed Compute FundamentalsDistributed compute fundamentals are the core mechanics that let a batch engine split data into partitions, run tasks on executors, move records through shuffles, and manage memory, storage, network, and locality.
- DNSDNS is the distributed naming system that resolves hostnames such as `www.example.com` into records clients can use, most often IP addresses.
- Document Ingestion and ChunkingDocument ingestion and chunking is the pipeline step that turns raw files, pages, tickets, or wiki entries into cleaned text records, split into retrievable pieces with source metadata.
- Draft ModelsDraft models are cheap token proposers used in speculative decoding, where a fast approximation guesses several next tokens and the full target model verifies them in a single pass.
- Dunning, Cancellation & the EndDunning is the designed recovery flow that starts when a recurring renewal payment fails, while cancellation and access removal are separate lifecycle decisions.
- DVC for Data and PipelinesDVC for data and pipelines is a way to version datasets, derived artifacts, and preprocessing steps alongside Git-tracked code, while storing large files outside Git.
E
- E-E-A-T as Evidence, Not a CheckboxE-E-A-T as evidence, not a checkbox, is the practice of making experience, expertise, authoritativeness, and trust visible through verifiable artefacts on a page.
- EAGLE and MTPEAGLE and MTP are in-model speculative decoding methods that attach or train future-token predictors inside the main language model, so a serving engine can propose several continuations and verify them with the target model.
- Economics, and When to LeaveCloud cost economics is the discipline of deciding whether to optimise, migrate, or stay put by comparing real infrastructure savings with engineering labour, operational risk, downtime, and lost product work.
- Effort and BudgetsEffort and budgets are inference-time controls that limit how many hidden reasoning tokens a model may spend before producing its visible answer.
- Email, Push & In-AppEmail, push and in-app are communication channels with different delivery guarantees: email is persistent and user-controlled, push is interruptive and permission-dependent, and in-app is contextual to an active session.
- Embedding Pipeline DesignEmbedding pipeline design is the production design of the process that converts source records into searchable vectors, with controlled extraction, cleaning, chunking, batching, embedding, storage, metadata, retries, and updates.
- Embeddings and Vector SearchEmbeddings and vector search are a retrieval technique where data is converted into numerical vectors and searched by geometric closeness rather than exact terms.
- Embeddings: Matching a Page That Shares No WordsEmbeddings are numerical representations of text that place similar meanings near each other in vector space, allowing retrieval to match a query with a page even when they share no vocabulary.
- Entitlement State MachineAn entitlement state machine is a product-owned model of what a customer may access, independent of the billing event that caused it.
- Entity: Being One Thing EverywhereEntity resolution for a brand is the process of making public sources describe the same organisation with consistent names, URLs, profiles, categories and facts, so search systems and language models can recognise it as one stable thing rather than confuse, split or merge it.
- eval that blocks a deployAn eval that blocks a deploy is a CI gate that runs behavioural tests against an agent, prompt, tool setup, or model configuration and fails the release when agreed quality rules are not met.
- Every State a Payment Can Be InEvery state a payment can be in is the lifecycle model for a single payment attempt, from creation through submission, waiting, approval, settlement, failure, cancellation, refund, dispute, or retry.
- EvictionEviction is the rule an inference server uses to choose which KV-cache blocks to remove when GPU memory reserved for cached tokens is full.
- Experiment Tracking MetadataExperiment tracking metadata is the structured record attached to a machine learning run: its configuration, measured results, generated files, data snapshot, model identity, code revision, and runtime environment.
- Expert ParallelismExpert parallelism is a way to run sparse mixture-of-experts layers by placing different expert networks on different devices and routing each token to the devices that own its chosen experts.
- Exposing data as resourcesExposing data as resources is the MCP pattern of publishing read-only context behind stable URIs so an agent can discover and read it without treating the read as an action.
F
- failure modes a user actually seesFailure modes a user actually sees are the externally visible ways an AI agent breaks: looping without progress, failing when a tool or service errors, or returning a polished but false answer.
- Feast Feature Store WalkthroughA Feast feature store walkthrough is the practical path through modelling entities, data sources, feature views, and retrieval in Feast so the same feature definitions can produce point-in-time-correct training data and low-latency online features for inference.
- Feature Engineering LifecycleThe feature engineering lifecycle is the end-to-end management of a model feature from its semantic definition through computation, validation, serving, monitoring, and retirement.
- Feature Store Data ModelsFeature store data models are the schema concepts that describe machine-learning inputs: entities being described, feature views grouping related features, feature values at a time, timestamps defining validity, and online keys used to fetch values during inference.
- Field vs Lab: CrUX, RUM and LighthouseField versus lab performance measurement is the distinction between synthetic tests, such as Lighthouse, and real-user datasets, such as CrUX and RUM.
- Fine-Grained Authorization & ReBACFine-grained authorization decides whether a specific subject may perform a specific action on a specific object, often using relationships among users, groups, folders, documents, and organisations.
- FlashAttentionFlashAttention is an exact GPU attention algorithm that reduces high-bandwidth-memory traffic by computing attention in tiles, keeping score and probability blocks on chip instead of materialising the full quadratic attention matrix.
- Flink Stream ProcessingFlink stream processing is the use of Apache Flink to run continuous, stateful computations over unbounded event streams.
- FLOPs and BytesFLOPs and bytes are the two basic counts in performance accounting: how many floating-point operations a computation must perform, and how much data it must move.
- Forward Pass vs GenerationForward pass vs generation is the distinction between computing model outputs for many already-known token positions in parallel and producing text by repeatedly predicting, choosing, and appending one next token.
- Four AxesThe Four Axes are a way to evaluate a deployed system by separating reliability into availability, latency, durability and cost.
- FragmentationFragmentation is an allocator problem where memory is free in total but unusable for a request because it is scattered into incompatible gaps.
- Fraud, Card Testing & Risk RulesFraud, card testing and risk rules are the payment controls used to identify suspicious checkout attempts, especially attackers probing stolen cards, and decide whether to allow, block, review or add friction.
- From Data Warehouse to AI PlatformFrom data warehouse to AI platform describes the evolution from a SQL-centred system for governed business reporting into a layered data architecture that also supports raw data, streaming events, machine learning features, embeddings, model training, and low-latency AI applications, while keeping trusted warehouse data as a core source of truth.
- Function calling, concretelyFunction calling is a pattern where an application advertises specific callable operations to a language model, then treats the model’s response as a structured request to run one of them.
G
- Gateway, Processor or Merchant of RecordA gateway, processor, and merchant of record are three distinct roles often hidden behind the phrase payment provider: checkout connectivity, transaction processing, and legal seller.
- Generation LoopA generation loop is the autoregressive inference loop used by a language model to produce text: run a forward pass on the current tokens, turn the final-position logits into a next-token choice, append that token, and repeat until a stop token or length limit is reached.
- Goodput and SLOsGoodput is the rate of completed inference requests that satisfy the service-level objective, usually both time to first token and time per output token, rather than the raw token rate a server emits.
- Grading the trajectoryGrading the trajectory is evaluating the sequence of decisions an agent made during a run, not just its final output.
- Great Expectations ValidationGreat Expectations Validation is the use of Great Expectations suites to express data assumptions as executable checks against a dataset.
H
- Handoffs and routingHandoffs and routing are the orchestration mechanisms that decide which agent should own the next step of a request and transfer the necessary state to that agent.
- Health Checks and DrainingHealth checks and draining are the release mechanisms that tell infrastructure whether an instance may receive traffic, whether it should be restarted, and how to stop it safely.
- Hit RateHit rate is the share of prompt tokens for which a serving engine reuses already-built KV cache entries instead of running prefill again.
- Hockey StickA hockey stick is the sharp bend in a system’s latency curve as utilisation approaches saturation.
- Hosts, clients and serversHosts, clients and servers are the three protocol roles in MCP integrations: the host is the user-facing AI application, a client is its per-server connection component, and a server is the program exposing tools, resources or prompts.
- Human in the loop, where it countsHuman in the loop, where it counts, is a control pattern for agent systems that pauses automation only before actions with high cost, risk, or poor reversibility.
I
- Idempotency, or You Will Charge TwiceIdempotency is the property that repeating the same operation produces the same durable effect as doing it once.
- IDOR in Your APIIDOR in your API is an object-level authorisation bug where an endpoint accepts an identifier, loads the referenced record, and returns or changes it without checking that the caller may access that specific record.
- Images and ReproducibilityImages and reproducibility are the practice of building container images so the same declared inputs produce the same immutable artifact.
- Impersonation, Audit Logs & Privileged AccessImpersonation, audit logs and privileged access are the controls that let staff inspect or operate on a user’s account while preserving who really acted, what authority they had, and why.
- Incident ResponseIncident response is the organised process for detecting, coordinating, mitigating, and learning from a production failure.
- Incident Response for Data PipelinesIncident response for data pipelines is the operational process for handling broken, late, incomplete, or incorrect data from alert through containment, recovery, and communication.
- Incremental Batch ProcessingIncremental batch processing is a batch execution pattern that processes only source data that is new or changed since the last successful run, rather than recomputing the whole dataset.
- Index: Your Page Is Not Stored as a PageAn inverted index is the search engine data structure that maps tokens to the documents containing them.
- Instruction Tuning DatasetsInstruction tuning datasets are structured collections of prompts, optional context, target responses, task categories, and quality metadata used to teach a foundation model to respond to user requests.
- Intents, Authorization & CaptureIntents, authorization and capture are the payment model where a durable server-side intent represents one checkout’s attempt to collect money, while authorization approves the funds and capture actually takes them.
- InterconnectAn interconnect is the communication fabric that lets GPUs exchange activations, gradients, KV data, or collective results while running a model across more than one device.
- Invitations, SCIM & Enterprise LifecycleInvitations, SCIM and enterprise lifecycle are the account-management patterns that determine how users enter, change roles in, and leave a SaaS application.
K
- Keeping it working after the model changesKeeping it working after the model changes is the practice of treating an agent’s prompts, tools, routing logic, and model selection as versioned production behaviour, protected by evals.
- Knowing it broke before a user says soKnowing it broke before a user says so is production observability for agents that alerts on the run’s internal behaviour, not only its final response.
- KV Cache QuantisationKV cache quantisation is the practice of storing attention keys and values in a lower-precision format, such as FP8 or NVFP4, during LLM inference.
- KV Memory HierarchyA KV memory hierarchy is the serving-system design that keeps attention key-value cache across GPU HBM, host DRAM, local NVMe, and remote pooled storage, moving blocks between tiers so active tokens are near the GPU while idle but reusable conversation state does not consume scarce accelerator memory.
- KV Offload and ReloadKV offload and reload is a serving technique that moves a request’s transformer key-value cache out of accelerator memory to a slower memory tier, then copies it back if that prefix is needed again, avoiding prefill recomputation when moving the cached bytes is cheaper than rebuilding them.
L
- Label and Concept DriftLabel and concept drift are production data changes where either the outcome distribution moves, or the mapping from inputs to outcomes changes.
- Label Modeling and LeakageLabel modelling is the design of a training table that states the entity, prediction time, available history, future outcome window, and target value for each example.
- LakeFS for Data Lake BranchesLakeFS for data lake branches is a version-control pattern for object-storage data, where pipelines write changes to an isolated branch, validate that branch, then merge it into the production view.
- Lakehouse Architecture OverviewLakehouse architecture is a data platform design that keeps data in scalable object storage, adds table-format metadata for reliability, and lets different compute engines query or transform the same datasets.
- Latency multiplies in a loopLatency multiplies in a loop means an agent’s user-visible wait time grows with the sequential chain of model calls, tool calls, database queries, retries, and pauses it must complete.
- Launch OverheadLaunch overhead is the fixed CPU-side cost of asking the GPU to run a kernel before that kernel does useful work.
- Least Privilege and Blast RadiusLeast privilege is the practice of giving code, users, services, and web origins only the access they need, while blast radius is the damage possible when that access is abused.
- Least privilege, for a loopLeast privilege, for a loop is the practice of giving an agent only the permissions needed for its current observe, decide, tool-call cycle, rather than broad standing access.
- Ledger and the Monthly CloseA ledger is an append-only, double-entry record of money movements, and the monthly close is the reconciliation process that proves those records match processor reports and bank activity.
- Links as Votes: PageRank and What It BecameLinks as votes is the PageRank idea that a web page’s authority can be estimated from the directed graph of hyperlinks, where votes from already authoritative pages count more.
- Links: What PageRank Still BuysPageRank is the link-graph signal that treats links as weighted endorsements: pages gain authority when other authoritative pages link to them.
- Little's LawLittle's Law is the queueing relationship L = lambda x W: average in-flight work equals average throughput multiplied by average time in the system.
- LLM as judge, and its failure modesLLM as judge is an evaluation pattern where a language model scores, compares, or critiques another system’s output against a prompt, rubric, reference, or evidence.
- LLM Data LifecycleThe LLM data lifecycle is the engineered flow of datasets used to pretrain, adapt, test, ground, monitor, and improve a language model.
- LLM Evaluation Data ManagementLLM evaluation data management is the practice of versioning and governing the prompts, inputs, reference answers, rubrics, metadata, and leakage controls used to test an LLM application.
- LogitsLogits are the model’s raw, pre-softmax scores for every token in its vocabulary at a generation step.
- Long-Context PrefillLong-context prefill is the inference scheduling work needed to process a very large prompt before the first generated token, without letting that prompt block ongoing decode traffic.
- Long-Running ServersA long-running server is a persistent application process that stays alive to handle many requests over its lifetime.
- loop, not the model“Loop, not the model” is the idea that an AI agent is defined by the control loop around a language model: ask the model what to do next, execute a tool or action, feed the result back as context, and repeat until a stopping rule ends the run.
M
- Memory HierarchyMemory hierarchy is the layered storage path between a processor and its data, ordered from large and slow to small and fast.
- Memory that is not a vector databaseMemory that is not a vector database is agent state stored in forms chosen for the access pattern: scratchpads for working notes, files for durable artefacts, databases for structured source-of-truth records, and other stores where semantic similarity search is not the main operation.
- Memory WallThe memory wall is the point in long-context LLM inference where serving is limited more by KV-cache capacity and memory bandwidth than by arithmetic or model weights.
- Migrations Against Live TrafficMigrations against live traffic are schema or data changes performed while production requests continue and multiple application versions may be running.
- Milvus and Open-Source Vector SearchMilvus is an open-source vector database for storing embeddings and running nearest-neighbour search with metadata filters.
- Mixture of ExpertsA Mixture of Experts is a transformer design where each token is sent by a learned router to a small subset of feed-forward expert networks instead of through one dense feed-forward block.
- ML Observability DashboardsAn ML observability dashboard is a production monitoring view that shows whether a machine learning system is getting timely, valid inputs, returning plausible predictions, meeting service constraints, and still performing its task.
- Modeling for Multi-Tenant ProductsModeling for multi-tenant products is the design of database structures, keys, constraints, and access rules so one product can safely store data for many customers.
- Moving the KV CacheMoving the KV cache is the handoff of a request’s stored attention keys and values from a prefill worker to a decode worker in disaggregated LLM serving.
- Multi-Tenancy and LoRAMulti-tenancy with LoRA is a serving pattern where many tenant-specific fine-tunes share one loaded base model, while each request selects a small low-rank adapter that modifies selected layers.
N
- Never Store Money in a FloatNever store money in a float means representing monetary amounts with exact units, usually an integer count of the currency’s minor unit plus a currency code, rather than an approximate binary floating-point value.
- Normalization vs Denormalization for MLNormalization for ML stores entities and facts once, linked by keys, while denormalization materialises joined feature values into wider training-ready records.
- Notification SystemA notification system is the product infrastructure that turns domain events into messages delivered through channels such as email, push, SMS, Slack, or in-app feeds.
- Number FormatsNumber formats are the bit-level encodings used to store and compute tensor values, such as BF16, FP8, INT8, INT4, MXFP4, and NVFP4.
O
- Off-Site Graph: Reddit, YouTube and WikipediaThe off-site graph is the set of third-party pages, communities, media, references and databases that answer engines use to corroborate entities and claims beyond a company’s own site.
- Offline vs Online FeaturesOffline versus online features is the design choice of when and where model inputs are computed: ahead of time from historical data, at serving time from current state, on demand from the request, or through a batch-stream combination that preserves training correctness while keeping recent values fresh.
- One Request at a TimeOne Request at a Time is the batch size 1 decode regime in LLM serving, where a GPU applies the model’s weight matrices to a single token position.
- Online Serving and Low-Latency AccessOnline serving and low-latency access is the production read path that supplies feature values to a model during a live request.
- OrchestrationOrchestration is the control layer that runs containers across a pool of machines by deciding placement, keeping declared replicas alive, routing traffic, and changing versions safely.
- Orchestration for ML TrainingOrchestration for ML training is the coordination of data preparation, training, evaluation, and model registration as a dependency-aware workflow rather than separate manual runs.
- Orchestrator and workersOrchestrator and workers is a control pattern where a parent agent decomposes a run into identifiable child tasks, runs them independently, then joins their outputs with explicit success and failure accounting.
- Original Research and Proprietary DataOriginal research and proprietary data is content built from measurements only your organisation can access, such as usage, support, pricing, operational, survey, or benchmark data.
- OWASP LLM Top 10, against your agentThe OWASP LLM Top 10 is a security review checklist for applications built around language models, including agents that read untrusted text, call tools, store memory, and affect external systems.
P
- Packaging it for other peoplePackaging an MCP server is the work of turning it into an installable, executable artefact with stable commands, metadata, configuration examples, and public primitive names.
- Page That Answers FirstA Page That Answers First is a page structure that puts the user’s main question and its direct answer at the top, then expands with context, proof, edge cases, and examples.
- Paged AttentionPaged Attention is a KV-cache memory layout for LLM serving that stores each request’s cached keys and values in fixed-size blocks and uses a per-request block table to translate logical sequence positions into physical memory blocks, so attention can read a continuous context while the allocator reuses scattered GPU memory.
- Parallel SamplingParallel sampling is an inference technique that generates several independent continuations from the same prompt state, then selects or combines them.
- Parquet and Columnar StorageParquet is a columnar file format for analytical data, storing values from the same field together with metadata that lets engines read, decompress, and filter only the parts relevant to a query or feature load.
- Passkeys & Phishing-Resistant AuthPasskeys are phishing-resistant login credentials based on public-key cryptography, usually implemented with WebAuthn.
- Passwords, OTP & Magic LinksPasswords, OTPs and magic links are login methods that prove a user controls an identity by checking either a remembered secret, a temporary emailed code, or a short-lived signed URL.
- Payment Code Your Agent WrotePayment code your agent wrote is AI-generated payment integration code that appears correct at the provider SDK call but is unsafe around the application handler.
- Payouts, Reserves & the Float You Are HoldingPayouts, reserves and float are the ledger controls a platform uses to decide when user money is payable, what portion is held back for risk, and whether the balances owed to users are actually backed by the bank or processor account holding the funds.
- Permissions as SetsPermissions as sets is a way to model authorisation as bounded membership: a user, origin, action, and resource are either inside or outside the allowed set.
- pgvector in Postgrespgvector in Postgres is an extension that adds an embedding-friendly vector column type, distance operators, and indexing options to PostgreSQL.
- Pinecone Managed Vector SearchPinecone Managed Vector Search is a hosted vector database service for storing embeddings, indexing them for approximate similarity search, and returning nearby records with IDs, scores, and metadata.
- Pipeline Design PatternsPipeline design patterns are reusable orchestration structures for splitting, joining, isolating, staging, and resuming data work.
- Pipeline ParallelismPipeline parallelism is a way to run one neural network across multiple devices by assigning different contiguous layers to different stages.
- Plan, then executePlan, then execute is an agent design pattern where a model first creates an ordered task plan, then a separate loop carries out each step, observes results, and decides whether to continue, revise, or stop.
- Point-in-Time Correct JoinsPoint-in-time correct joins are joins that attach historical feature values to a training example only if those values were available at the prediction time.
- Point-in-Time Feature RetrievalPoint-in-time feature retrieval is the construction of training rows by joining each labelled event to only the feature values that were available before that event.
- PrecisionPrecision is the numeric format used to represent model weights, activations, KV cache entries, and accumulators during inference.
- Prefect Flows and DeploymentsPrefect flows and deployments are Prefect’s way of turning Python workflow code into managed, observable pipeline runs.
- Preferences, Frequency & StatePreferences, frequency and state is the practice of modelling notification choices as durable user data that the delivery system consults before sending.
- Prefill & DecodePrefill and decode are the two execution stages of autoregressive LLM serving: prefill ingests the whole prompt to initialise attention state, then decode extends the sequence one token at a time.
- Prefill/Decode InterferencePrefill/decode interference is the throughput and latency loss caused when prompt processing and token-by-token generation share the same GPU scheduling path.
- Prefix CachingPrefix caching is an inference optimisation that reuses the KV cache for an identical prompt prefix instead of recomputing it.
- Privacy, Data Export & DeletionPrivacy, data export and deletion is the engineering discipline of finding, packaging, removing, anonymising or retaining all personal data connected to a user across a product’s systems.
- Problem, StatedThe stated deployment problem is the engineering problem of changing a live system from S0 to S1 without losing, corrupting, or misrouting work the system has already accepted.
- Processes and SchedulingProcesses and scheduling are the operating system mechanisms that turn running programs into isolated, manageable units and decide when each one gets CPU time.
- Product-Led Sales and ExpansionProduct-led sales and expansion is a go-to-market motion where sales and success teams act on evidence from product usage, not just forms or cold prospecting.
- Profiles, Preferences & User DataProfiles, preferences and user data are separate categories inside a user system: identity proves account ownership, profile describes the user in the product, and preferences customise behaviour.
- Profiling a Forward PassProfiling a forward pass is recording the CPU work, CUDA calls, GPU kernels, and memory movement that occur while a model computes outputs from inputs.
- Progressive Onboarding & InvitationsProgressive onboarding and invitations is an onboarding design pattern that asks users only for the information needed for their next meaningful step, while treating invited users as joining an existing organisation rather than creating a new one.
- Prompt cachingPrompt caching is a provider-side optimisation where repeated leading tokens in LLM requests are processed once and reused on later calls.
- Prompt injection when the agent can actPrompt injection when the agent can act is an attack where untrusted text read by a model changes a later tool call or external action.
Q
R
- RadixAttentionRadixAttention is SGLang’s prefix-cache design for LLM inference, storing KV-cache references in a compressed radix tree keyed by token sequences.
- RAG Evaluation and Retrieval QualityRAG evaluation and retrieval quality is the measurement of whether a retrieval-augmented generation system finds the evidence needed to answer a query, ranks it usefully, and produces answers supported by that evidence.
- Ray for Data and ML WorkloadsRay for data and ML workloads is the use of Ray’s distributed Python runtime, especially Ray Data and Ray Train, to run preprocessing, batching, and training across a cluster.
- Recurring in IndiaRecurring in India is the RBI-regulated way to take repeat debits from cards, wallets or UPI using a registered mandate, advance notice and amount-based authentication rules.
- Referral and Viral LoopsReferral and viral loops are acquisition systems where current users expose new people to a product, some of those people become qualified users, and some later repeat the same behaviour.
- Refunds, and What They Do Not UnwindA refund is a payment-rail operation that sends captured money back to the payer, in full or in part, while leaving the original payment record and most business state intact.
- Release ProblemThe release problem is the coordination problem of changing software that is already serving users.
- Rendering: How an SPA Goes InvisibleRendering an SPA for SEO is the process by which a crawler moves from the server’s initial HTML to a JavaScript-produced DOM, if it can.
- Replication and ConsistencyReplication and consistency describe how a system keeps the same data on several machines, and what a read is allowed to return while those copies catch up.
- Reproducibility Problem in MLThe reproducibility problem in ML is the difficulty of recreating a model run with the same inputs, behaviour, and results after the fact.
- Reproducible Training SplitsReproducible training splits are deterministic rules for assigning records to train, validation, and test sets so the same examples keep the same role across reruns, machines, and dataset rebuilds.
- Reproducing a bad runReproducing a bad run is the practice of replaying a failed agent or LLM workflow with enough captured context that the same wrong behaviour appears again.
- Rerankers: How a Passage Becomes a CitationA reranker is a second-stage relevance model that rescales a small set of retrieved passages by comparing each passage directly with the user’s query.
- Retention and the Shape of a Good Cohort CurveRetention and the shape of a good cohort curve describe whether users who start using a product in the same period keep returning over time.
- Retry StormsA retry storm is a failure mode where many clients repeat requests to the same unhealthy dependency at nearly the same time, adding load precisely when it has least capacity.
- RLHF and Preference Data PipelinesRLHF and preference data pipelines are data systems that convert human judgements about model outputs into auditable datasets for reward-model training and alignment.
- Rollback Beats Forward-FixRollback beats forward-fix is the reliability principle that, during a bad release, restoring the last known-good version is usually safer and faster than repairing production in place.
- Rolling it out without a big bangRolling it out without a big bang is a release strategy where a new agent version reaches a small, controlled slice of production traffic before broader exposure.
- Rollouts Are InferenceRollouts are inference means that reinforcement-learning post-training spends much of its time using the current policy as a serving model to generate sampled completions.
- RooflineA roofline is a performance model and plot that bounds a kernel by the lesser of the machine’s compute peak and its memory-bandwidth-limited throughput.
- Routing RequestsRouting requests is the fleet-level policy that chooses which model replica should handle an inference request, using session affinity, prefix matches, queue state, and KV-cache residency instead of treating workers as identical.
S
- SamplingSampling is the step in text generation that turns a model’s next-token logits into the actual next token.
- Sampling and TailsSampling and tails are the discipline of describing reliability data with an explicit probability model, then asking how often extreme events occur.
- Sandboxing what it runsSandboxing what it runs is isolating model-authored or model-selected code inside a restricted execution environment instead of letting it run on your machine or service.
- Scaled Content Abuse: Where the Line IsScaled content abuse is the practice of publishing large volumes of low-value pages, made by AI, humans, automation, or any mixture of them, chiefly to win search traffic rather than help users.
- Scaling AxesScaling axes are the choices a system makes about how to spread traffic across replicas, usually through a load-balancing algorithm.
- Scheduler LoopA scheduler loop is the repeated admission-control cycle in an LLM serving engine that decides which waiting prompts and active decodes become the next GPU forward pass.
- Schema Registry and Event ContractsA schema registry is a central service that stores versioned definitions of event payloads and enforces rules for how those definitions may change.
- Scoping what it is allowed to doScoping what an agent is allowed to do is the practice of defining its permitted resources, actions, environments, users, and approval boundaries, then enforcing those limits in application code.
- Scoring Text: TF-IDF and BM25TF-IDF and BM25 are lexical ranking formulas that score how well a document matches a query by combining term occurrence, term rarity, repetition limits, and document length.
- Search Console, HonestlySearch Console is Google’s reporting interface for how your site appears and receives clicks in Google Search surfaces.
- Security Boundaries & Failure ModesSecurity boundaries and failure modes are the points where a system must decide whether an actor is allowed to perform an action, and the ways that decision can be bypassed or made incorrectly.
- Self-Host or APISelf-host or API is the production inference decision between running your own model-serving fleet and calling a hosted provider.
- Selling From IndiaSelling From India is the payment and compliance problem of collecting money from foreign customers into an Indian entity through a legally valid rail.
- Selling to the WorldSelling to the World is the payment setup where a customer can see and pay in one currency while the merchant reports, accounts for, and receives funds in another.
- Serverless InternalsServerless internals are the platform mechanisms that allocate isolated compute, start a language runtime, load user code, run initialisation, and dispatch an event to a handler.
- Serving StackA serving stack is the production path that accepts model requests, queues them, schedules batched generation work, runs the model, manages KV cache memory, and streams tokens back.
- Serving Two ModelsServing two models is co-locating a primary model and an auxiliary model on the same accelerator, while explicitly dividing memory, KV cache, and scheduler priority between them.
- Session AffinitySession affinity is a serving policy that keeps the turns of an interactive model session on the same worker, or on a worker that already has its reusable prefix state.
- Sessions, Cookies & Stolen TokensSessions are the mechanism that lets a server remember a logged-in user across later HTTP requests, usually by accepting a browser-sent cookie or token as evidence of an existing login.
- Signup Is Not ActivationSignup is not activation means account creation is separate from the first observable action that shows a user has reached product value.
- SLOs for ThinkingSLOs for Thinking are latency objectives for models that generate hidden reasoning before producing user-visible output.
- Slowly Changing DimensionsSlowly Changing Dimensions are dimension-table patterns for representing attributes that change over time, either by replacing the old value or by keeping dated versions.
- Snowflake for ML DataSnowflake for ML data is the use of Snowflake as the structured warehouse layer where raw records are loaded, cleaned, transformed, and published as reproducible training datasets.
- Spark Performance TuningSpark performance tuning is the practice of making a Spark application spend less time moving, recomputing, spilling, and waiting on data.
- Speculative DecodingSpeculative decoding is an LLM inference technique where a cheap draft model proposes k future tokens, the target model scores those proposed positions in one causal forward pass, and a rejection-sampling accept or repair step preserves the exact output distribution of normal target-model sampling.
- Speed of Light Is a FloorSpeed of Light Is a Floor is the irreducible lower bound on network latency caused by physical distance: bits are carried by electromagnetic signals, and those signals cannot outrun light.
- Splits, Commissions & Seller KYCSplits, commissions and seller KYC are the marketplace payment controls that allocate a buyer’s payment between seller earnings, platform revenue and processor fees, while preventing payouts to sellers whose identity, business details, bank account or sanctions status have not been verified as required.
- SQL for Training DatasetsSQL for training datasets is the practice of writing queries that turn raw relational data into model-ready examples: entity identifiers, event timestamps, feature columns, and labels.
- SQL Testing and AssertionsSQL testing and assertions are executable checks, written as SQL queries, that verify a table still satisfies assumptions about keys, missingness, allowed categories, recency, and target behaviour.
- Stacking the WinsStacking the Wins is the practice of combining inference optimisations such as quantisation, KV-cache reuse and speculative decoding, then benchmarking the combined serving system instead of multiplying separate speedup claims.
- Star Schemas for Analytics and MLA star schema is an analytical data model with a central fact table for measured events and surrounding dimension tables for descriptive context.
- Static and EdgeStatic and edge deployment is the split between prebuilt, cacheable output and small request-time code that runs near the user.
- Static BatchingStatic batching is request-level batching where an inference server groups a fixed cohort of prompts, runs prefill for that cohort, then decodes every member in lockstep until the slowest request finishes.
- StoppingStopping is the set of checks an autoregressive inference engine applies after each generated token to decide that a response is complete.
- Stopping, and the loop that will notStopping is the control logic that makes an agent loop terminate instead of repeatedly calling the model and tools forever.
- Strategies ComparedRelease strategies compared means evaluating rolling, blue-green and canary deployments by how they move traffic to new code, how quickly they can undo a bad release, how much extra capacity they need, and how many users are exposed before confidence grows.
- Streaming Features for MLStreaming features for ML are feature values maintained continuously from incoming events, keyed by an entity such as a user, account, device, product, or session.
- Streaming System ConceptsStreaming system concepts are the shared vocabulary for processing unbounded data as it arrives: events, topics, partitions, offsets, time models, watermarks, and consistency guarantees.
- Structured OutputStructured output is generation constrained to a machine-readable shape, usually by masking the model’s next-token probabilities against a schema or grammar during decoding.
- Subagents and context isolationSubagents and context isolation is the pattern of delegating a bounded, noisy piece of work to a separate agent invocation with its own working context, then returning only a compact result to the main agent.
- Subtasks and checkpointsSubtasks and checkpoints are a workflow pattern for agent systems where a long goal is split into recoverable units, and useful state is saved between them.
- Synthetic Data Generation PipelinesA synthetic data generation pipeline is a repeatable workflow that uses models to create structured training, evaluation, or test records, then validates and records their lineage.
T
- Tax You Stop OwingTax you stop owing is the consumption-tax work a merchant of record takes over when it becomes the legal seller for a transaction.
- Teams, Organizations & Multi-TenancyTeams, organisations and multi-tenancy are the design patterns for representing customer groups in a SaaS product and isolating their users, data and resources.
- Tecton and Managed Feature PlatformsTecton is a managed feature platform: a service layer for defining, running, serving, monitoring, and governing machine learning features across training and production.
- Tensor ParallelismTensor parallelism is a way to run one neural network layer across multiple accelerators by splitting its weight matrices and having each device compute part of the same matrix multiplication.
- Test Mode Is a Different PlanetTest mode is a separate payment-provider environment that mimics the checkout flow without moving real money.
- Test-Time ComputeTest-time compute is extra computation spent while a model is answering, rather than while it is being trained.
- Testing a server without an agentTesting a server without an agent is the practice of exercising an MCP server through its protocol interface using controlled requests, before any language model or agent is involved.
- Thinking out loud, on purposeThinking out loud, on purpose is the practice of asking a model to write a scratchpad of assumptions, subproblems, options, checks, and tentative conclusions before it gives an answer or takes an action.
- Throughput vs LatencyThroughput is the total rate at which a serving system produces work, while latency is the time an individual request waits or takes to complete.
- TLSTLS is the protocol that turns a plain network connection into an authenticated, encrypted, tamper-detecting channel.
- Tokenisation at Serving TimeTokenisation at serving time is the conversion of incoming request text into the exact token IDs a model consumes before inference starts.
- Tokenization and Dataset PackingTokenization and dataset packing is the data-preparation stage that converts raw text into model vocabulary IDs, measures how long records become, and arranges those IDs into fixed-length training sequences.
- Too many toolsToo many tools is the failure mode where an agent is given a larger tool list than the current task can reliably justify, so the model’s tool selection becomes noisy.
- Tool Calls in the LoopTool calls in the loop are pauses in an agent inference request where the model has emitted a structured external call, the application is waiting for that call to return, and the request is doing no prefill or decode work while its accumulated KV cache may still occupy accelerator memory.
- Tool Schema TaxTool Schema Tax is the extra inference work caused by including tool or function definitions in an LLM prompt before the model has called any tool.
- Tooling Landscape for ML EngineersThe tooling landscape for ML engineers is the set of specialised data, orchestration, transformation, feature, vector, and model-lifecycle systems used to move raw events into reliable datasets, model inputs, retrieval indexes, experiments, and deployable artefacts.
- Tools, resources and promptsTools, resources and prompts are the main MCP primitives for exposing agent capabilities as actions, readable context, and reusable interaction templates.
- Topic Clusters and the Entity Behind the WordsTopic clusters are a site architecture pattern that organises pages around a real subject and its underlying entity, not around repeated keyword phrasings.
- Tracing a runTracing a run is recording an agent execution as a structured tree of related steps, including inputs, outputs, tool calls, model calls, timings, errors, and metadata.
- Training and Serving Data LineageTraining and serving data lineage is the recorded chain connecting a model output to the data, feature definitions, transformations, code, model artifact, and deployment that produced it.
- Transactional vs MarketingTransactional vs marketing email is the separation between product-critical messages a user needs to receive, such as password resets or receipts, and promotional messages intended to influence behaviour.
- Transports: stdio and HTTPTransports, in MCP, are the communication mechanisms that carry protocol messages between a client and a server.
- Trust BoundaryA trust boundary is the line between code and data an attacker can inspect or control, and code and data protected by your infrastructure.
- Two Ways to Go FasterTwo Ways to Go Faster is a framing for LLM inference optimisation: during autoregressive decode, speed usually improves by reading fewer bytes per generated token or by needing fewer target-model steps per generated token.
U
- Unpredictable Output LengthUnpredictable output length is a serving failure mode where an inference scheduler admits work using an expected generation length, but actual requests produce much shorter or much longer continuations.
- Usage Billing, Credits & OveragesUsage billing, credits and overages is the billing pattern that records customer consumption, rates it against a subscription plan, applies prepaid or granted credit balances, and invoices any remaining charge.
- User Lifecycle State MachineA user lifecycle state machine is an explicit model of the account states a person can occupy and the allowed transitions between them, with required security side effects for each transition.
- Using a smaller model where it is enoughUsing a smaller model where it is enough means routing easy or low-risk AI workflow steps to cheaper, faster models, rules, or cached results, while reserving the strongest model for hard reasoning, ambiguity, or final synthesis.
V
- Validating what comes backValidating what comes back is the practice of treating model-generated tool arguments as untrusted input, then checking shape, type, permissions, and business rules before any function runs.
- Verification & Account RecoveryVerification and account recovery is the set of alternate authentication flows used when a user cannot present their normal proof, such as a password or MFA factor.
- Verifiers in the Serving PathA verifier in the serving path is a second inference model that scores answers or intermediate reasoning steps produced by the main model before a response is returned.
- Virtual MachinesA virtual machine is a complete guest computer, including its own operating system kernel, running on virtual hardware supplied by a hypervisor.
W
- Warehouse vs Lakehouse TradeoffsWarehouse vs lakehouse tradeoffs are the architectural choices between managed, optimised SQL platforms and open object-storage-based data platforms.
- Webhook Is the Only Thing That Knows“Webhook is the only thing that knows” is a payment architecture rule: grant paid access only from a verified provider-to-server webhook event, not from a browser redirect.
- Weight-Only QuantisationWeight-only quantisation stores a model’s weights in lower precision, typically INT8 or INT4, while leaving activations and most intermediate values in FP16 or BF16.
- Who Says No, and WhyWho Says No, and Why is the card-payment authorisation model that identifies each party in the transaction path and separates routing from decision-making.
- Window Functions for FeaturesWindow functions for features are SQL expressions that compute per-example values from neighbouring or related rows without collapsing the result set.
- Workflow Orchestration FundamentalsWorkflow orchestration is the coordination of pipeline tasks so data work runs in the correct order, at the intended time, and with observable outcomes.