The AI interview glossary

230 terms an AI, ML or GenAI interviewer will use without stopping to define. Each one gets a single sentence here, which is usually all you need mid-conversation, and a link to the page that teaches the mechanism properly. If you are reading this the night before a loop, skim the track that matches your round and follow only the links where the one-liner did not land.

Grounded in real GenAI, LLM, and AI/ML engineering interview loops and written to a senior-engineer editorial bar.

43 TERMS

Foundations of LLMs & GenAI

Alignment: Outer, Inner, and Scalable Oversightalso: outer alignment, inner alignment, reward hacking, Goodhart's law: Alignment is getting a system to pursue what we actually want rather than what we literally specified.
Attention Variants: MHA, MQA, and GQAalso: MHA, MQA, GQA, multi-query attention: Multi-head attention gives every query head its own key and value heads, which is expressive but leaves the KV cache large and memory-bandwidth hungry at decode time.
Attention and Self-Attentionalso: attention, self-attention, multi-head attention, query key value: Attention casts each token as a query, key, and value, scores every query against every key, softmaxes those scores into weights, and returns the weighted sum of values, so each token draws information from the others.
Causal Masking and Teacher Forcingalso: causal mask, attention mask, teacher forcing, causal attention: A causal mask adds a triangular block of large negative values to the attention scores before the softmax, so every position gets exactly zero attention weight on the future.
Chain-of-Thought and In-Context Learningalso: chain-of-thought, chain of thought, in-context learning, few-shot learning: In-context learning is the ability to perform a task from instructions or a few examples in the prompt, with no weight updates.
Classic NLP: Bag-of-Words, TF-IDF, and Word2Vecalso: bag-of-words, BoW, TF-IDF, word2vec: Before learned embeddings, text became sparse high-dimensional vectors through bag-of-words and TF-IDF, which tally words and weight them by distinctiveness while ignoring meaning and order.
Constitutional AI and RLAIFalso: Constitutional AI, RLAIF, RL from AI feedback, AI feedback: RLAIF (RL from AI Feedback) swaps human preference labels for AI-generated ones, pushing alignment past the human-labeling bottleneck.
Constrained and Structured Decodingalso: constrained decoding, structured decoding, JSON mode, constrained generation: Asking a model nicely for JSON sometimes fails; constrained decoding guarantees valid output by masking, at each generation step, every token that would break a schema or grammar, so only valid continuations can be sampled.
Context Compression and Prompt Compactionalso: context compression, prompt compression, prompt compaction, LLMLingua: When a prompt is too big, compression is the last lever you should reach for, not the first.
Context Rot and Long-Context Failure Modesalso: context rot, lost in the middle, long context degradation, attention sink: Context rot is the practical degradation of model quality as the input window fills up, even when the official window is a million tokens.
DPO and Preference-Optimization Variantsalso: DPO, direct preference optimization, SimPO, KTO: Direct Preference Optimization aligns a model straight from preference pairs with a simple classification-style loss, bypassing RLHF's separate reward model and RL loop, which makes alignment far simpler and more stable.
Diffusion Control and Fast Samplingalso: ControlNet, IP-Adapter, classifier-free guidance, CFG: A text prompt is a weak handle on an image model.
Diffusion Modelsalso: diffusion, diffusion model, latent diffusion, denoising: Diffusion models generate images (and audio/video) by learning to reverse a noising process: training corrupts data into noise step by step, and the model learns to denoise, so at generation it begins from pure noise and iteratively denoises into a sample.
Embeddingsalso: embedding, vector representation, dense vector, semantic similarity: An embedding maps text (or an image) to a dense vector so that semantic similarity turns into geometric closeness, similar meanings land near each other, measured by cosine similarity.
Fine-Tuning Hyperparameters and Overfittingalso: fine-tuning hyperparameters, lora_alpha, LoRA rank, learning rate for fine-tuning: Choosing to fine-tune is the easy part.
Foundation Models and the Pretrain-Adapt Paradigmalso: foundation model, pretrain-adapt, general purpose model, base model: A foundation model is a single large model pretrained on broad data and then adapted to many tasks, replacing the old habit of training one bespoke model per task.
From RNNs to Transformers: RNN, LSTM, Seq2Seqalso: RNN, LSTM, GRU, seq2seq: Recurrent networks walk through a sequence one position at a time via a hidden state, an approach that is principled but slow and weak on long-range dependencies because gradients shrink across many steps.
Hallucinationalso: hallucinations, grounding, faithfulness, confabulation: A hallucination is fluent, confident output that is wrong or unsupported.
Inference-Time Compute and Reasoning Modelsalso: inference-time compute, test-time compute, reasoning models, thinking models: Inference-time (test-time) compute is the idea that spending more computation at generation, longer chains of thought, sampling multiple attempts, or search, reliably improves answers on hard problems, a scaling axis distinct from making the model bigger.
LoRA and Parameter-Efficient Fine-Tuningalso: LoRA, PEFT, parameter-efficient fine-tuning, QLoRA: Full fine-tuning updates all of a model's weights, costly in compute and memory and leaving a full-size copy per task.
Logits, Log-Probs, and Logit Biasalso: logits, log probs, logprobs, logit bias: The output layer of an LLM is an API surface, not just an implementation detail.
Mixture-of-Expertsalso: MoE, sparse model, expert routing: A Mixture-of-Experts model swaps the dense feed-forward layer for many expert networks plus a router that sends each token to only a few of them.
Multilingual Models and the Tokenization Taxalso: multilingual models, multilingual, low-resource languages, tokenization tax: Multilingual LLMs perform unevenly: best on high-resource languages (English), worse on low-resource ones, because training data is English-heavy.
Multimodal Fusion Architecturesalso: multimodal fusion, late fusion, early fusion, dual encoder: There are four ways to get an image into a language model, and they differ by how late the modalities meet: dual encoders (CLIP), cross-attention resamplers (Flamingo, Q-Former), projectors that turn patches into tokens (LLaVA), and natively multimodal pretraining.
Multimodal Models and VLMsalso: multimodal, VLM, vision-language model, CLIP: Multimodal models handle more than text, most commonly vision-language models (VLMs) that take images and text together.
Normalization in Transformers: LayerNorm, RMSNorm, Pre-Norm and Post-Normalso: LayerNorm, RMSNorm, layer normalization, pre-norm vs post-norm: Normalization keeps activations in a range where a deep stack can actually train.
Policy Optimization: PPO and GRPOalso: PPO, GRPO, policy optimization, proximal policy optimization: PPO and GRPO are the reinforcement-learning algorithms that optimize an LLM against a reward, the RL step in RLHF and in training reasoning models.
Positional Encodings (RoPE and ALiBi)also: positional encoding, RoPE, rotary position embedding, ALiBi: Attention is order-blind, so models inject token position separately.
Prompt Engineeringalso: prompting, prompt template, system prompt, few-shot: Prompting is the cheapest, fastest way to steer an LLM: clear instructions, few-shot examples, explicit output format, and the right context.
Prompting vs RAG vs Fine-Tuningalso: RAG vs fine-tuning, prompting vs fine-tuning, when to fine-tune, when to use RAG: Given an LLM use case, the senior move is matching the technique to what is missing rather than defaulting to one.
RLHF: Reinforcement Learning from Human Feedbackalso: RLHF, reinforcement learning from human feedback, alignment, instruction tuning: RLHF is how a raw next-token predictor turns into a helpful, harmless assistant.
Reward Modelsalso: reward model, preference model: A reward model converts human preference comparisons into a scalar score for any response, the very signal RLHF chases.
Scaling Lawsalso: Chinchilla, compute-optimal, neural scaling laws: Scaling laws say model loss drops predictably as a power law in parameters, data, and compute, which is why bigger models trained on more data reliably improve.
Self-Consistency, Tree-of-Thought, and Prompt Chainingalso: self-consistency, tree of thought, ToT, prompt chaining: Three ways to move past a single linear chain of thought: self-consistency samples many reasoning paths and votes on the answer, tree-of-thought branches and searches over partial reasoning, and prompt chaining splits one hard prompt into a sequence of focused calls.
Small vs Large Models and Routingalso: small vs large models, model routing, small language models, model cascade: Bigger is not always better in production: small models are far cheaper and faster, and for many tasks they are good enough, especially when fine-tuned or given retrieval.
Speech and Voice AI: ASR, TTS, and Voice Agentsalso: ASR, TTS, speech recognition, text to speech: Voice agents chain three systems: speech-to-text (ASR), an LLM, and text-to-speech (TTS), all under a hard real-time latency budget that text chat never faces.
Temperature and Samplingalso: temperature, sampling, top-p, nucleus sampling: At each step a model outputs a probability distribution over the next token; how you pick from it is decoding.
The Context Windowalso: context window, context length, long context, lost in the middle: The context window is the largest number of tokens a model can attend to at once, prompt plus generation.
The KV Cachealso: KV cache, KV-cache, key-value cache: In autoregressive decoding a model would recompute attention over the whole history at every step; the KV cache keeps each token's key and value vectors so a new token only attends and never recomputes.
The Transformer Architecturealso: transformer, transformer architecture, feed-forward network, FFN: The transformer is the architecture behind modern LLMs: stacked blocks that each mix information across tokens with self-attention and then transform each token with a feed-forward network, wrapped in residual connections and normalization.
Tokenizationalso: tokenizer, tokens, BPE, byte pair encoding: Models read neither characters nor words; they read tokens, subword chunks produced by an algorithm like BPE that maps text to integer IDs.
Training Reasoning Models: RLVR, PRM vs ORMalso: RLVR, GRPO, process reward model, PRM: Reasoning models like o1 and R1 are more than bigger instruct models: they are trained with reinforcement learning where the reward comes from checking whether the final answer is correct, which teaches the model to generate long internal chains of thought.
What an LLM Is: Next-Token Prediction and the Training Pipelinealso: large language model, LLM, what is an LLM, autoregressive model: An LLM is a function that maps a sequence of tokens to a probability distribution over the next token, called in a loop.

23 TERMS

Retrieval & Agents

Agent Design Patterns: ReAct, Plan-and-Execute, Reflectionalso: ReAct, plan and execute, plan-and-execute, reflection agent: These are the named control-flow architectures for LLM agents: ReAct interleaves reasoning and actions in a tight loop, plan-and-execute breaks the task down up front and then runs the steps, and reflection adds a self-critique pass that revises output.
Agent Evaluation and Trajectory Analysisalso: agent eval, trajectory evaluation, trajectory analysis, agent trajectory eval: Agent evaluation grades the whole execution trace (tool calls, observations, state changes, recovery) instead of the final answer alone, because a right answer can mask a broken process and a wrong answer can trace to one bad step in an otherwise sound run.
Agent Memory: Short-Term, Long-Term, and Memory Storesalso: agent memory, short-term memory, long-term memory, working memory: Agent memory is how an agent holds onto and recalls information across steps and sessions.
Agent Reliability and Long-Horizon Robustnessalso: agent reliability, long-horizon robustness, agent robustness, consistent completion: Agents over long horizons break down because per-step reliability multiplies: a step that works 95 percent of the time drops to roughly 60 percent across ten steps.
Agent State, Checkpointing, and Durable Executionalso: agent state, checkpointing, durable execution, workflow resumption: A long-running agent is a distributed workflow, so the answers come from durable execution rather than LLM folklore: model state as an explicit serializable object updated by reducers, checkpoint after every step so a crash resumes instead of replaying, and give every side-effecting tool an idempotency key plus a durable record written before the call.
Agentic and Corrective RAGalso: agentic RAG, corrective RAG, CRAG, self-RAG: Standard RAG retrieves once then generates; agentic RAG puts retrieval in a loop so the model chooses whether to retrieve, what to query, judges the results, and retrieves again until it has enough.
Agents and Tool Usealso: agent, agents, tool use, function calling: An agent is an LLM in a loop that can take actions through tools: it reasons, calls a tool (search, a database, code, an API), observes the result, and loops until finished.
Choosing and Adapting Embedding Modelsalso: embedding model selection, choosing embeddings, MTEB, embedding fine-tuning: Choosing an embedding model is a call about retrieval quality, cost, and operational risk on your own data, not about which model leads a public leaderboard.
Chunkingalso: chunk size, parent-child retrieval, semantic chunking, chunk: Chunking divides documents into the passages you embed and retrieve, and it ranks among the highest-leverage knobs in RAG.
Citations and Groundingalso: citations, grounding, attribution, source attribution: Grounding means the model answers only from supplied sources; citations make each claim traceable to the exact passage backing it.
Context Engineering for Agentsalso: context engineering, context management, context window management, agent context design: Context engineering is the discipline of designing the entire information payload that enters an agent's context window each turn: system instructions, memory, retrieved data, tool definitions and results, and conversation history.
Function Calling and Tool Schemasalso: function calling, tool schemas, tool calling, structured tool calls: Tool use runs on a function-calling protocol: you declare each tool as a JSON schema, the model returns a structured call (name plus arguments) that your code checks and executes, and the result flows back into the conversation.
GraphRAG and Knowledge-Graph Retrievalalso: GraphRAG, graph RAG, knowledge graph RAG, knowledge-graph retrieval: GraphRAG constructs an entity-and-relationship graph across a corpus, then retrieves by walking that graph rather than (or together with) flat vector similarity.
Hierarchical Retrieval (RAPTOR and Small-to-Big)also: hierarchical retrieval, RAPTOR, small-to-big, small to big retrieval: Hierarchical retrieval resolves the chunk-granularity dilemma: small chunks retrieve precisely but miss context, large chunks hold context but retrieve poorly.
Hybrid Search and Reciprocal Rank Fusionalso: hybrid search, BM25, reciprocal rank fusion, RRF: Vector search alone grasps meaning but drops exact terms (codes, names, SKUs); keyword search (BM25) alone locks onto exact terms yet ignores synonyms and intent.
Late-Interaction Retrieval (ColBERT)also: late interaction, ColBERT, MaxSim, multi-vector retrieval: Late-interaction retrieval stores each document as one vector per token instead of a single pooled vector, then scores a query by adding up the best token-to-token matches (MaxSim).
Model Context Protocol (MCP)also: MCP, Model Context Protocol, MCP server, MCP client: MCP is an open client-server standard that connects an agent to external tools, data, and prompts through one uniform interface, so a single integration serves many hosts instead of bespoke glue written per model.
Multi-Agent Orchestrationalso: multi-agent, orchestration, sub-agents, subagents: When a task is too big or varied for a single agent, an orchestrator breaks it apart and hands subtasks to focused sub-agents, each with its own clean context and tools, then synthesizes the results.
Query Transformation and Multi-Hop Retrievalalso: query transformation, query rewriting, HyDE, multi-hop retrieval: A user's raw question is frequently a weak search query: ambiguous, underspecified, or needing several facts chained together.
Rerankingalso: reranker, cross-encoder, bi-encoder, two-stage retrieval: Reranking is a two-stage retrieval design: a fast bi-encoder grabs a broad candidate set for recall, then a slower but more accurate cross-encoder rescores each (query, document) pair to reorder them for precision.
Retrieval vs Long Contextalso: long context vs RAG, RAG vs long context: If a whole document fits in a model's large context window, should you paste it, or retrieve only the relevant chunks?
The RAG Pipelinealso: RAG, retrieval-augmented generation, RAG pipeline, retrieval augmented generation: Retrieval-Augmented Generation anchors an LLM in outside knowledge: when a query arrives you pull the most relevant chunks from a knowledge base into the prompt, letting the model respond from actual sources rather than memory.
Vector Search and ANN Indexesalso: vector search, ANN, approximate nearest neighbor, vector database: Vector search locates the embeddings closest to a query vector.

48 TERMS

Evaluation & ML Foundations

A/B Testingalso: A/B test, experimentation, controlled experiment, split test: An A/B test randomly splits users between a control and a variant and compares a metric to measure causal impact.
Activation Functions: ReLU, GELU, SwiGLUalso: activation functions, ReLU, GELU, SwiGLU: Activation functions are the nonlinearity sitting between linear layers; drop them and a deep network folds into a single linear map however many layers it stacks.
Autoencoders and GANsalso: autoencoder, denoising autoencoder, variational autoencoder, VAE: Two foundational generative architectures: autoencoders squeeze input through a bottleneck and reconstruct it, which makes them useful for denoising, anomaly detection, and learning compact representations, while GANs set a generator against a discriminator in an adversarial game to produce realistic samples.
Backpropagation, Intuitivelyalso: backpropagation, backprop, reverse-mode autodiff, automatic differentiation: Backpropagation is the algorithm that computes the gradient of the loss with respect to every parameter in a network by running the chain rule in reverse, from the output back to the inputs.
Benchmarks and Their Limitsalso: benchmarks, benchmark contamination, leaderboard, MMLU: Public benchmarks like MMLU offer a shared yardstick, but they saturate, leak into training corpora, and stop tracking real ability once labs optimize for them.
CLT, Sampling, and Confidence Intervalsalso: CLT, central limit theorem, confidence interval, standard error: The central limit theorem says a sample mean is approximately normal no matter the underlying distribution, which is why so much inference relies on the normal curve.
CNNs: Convolution, Pooling, Receptive Fieldsalso: CNN, convolutional neural network, convolution, pooling: Convolutional neural networks swap dense layers for small filters slid across an image, sharing weights so the same edge detector works everywhere.
CV Architectures: ResNets, ViT, Detectionalso: computer vision architectures, ResNet, Vision Transformer, ViT: Modern computer vision stands on three pillars: residual connections that let CNNs reach hundreds of layers deep without degrading, Vision Transformers that patchify an image and run self-attention in place of convolutions, and detection heads (one-stage vs two-stage) scored by mAP after non-maximum suppression.
Calibration and Uncertaintyalso: calibration, calibrated probabilities, temperature scaling, Platt scaling: A model is calibrated when its confidence lines up with reality: among the predictions it makes at 0.8, roughly 80% turn out correct.
Catastrophic Forgetting and Continual Learningalso: catastrophic forgetting, continual learning, lifelong learning, elastic weight consolidation: Catastrophic forgetting is when training a neural network on new data erodes capabilities it already had, because gradient updates overwrite the weights that encoded old skills.
Causal Inference: Confounders and Identificationalso: causal inference, confounding, Simpson's paradox, difference-in-differences: Causal inference is the discipline of estimating what would happen if you intervened, not merely what correlates in observed data.
Clustering: K-Means, Hierarchical, DBSCANalso: clustering, k-means, kmeans, DBSCAN: Clustering groups unlabeled points by similarity.
Contrastive and Metric Learningalso: contrastive learning, metric learning, triplet loss, InfoNCE: Contrastive learning trains embeddings through comparison: pull similar (positive) pairs together and push dissimilar (negative) pairs apart, so distance encodes similarity.
Cross-Validation (Done Right)also: cross-validation, k-fold, stratified k-fold, time-series split: Cross-validation estimates how a model generalizes by training and testing on rotating folds, yielding a more reliable estimate than a single split.
Decision Trees and Splitting Criteriaalso: decision tree, CART, splitting criteria, Gini impurity: A decision tree recursively splits the feature space by choosing the split that most reduces impurity (Gini or entropy), producing a flowchart you can read top to bottom.
Dimensionality Reduction: PCA, t-SNE, UMAPalso: dimensionality reduction, PCA, principal component analysis, t-SNE: Dimensionality reduction compresses high-dimensional data into fewer axes.
Ensembling: Bagging, Boosting, Stackingalso: ensembling, ensemble, bagging, boosting: Ensembles combine multiple models to beat any single one, because if their errors are decorrelated, combining cancels mistakes.
Eval-Driven Development and Golden Datasetsalso: eval-driven development, golden dataset, evaluation set, eval set: You cannot improve an LLM system you cannot measure, so the first thing to build is an evaluation: a golden dataset of representative inputs with expected behavior, plus metrics, that you run on every change.
Feature Engineering: Encoding, Scaling, Selectionalso: feature engineering, categorical encoding, feature scaling, feature selection: Feature engineering is the work of turning raw columns into inputs a model can learn from: encoding categoricals, scaling numerics, and deciding which features to keep.
Gaussian Mixtures and the EM Algorithmalso: GMM, Gaussian mixture model, expectation maximization, EM algorithm: A Gaussian mixture model treats data as generated by several Gaussian components and gives each point a soft, probabilistic membership rather than a hard cluster label.
Generative vs Discriminative Models (Naive Bayes)also: generative vs discriminative, naive bayes, generative model, discriminative model: A discriminative model learns P(y|x) directly, the decision boundary.
Gradient Descent and Optimizersalso: gradient descent, SGD, stochastic gradient descent, Adam: Gradient descent is how models learn: compute the gradient of the loss with respect to the parameters and step opposite it to cut error.
Handling Missing and Corrupted Dataalso: missing values, imputation, MCAR, MAR: Missing data has three mechanisms (MCAR, MAR, MNAR) and the mechanism decides whether dropping rows is safe or biased and which imputation is valid.
Hyperparameter Optimizationalso: hyperparameter tuning, HPO, Bayesian optimization, Hyperband: Hyperparameter optimization is the hunt for the settings (learning rate, depth, regularization) that a model does not learn by itself, done through grid, random, or Bayesian search.
Hypothesis Testing and p-valuesalso: hypothesis testing, p-value, p values, significance testing: Hypothesis testing asks whether an observed effect is large enough to be unlikely under a null hypothesis of no effect, condensed into a p-value.
Imbalanced Data and Resamplingalso: class imbalance, imbalanced classification, rare class, oversampling: Imbalanced data is when one class is rare (fraud, churn, disease), so a model that predicts only the majority scores high accuracy while being useless.
Information Theory for MLalso: information theory, entropy, cross-entropy, KL divergence: ML rests on four information-theoretic quantities: entropy (how uncertain a distribution is), cross-entropy (the cost of modeling the true distribution with your predicted one, the classification loss), KL divergence (the gap between two distributions), and mutual information (how much one variable reveals about another).
LLM-as-a-Judgealso: LLM-as-judge, LLM as a judge, model-graded eval, G-Eval: When outputs are open-ended (summaries, chat answers, generated code), there is no exact match to score against, so you enlist a strong LLM to grade them against a rubric.
Label Noise and Weak Supervisionalso: label noise, weak supervision, programmatic labeling, confident learning: Label noise means mistakes in your training labels, and it sets a hard ceiling on model accuracy regardless of how strong the architecture is.
Linear and Logistic Regressionalso: linear regression, logistic regression, least squares, logit model: Linear regression fits a weighted sum of features to a continuous target by minimizing squared error; logistic regression squashes that same linear score through a sigmoid and fits it with cross-entropy to yield a probability.
MLE, MAP, and Bayesian vs Frequentistalso: MLE, MAP, maximum likelihood, maximum a posteriori: Maximum likelihood chooses the parameters that make the observed data most probable; MAP adds a prior and chooses the most probable parameters given the data.
Multi-Armed Banditsalso: bandit, exploration-exploitation, Thompson sampling, UCB: A multi-armed bandit selects among options to maximize reward while learning which is best, balancing exploration (try options to learn) against exploitation (use the best-known).
Object Detection and Segmentationalso: object detection, semantic segmentation, instance segmentation, Faster R-CNN: Detection finds objects as boxes plus labels; segmentation labels pixels (semantic) or per-object pixels (instance).
Offline vs Online Evaluationalso: offline vs online, offline evaluation, online evaluation, offline online gap: Offline evaluation scores a model on held-out data; online evaluation measures its impact on real users (through an A/B test).
Outlier and Anomaly Detectionalso: anomaly detection, outlier detection, novelty detection, isolation forest: Outlier and anomaly detection finds points that do not fit the bulk of the data using statistical, distance/density, or reconstruction-based methods.
Overfitting and Regularizationalso: overfitting, regularization, L1, L2: Overfitting is when a model learns the training data's noise rather than its signal, scoring well in training but failing on new data.
Precision, Recall, and F1also: precision, recall, F1, precision and recall: Precision is what fraction of your positive predictions were correct; recall is what fraction of the actual positives you caught.
Probability Distributions You Should Knowalso: probability distributions, Bernoulli distribution, binomial distribution, normal distribution: A small set of distributions covers most modeling situations: Bernoulli and binomial for yes/no outcomes and counts of successes, normal for sums and measurement noise, Poisson for event counts in a window, and exponential for waiting times.
RAG Evaluationalso: retrieval evaluation, recall@k, faithfulness, RAGAS: Evaluating a RAG system means scoring retrieval and generation separately, because a bad answer is usually a retrieval failure (the right context was never fetched) and you cannot fix what you cannot localize.
SVMs and the Kernel Trickalso: support vector machine, SVM, kernel trick, max-margin classifier: A support vector machine finds the decision boundary with the widest margin to the nearest points (the support vectors), trading hinge loss against margin width.
Sampling Techniques: Stratified, Reservoir, Importancealso: sampling techniques, stratified sampling, reservoir sampling, importance sampling: Sampling techniques decide which subset of data you train on, evaluate on, or stream through, and that choice quietly determines whether your numbers match reality.
Synthetic Data Generationalso: synthetic data, generating training data, data synthesis, LLM-generated data: Synthetic data is training or eval data made by a model, a simulator, or a program instead of gathered from the real world, used to bootstrap labels, cover rare cases, and distill a larger model down into a smaller one.
The Bias-Variance Tradeoffalso: bias-variance, bias-variance tradeoff, underfitting, bias variance: A model's error breaks into bias (error from being too simple to capture the pattern, underfitting) and variance (error from being too sensitive to the training sample, overfitting).
The Computer Vision Pipelinealso: computer vision pipeline, CV pipeline, image preprocessing, train serve skew: A production CV system is a chain: ingest and version images, preprocess and augment, fine-tune a pretrained backbone, attach a task head, evaluate with sliced metrics, post-process, then serve and monitor.
Training Neural Nets: Init, Normalization, Dropout, LR Schedulesalso: weight initialization, He initialization, Xavier initialization, batch normalization: The working recipe that lets deep nets train at all: scale-aware weight initialization (Xavier, He), normalization layers (batch, layer, RMS) that keep activations well-conditioned, dropout as stochastic regularization, and warmup plus cosine learning-rate schedules.
Transfer Learningalso: feature extraction, freezing layers, fine-tuning a backbone, pretrained model reuse: Transfer learning reuses a model pretrained on a large general corpus as the starting point for a new task, so you inherit learned features rather than training from scratch.
Vanishing and Exploding Gradientsalso: vanishing gradients, exploding gradients, gradient clipping, residual connections: In a deep or recurrent network the backward gradient is a product of many per-layer Jacobians, so its magnitude compounds: factors mostly below one drive it toward zero (early layers stop learning) and factors above one make it explode (training diverges into NaNs).
kNN and the Curse of Dimensionalityalso: k-nearest neighbors, kNN, nearest neighbor, curse of dimensionality: k-nearest-neighbors is a lazy, instance-based learner that labels a point by majority vote of its closest training examples under some distance metric.

24 TERMS

System Design for AI in Production

CAP and Consistency Modelsalso: CAP, CAP theorem, PACELC, linearizability: The CAP theorem says that during a network partition a distributed system has to choose between consistency and availability; you cannot have both while the network is split.
Caching Strategiesalso: caching, cache, cache-aside, write-through: A cache trades freshness for speed by holding a copy of hot data closer to the request.
Concurrency and Thread Safetyalso: concurrency, thread safety, race condition, mutex: When multiple threads touch shared mutable state, interleavings produce race conditions: lost updates, torn reads, corrupted data.
Consistent Hashing and Shardingalso: consistent hashing, sharding, hash ring, virtual nodes: Sharding spreads data across nodes so no single machine holds everything, but naive modulo hashing remaps almost every key when a node joins or leaves.
Content Distribution and P2Palso: content distribution, P2P, peer-to-peer, BitTorrent: Distributing one large file to many consumers from a single source bottlenecks on the source's upload bandwidth.
Distributed Key-Value Storesalso: key-value store, KV store, quorum, LSM-tree: A distributed KV store spreads keys across many nodes and replicates each key for durability and availability.
Fault Tolerance and Graceful Degradationalso: fault tolerance, graceful degradation, circuit breaker, fallback: AI systems rely on flaky, slow dependencies (model providers, vector stores, tools), so they must degrade gracefully rather than fail hard.
Foundation Model Selection and Benchmarkingalso: model selection, foundation model selection, benchmarking models, model evaluation for selection: Foundation model selection is the disciplined process of choosing among frontier models on capability, cost, latency, and context window, confirmed by your own task evals rather than public leaderboards.
Guardrailsalso: safety layer, input validation, output filtering, content safety: Guardrails are the runtime safety layer around an LLM: input checks (spotting prompt injection, off-topic or disallowed requests, PII) ahead of the model, and output checks (content safety, schema/format validation, grounding, PII/secret leakage) ahead of the user.
Idempotency and Exactly-Once Effectsalso: idempotency, idempotent, exactly-once, idempotency key: In a distributed system, calls fail and get retried, so the same request can land more than once.
LLM Cost Optimizationalso: cost optimization, token cost, cost per request: LLM systems get expensive fast, and the cost model comes down mostly to tokens and number of model calls.
Latency Budgets and Streamingalso: latency budget, time to first token, TTFT, streaming: LLM latency is not a single figure: time-to-first-token (driven by prefill and queueing) and inter-token latency (driven by decode) feel very different to users.
Learning to Rank: Pointwise, Pairwise, Listwisealso: learning to rank, LTR, pointwise, pairwise: Learning to rank trains a model to order a list rather than predict a single label.
Load Balancingalso: load balancer, L4, L7, round robin: A load balancer distributes requests across many backend instances so no single server is overwhelmed, and pulls failed instances from rotation.
Message Queues and Event Streamingalso: message queue, event streaming, Kafka, RabbitMQ: Broker queues (RabbitMQ, SQS) hand each message to one worker, wait for an ack, and delete it: built for distributing jobs.
Multi-Stage Retrieval and Ranking Funnelsalso: multi-stage ranking, ranking funnel, retrieval and ranking funnel, cascade ranking: Search, ads, and feed systems are constructed as a funnel: retrieve a broad candidate set, rank it with a heavier model, re-rank the top with the heaviest model, then filter and blend with business rules.
Observability for LLM Systemsalso: observability, LLM observability, tracing, logging: You cannot run or improve an LLM system you cannot see.
Prompt Versioning and Managementalso: prompt versioning, prompt management, prompt registry, versioned prompts: Prompt versioning handles prompts as production artifacts with their own change log, eval-backed releases, and rollback path, instead of string literals buried in application code.
Prompt and Semantic Cachingalso: prompt caching, prefix caching, semantic caching, caching: Caching ranks among the cheapest, highest-impact LLM optimizations.
Rate Limiting, Retries, and Backoffalso: rate limiting, token bucket, exponential backoff, retries: LLM systems rely on rate-limited, sometimes-failing providers, so resilient design is essential.
Recommendation Systems: Candidate Generation and Rankingalso: recommendation system, recsys, candidate generation, recommender system: Industrial recommenders run a two-stage funnel: cheap candidate generation trims millions of items to a few hundred, then an expensive ranker scores that shortlist.
The LLM Gatewayalso: LLM gateway, model gateway, AI gateway, proxy layer: An LLM gateway is one proxy layer sitting between your application and one or more model providers.
Token Streaming: SSE, Chunking, and Cancellationalso: token streaming, SSE, server-sent events, streaming responses: Server-Sent Events is the default transport for one-way token streams, and the interesting problems start after you pick it: an output guardrail that buffers the whole response destroys the time-to-first-token you paid a GPU for, you cannot send an HTTP error status after the 200 has flushed, and a client disconnect must actually cancel the GPU work or you keep generating tokens nobody will read.
User Feedback Loops and the Data Flywheelalso: data flywheel, user feedback loops, feedback loop, implicit feedback: A data flywheel captures implicit and explicit user feedback in production, feeds it into eval sets and fine-tuning data, and uses the improved model to draw more usage that produces more feedback.

7 TERMS

MLOps & Lifecycle

CI/CD for Modelsalso: ML testing, model testing, continuous delivery for ML: Shipping a model safely takes more than software CI/CD because the model rides on data, not just code.
Drift Detectionalso: data drift, concept drift, PSI, distribution shift: Models decay as the world shifts.
Feature Stores and Training-Serving Skewalso: feature store, training-serving skew, online features, point-in-time correctness: A feature store computes features once and delivers them to both training (offline, historical) and serving (online, low-latency) from the same definitions, which is the fix for training-serving skew, the silent bug where features are computed differently in training and production and the model degrades.
Model Debugging Methodologyalso: model debugging, error analysis, root-causing underperformance, train val test gap: Model debugging is the systematic work of root-causing why a model underperforms: judging whether the cause is the data, the features, the labels, model capacity, or the evaluation itself, rather than blindly tuning hyperparameters.
Model Monitoring in Productionalso: model monitoring, production monitoring, ML monitoring, monitoring layers: Monitoring an ML model takes more than uptime and latency, because a model can look healthy and be silently wrong.
Model Registry, Lineage, and Promotionalso: model registry, lineage, model promotion, model versioning: A model registry is the versioned source of truth for trained models: every model carries a version, lineage (the data, code, config, and run that produced it), and a stage (staging, production, archived).
Reproducible and Deterministic Pipelinesalso: reproducible pipelines, deterministic training, reproducibility, bit-for-bit reproducibility: A reproducible pipeline yields the same model and metrics from the same inputs, achieved by pinning seeds, dependencies, data versions, and code together.

13 TERMS

ML Infrastructure & Serving

Continuous Batchingalso: in-flight batching, dynamic batching, batching: GPUs run efficiently on batches, but LLM requests show up at different times and complete after different numbers of tokens, so static batching wastes the GPU while it waits on the slowest request.
Disaggregated Prefill/Decode and Prefix Cachingalso: disaggregated prefill, prefill decode disaggregation, prefix caching, chunked prefill: LLM inference has two phases with opposite hardware profiles: prefill is compute-bound (it works through the whole prompt in parallel) while decode is memory-bandwidth bound (one token at a time).
Distributed Training: Parallelism and FSDPalso: distributed training, FSDP, ZeRO, data parallelism: Training large models requires many GPUs, and the work can be split in distinct ways: data parallelism copies the model and divides the batch; FSDP/ZeRO shards the optimizer state, gradients, and parameters across GPUs to fit models that otherwise do not; tensor parallelism divides a layer's matrices within a node; pipeline parallelism divides layers across nodes.
FlashAttention and IO-Aware Kernelsalso: FlashAttention, flash attention, IO-aware attention, fused attention kernel: Naive attention is slow not because of the matmuls but because it writes the full N-by-N attention matrix out to GPU high-bandwidth memory and reads it back, making it memory-bandwidth bound.
GPU Memory and the Serving Stackalso: GPU memory, serving stack, memory math, prefill: Serving an LLM is largely a memory problem: the GPU has to hold the model weights along with a KV cache that scales with sequence length and batch size, and inference divides into a compute-bound prefill and a memory-bandwidth-bound decode.
Green AI: Compute, Energy, and Carbonalso: green AI, carbon footprint, energy efficiency, sustainable AI: Energy is roughly GPU-hours times average power draw times data-center PUE, and carbon is that energy times the grid's carbon intensity where and when you ran it, which varies by an order of magnitude across regions.
Knowledge Distillationalso: model distillation, teacher-student, distillation, soft targets: Knowledge distillation trains a small student model to copy a larger teacher, treating the teacher's soft probability distribution (or internal features) as a richer training signal than hard labels.
Mixed-Precision Trainingalso: mixed precision, FP16, BF16, bfloat16: Mixed-precision training runs most computation in 16-bit (FP16 or BF16) rather than 32-bit, roughly halving memory and accelerating training on modern GPUs, while holding a few numerically-sensitive parts in FP32 for stability.
Model Serving Frameworksalso: vLLM, Triton, TGI, TensorRT-LLM: You seldom build a serving stack from scratch; frameworks take care of the production plumbing.
Multi-LoRA Servingalso: multi lora, serving LoRA adapters, LoRA multiplexing: LoRA adapters are tiny weight deltas layered on a shared base model, so you can serve hundreds of fine-tuned variants from one set of base weights rather than one full model per tenant.
PagedAttentionalso: paged attention, KV cache paging, vLLM: The KV cache is the memory bottleneck in LLM serving, and naively reserving a contiguous block per request (sized for the maximum length) loses most of it to fragmentation and over-allocation.
Quantization and Low Precisionalso: quantization, low precision, INT8, INT4: Quantization holds and runs model weights (and activations) at fewer bits, FP16/BF16, FP8, INT8, INT4, rather than FP32, shrinking memory and accelerating inference for some accuracy cost.
Speculative Decodingalso: draft model, speculative sampling: Decoding is sequential and memory-bound, so producing each token one at a time leaves the GPU underused.

23 TERMS

Data & SQL Engineering

Backfills and Reprocessingalso: backfill, backfilling, reprocessing history, recompute history: A backfill recomputes historical data after a bug fix, a new column, or a logic change, and it is where fragile pipelines break.
Batch vs Streamingalso: batch processing, stream processing, streaming, event time: Batch processes a bounded dataset on a schedule; streaming processes an unbounded flow of events continuously.
CTEs and Subqueriesalso: CTE, common table expression, WITH clause, subquery: A CTE (the WITH clause) names an intermediate result so a query reads as a top-to-bottom pipeline rather than nested subqueries.
Change Data Capturealso: CDC, change stream, incremental load: Change Data Capture (CDC) streams the inserts, updates, and deletes from a source database so downstream systems stay in sync without costly full reloads.
Data Quality and Contractsalso: data quality, data contracts, data validation, schema validation: Models and analytics are only as good as the data behind them, and a silent upstream data change (a renamed column, a units switch, a spike in nulls) corrupts everything downstream without raising an error.
Deduplication (Exact and Fuzzy)also: deduplication, dedup, near-duplicate, MinHash: Duplicates slip into data through retries, joins, and multiple sources, and they corrupt counts, training sets, and aggregates.
Dimensional Modeling and Star Schemasalso: dimensional modeling, star schema, snowflake schema, fact and dimension tables: Dimensional modeling arranges an analytics warehouse into fact tables (the measurable events) surrounded by dimension tables (the descriptive context), forming a star schema.
GROUP BY and Aggregationalso: GROUP BY, aggregation, HAVING vs WHERE, conditional aggregation: GROUP BY collapses rows that share the same key values into one row per group, and aggregate functions (COUNT, SUM, AVG) produce a single value per group.
Gaps and Islands (Sessionization)also: gaps and islands, sessionization, islands, streak detection: Gaps-and-islands is the pattern for grouping consecutive rows into runs (islands) split by breaks (gaps), the machinery behind sessionization, streak detection, and merging contiguous ranges.
Idempotent Data Pipelinesalso: idempotent pipelines, idempotency, insert-overwrite, upsert: Data pipelines fail and get rerun, so a pipeline has to be idempotent: running it again yields the same result rather than duplicated or corrupted data.
Incremental Models and MERGE/UPSERTalso: incremental models, MERGE, UPSERT, high watermark: Incremental models process only new or changed rows rather than rebuilding a table from scratch, using a high-watermark to select the delta and a MERGE/UPSERT to apply it.
Indexing Strategiesalso: indexing, indexes, B-tree index, covering index: An index is a secondary data structure that lets the database locate rows without scanning the whole table, trading write cost and storage for read speed.
NULLs and Three-Valued Logicalso: NULL, three-valued logic, NOT IN trap, COALESCE: NULL means unknown, so SQL relies on three-valued logic where comparisons with NULL return UNKNOWN, not TRUE or FALSE.
Partitioning and Clusteringalso: partitioning, clustering, partition pruning, sort keys: Partitioning splits one large table into physically separate chunks by a key (usually date), so a query with a matching filter reads only the relevant partitions rather than the whole table.
Pipeline Orchestration and DAGsalso: orchestration, DAG, Airflow, Dagster: Orchestration runs dependent data tasks as a DAG so each task waits for its upstreams, retries safely, backfills history, and alerts when an SLA is missed.
Query Execution and Optimizationalso: query optimization, EXPLAIN plan, query planner, execution plan: A query optimizer turns your SQL into a physical plan: which tables to scan, in what join order, and whether to use a hash join, sort, or index lookup.
Ranking and Top-N Per Groupalso: top-N per group, ROW_NUMBER, RANK, DENSE_RANK: Top-N-per-group is the partition-then-filter idiom: rank rows within each group using a window function, then keep the ranks you want.
SQL Joinsalso: left join, semi join, anti join, join fan-out: Joins combine rows across tables on a matching condition, and the join type (inner, left, right, full, semi, anti) decides which non-matching rows survive.
Schema Evolution and Data Contractsalso: schema evolution, data contracts, expand-contract migration, schema migration: Schemas change as products evolve, and adding, altering, or dropping a column can break every downstream consumer at once.
Slowly Changing Dimensions (SCD)also: slowly changing dimensions, SCD, SCD Type 2, dimension history: Slowly changing dimensions are the patterns for handling dimension attributes that change over time, such as a customer moving cities or a product changing category.
Transactions, ACID, and Isolation Levelsalso: ACID, isolation levels, transaction isolation, MVCC: A transaction bundles multiple reads and writes so the whole set either commits together or rolls back together, backed by the ACID guarantees of atomicity, consistency, isolation, and durability.
Warehouse vs Lake vs Lakehousealso: data warehouse, data lake, lakehouse, Iceberg: A warehouse enforces schema-on-write with tight governance and fast SQL; a data lake stores raw files cheaply with schema-on-read and no transactions; a lakehouse layers an open table format (Iceberg or Delta) on object storage to deliver ACID, time travel, and schema evolution at lake cost.
Window Functionsalso: OVER, PARTITION BY, ROW_NUMBER, LAG: Window functions run calculations over a set of rows tied to the current row, without collapsing them the way GROUP BY does, so you can rank within groups, build running totals and moving averages, and compare a row against its neighbors (LAG/LEAD), all in a single pass.

16 TERMS

AI Security, Privacy & Governance

AI Governance Frameworksalso: AI governance, NIST AI RMF, EU AI Act, governance framework: AI governance is the program that keeps deployments safe, fair, and compliant: risk assessment, documentation (model cards, datasheets), human oversight, monitoring, and incident response, shaped by frameworks like the NIST AI Risk Management Framework and laws like the EU AI Act (which tiers obligations by risk).
Agent Guardrailsalso: least privilege, human-in-the-loop, blast radius, agent safety: An agent that can take actions is far riskier than one that only talks, so guardrails have to constrain actions, not just text.
Agent Security: Tool Poisoning, Memory Poisoning, Containmentalso: agent security, tool poisoning, memory poisoning, agent containment: Agent security covers threats that appear only once an LLM can call tools and act on their results: malicious tool or MCP responses, poisoned long-term memory, privilege escalation through tool misuse, and goal hijacking.
Audit Trailsalso: audit logging, traceability, audit log: An audit trail records enough to reconstruct and explain any AI decision: the input, retrieved context, model and prompt version, output, and who/when, along with human overrides and guardrail events.
Automation Bias and Effective Human Oversightalso: automation bias, human in the loop, human oversight, rubber stamping: Automation bias is the documented tendency for a person shown a confident machine recommendation to anchor on it and stop hunting for contradicting evidence, which makes 'human in the loop' weakest exactly where the model is wrong.
Differential Privacyalso: DP, DP-SGD, epsilon, membership inference: Differential privacy injects calibrated noise into data, queries, or training so the output is provably insensitive to any single individual's record, capping what can be learned about any one person.
Fairness, Bias, and Model Cardsalso: fairness, bias, model cards, datasheets: Models can perform unequally across groups, inheriting and amplifying bias in the data, which is a harm and, in regulated domains, illegal.
Federated Learningalso: FedAvg, federated averaging, cross-device learning, cross-silo learning: Federated learning trains a shared model across many devices or organizations without shipping their raw data to a central server: each party computes updates locally and only the updates get aggregated.
Indirect Prompt Injection and the Lethal Trifectaalso: indirect prompt injection, lethal trifecta, data exfiltration attack, poisoned retrieval: Indirect prompt injection buries attacker instructions inside content an agent retrieves or reads (a web page, a PDF, a support ticket), so an innocent user sets off the attack.
Intersectional and Subgroup Fairnessalso: intersectional fairness, subgroup fairness, fairness gerrymandering, multicalibration: A model can pass a fairness audit on gender, pass on race, and fail badly on their intersection, because a single-axis audit averages away the group you most need to see.
Jailbreaks and Red-Teaming Taxonomyalso: jailbreaks, red teaming, jailbreak taxonomy, crescendo attack: Jailbreaks are inputs that coax a model into producing content its safety training was meant to refuse, using techniques like role-play framing, encoding, many-shot priming, and gradual crescendo escalation.
Mechanistic Interpretabilityalso: mech interp, circuits, superposition, sparse autoencoders: Mechanistic interpretability reverse-engineers what a neural network actually computes: the features it represents, the circuits that combine them, and how to check causal claims with interventions.
Multi-Tenancy and Isolationalso: multi-tenancy, tenant isolation, multi-tenant, cross-tenant leak: When a single AI system serves many customers (tenants), the cardinal rule is that no tenant may ever see another's data.
PII Handlingalso: PII, redaction, data minimization, personal data: Personal data sitting in prompts, logs, and training sets creates privacy and compliance exposure (GDPR, HIPAA), so you have to detect and guard it.
Privacy Attacks: Re-identification, Linkage, and k-Anonymityalso: re-identification, reidentification, linkage attack, k-anonymity: Stripping direct identifiers does not anonymize data: quasi-identifiers like ZIP, birth date, and gender are close to unique for most people, and any auxiliary dataset sharing those fields enables a linkage attack.
Prompt Injectionalso: indirect prompt injection, jailbreak, injection: Prompt injection ranks as the number one security risk for LLM apps: hostile instructions hijack the model's intended behavior.

28 TERMS

Coding & Engineering Craft

Arrays and Hashingalso: hash map, hash table, dictionary, two sum: The hash map does most of the heavy lifting in coding interviews: average O(1) insert and lookup that collapses an O(n^2) all-pairs scan down to one O(n) pass.
Backtrackingalso: backtrack, systematic search, constraint search, prune and backtrack: Backtracking is systematic search across a tree of partial solutions: at each step you pick an option, explore deeper, and undo the pick before trying the next (choose, explore, unchoose).
Binary Search and Search-Space Reductionalso: binary search, binary search on the answer, lo hi mid, search space reduction: Binary search cuts a sorted or monotonic-predicate space in half at each step to reach O(log n), but the real interview skill is spotting a problem that is secretly monotonic and binary-searching on the answer rather than the array.
Bit Manipulationalso: bitwise operations, bitmask, XOR trick, bit tricks: Bit manipulation uses AND, OR, XOR, and shifts to pack flags into integers, test and toggle individual bits, and lean on tricks like XOR-cancellation to find a unique element in O(1) space.
Dynamic Programmingalso: DP, memoization, tabulation: Dynamic programming tackles problems with overlapping subproblems and optimal substructure by defining a state, writing a recurrence, and caching results so each subproblem is computed once.
Fast and Slow Pointers (Floyd's Cycle Detection)also: fast and slow pointers, tortoise and hare, Floyd's algorithm, cycle detection: Fast and slow pointers send two cursors through a sequence at different speeds so geometry, not extra memory, reveals structure.
Graphs: BFS, DFS, and Shortest Pathsalso: graph traversal, BFS, DFS, breadth-first search: A graph is nodes and edges, and most of the work is realizing a problem is a graph to begin with.
Greedy Algorithmsalso: greedy, greedy algorithm, exchange argument, greedy choice: Greedy algorithms construct a solution by always taking the locally best choice and never reconsidering.
Heaps and Priority Queuesalso: heap, binary heap, priority queue, min-heap: A binary heap holds a partial order so you can pull the smallest or largest element in O(log n) and peek at it in O(1), without paying for a full sort.
Implementing ML From Scratch (NumPy Patterns)also: ML from scratch, NumPy patterns, vectorization, implement softmax: ML-from-scratch coding rounds check whether you can express a model as vectorized array operations rather than Python loops, lay out a clean forward and backward pass, and write a numerically careful softmax and cross-entropy.
Interval Problemsalso: intervals, merge intervals, meeting rooms, sweep line: Interval problems (merging, inserting, counting overlaps, finding minimum resources) nearly always open the same way: sort by start or end time, then sweep through once.
Linked Listsalso: linked list, singly linked list, doubly linked list, Floyd's algorithm: A linked list keeps elements in nodes that reference the next node, giving up O(1) random access in exchange for O(1) insertion and deletion once you hold a pointer.
Matrix and Grid Simulation Patternsalso: matrix simulation, grid simulation, spiral matrix, rotate image: Grid problems reward a small set of mechanical patterns: walk a spiral by shrinking four boundaries, rotate a square in place with a transpose-then-reverse, and store state inside the grid itself to keep extra space at O(1).
Monotonic Stack and Monotonic Queuealso: monotonic stack, monotonic queue, monotonic deque, next greater element: A monotonic stack holds its elements sorted so the next-greater or next-smaller element falls out in amortized O(n); a monotonic deque does the same for a sliding window maximum.
Numerical Stability in Codealso: numerical stability, log-sum-exp, logsumexp, floating point precision: Numerical stability means writing arithmetic so floating-point error and overflow do not corrupt the result, which matters because naive ML math (softmax, cross-entropy, variance) quietly returns NaN or wrong gradients.
Parsing Messy, Real-World Dataalso: parsing messy data, data parsing, robust parsing, ingestion: Production data arrives messy: formats vary, fields go missing, encodings break, records come malformed, and edge cases appear that you never planned for.
Prefix Sums and Difference Arraysalso: prefix sum, prefix sums, cumulative sum, difference array: A prefix-sum array precomputes running totals so any range sum resolves in O(1), and pairing prefix sums with a hash map counts subarrays whose sum reaches a target or a residue mod k.
Recursion and Divide-and-Conqueralso: recursion, divide and conquer, divide-and-conquer, recursive algorithms: Recursion solves a problem by calling itself on smaller inputs until a base case halts it; divide-and-conquer is the variant that breaks input into independent subproblems, solves each, and merges the results (merge sort, quickselect).
Sorting Algorithmsalso: sorting, merge sort, quicksort, radix sort: Sorting algorithms divide into comparison sorts (merge, quick, heap) capped by an O(n log n) lower bound, and linear-time counting and radix sorts that apply only when keys are small bounded integers.
Stacks and Queuesalso: stack, queue, monotonic stack, LIFO: A stack is last-in-first-out and a queue is first-in-first-out, and most interview value comes from spotting which problems conceal one.
Streaming and Backpressurealso: streaming, backpressure, bounded memory, generators: When data is too large to hold in memory or keeps arriving without end, you handle it as a stream, one piece at a time, with bounded memory, rather than pulling it all in.
Testable Design for AI Systemsalso: testable design, dependency injection, mocking, testing AI systems: AI systems resist testing because models are non-deterministic and reach out to external services, so testability must be built in from the start: put the non-deterministic model behind an interface so you can mock it, split deterministic logic (parsing, retrieval, formatting) away from the model call and test it as usual, and check metric tolerances instead of exact outputs.
The Big-O That Actually Mattersalso: Big-O, time complexity, complexity, quadratic: Big-O complexity counts most where it actually hurts in real AI systems: dodge accidental O(n^2) (all-pairs comparisons, repeated linear scans), reach for hash maps to get O(1) lookups, and understand that vector search stays approximate exactly because exact nearest-neighbor costs O(n) per query.
Topological Sort and DAGsalso: topological sort, topo sort, DAG, Kahn's algorithm: A topological sort arranges the nodes of a directed acyclic graph so that every edge points forward, which is exactly what dependency resolution requires.
Trees, BSTs, and Traversalalso: binary tree, BST, binary search tree, tree traversal: A binary tree connects each node to at most two children, and a binary search tree adds the invariant that everything left is smaller and everything right is larger, which yields O(log n) search on a balanced tree.
Tries and String Algorithmsalso: trie, prefix tree, KMP, Knuth-Morris-Pratt: A trie is a prefix tree that keeps strings by shared prefixes, giving O(length) lookup and natural prefix queries for autocomplete.
Two Pointers and Sliding Windowalso: two pointers, sliding window, expand contract, converging pointers: Two pointers and the sliding window are the array techniques that reach O(n) where a naive double loop would sit at O(n^2).
Union-Find (Disjoint Set Union)also: union find, disjoint set union, DSU, disjoint-set: Union-Find (Disjoint Set Union) maintains a partition of elements into groups and answers 'are these two connected?' in near-constant amortized time via path compression and union by rank.

5 TERMS

Behavioral & Project Deep-Dives

Communicating with Non-Technical Stakeholdersalso: stakeholder communication, explaining to non-technical, communicating AI, audience: A large share of AI, ML, and GenAI engineering work is explaining complex systems to non-technical people: executives, customers, domain experts.
Handling the Live Demo (and Recovery)also: demo recovery, live demo, handling failure, composure: AI demos break in front of customers: the model hallucinates, a service times out, an edge case gives way.
Requirements Discoveryalso: discovery, working backwards, problem definition: The priciest AI errors trace back to building the wrong thing, and the reason is nearly always discovery that got skipped.
Scoping Under Ambiguityalso: scoping, ambiguity, handling ambiguity, MVP: Real AI projects begin ambiguous: fuzzy goals, unknown data, requirements that shift.
Translating Technical Trade-offsalso: translating tradeoffs, explaining tradeoffs, accuracy latency cost, communicating uncertainty: AI, ML, and GenAI engineers constantly translate between technical reality and business stakeholders: explaining the accuracy-latency-cost triangle, why the model cannot be 100% reliable, and what a trade-off means for the user, in the stakeholder's language rather than jargon.

Knowing the word is not the same as passing the round

A definition gets you through the first thirty seconds. What decides the round is the follow-up: why that approach and not the other one, what breaks at scale, what you would measure. Start with the map if you are new here, work the concept curriculum if you want the mechanism, and drill the question bank when you want to rehearse saying it out loud.