NVIDIA Applied AI Engineer interview questions

Almost everyone can quote softmax(QKᵀ/√d_k)V. The interviewer wants the variance argument and the exact training failure the scale prevents. Here is the answer that separates memorization from understanding.

PEFT is how everyone fine-tunes large models now. The signal is the low-rank insight behind LoRA, why it cuts memory so much, and what 4-bit QLoRA adds. Here is the answer that goes past 'it's efficient fine-tuning.'

The 2025-2026 landscape isn't 'bigger is better' anymore. The signal is knowing why small models and reasoning models exist, the test-time-compute tradeoff, and routing the right model to the right task. Here is the practitioner's view.

Fine-tune a model on your domain and it can forget how to do everything else. The signal is explaining why shared weights cause it and naming the concrete mitigations that all reduce to one principle.

PEFT is a family, not just LoRA, and interviewers probe whether you know how each one injects trainable parameters. The signal is where each method adds capacity and the latency and quality tradeoffs that follow.

Synthetic data is how teams get training data when real data is scarce, and it has sharp failure modes. The signal is naming when it helps, how to hold the quality line, and why training on model output across generations narrows the distribution.

Everyone fixates on attention, but the feed-forward layers hold most of a transformer's weights and do much of the per-token 'knowledge' work. The signal is knowing what the FFN computes and why it dominates the parameter count.

Full attention is O(n^2), so long context needs cheaper attention. The signal is naming the families (sparse, sliding-window, linear), what each gives up, and why FlashAttention is not one of them.

MQA and GQA shrink the KV cache, the thing that bottlenecks LLM serving. The signal is knowing they share key/value heads across query heads to cut memory and bandwidth, with GQA as the quality-preserving middle ground. Here is the answer.

Fine-tuning a 65B model used to mean a node of A100s. QLoRA collapses it onto one card with three specific tricks. The signal is knowing what gets quantized, what stays trainable, and why quality barely moves. Here is the answer.

Distillation is not one method. The signal is knowing when to match logits versus train on generated text, why on-policy distillation beats off-policy, and how reasoning models are distilled.

The ratio of web, code, books, and math in pretraining quietly decides downstream skills. The signal is knowing how mixtures are chosen, why upsampling helps, and how methods like DoReMi automate it.

Continued pretraining injects domain knowledge that fine-tuning cannot, but naively it wrecks general ability. The signal is the replay ratio, learning-rate rewarming, and how you measure forgetting.

MQA and GQA shrink the KV cache by sharing key/value heads. MLA takes a different route: compress K and V into a low-rank latent and cache that. The signal is knowing it is a cache trick, not a head-sharing trick, and why it keeps quality.

Drop the oldest tokens to bound the KV cache and the model collapses. Keep just the first few tokens and it generates indefinitely. The signal is understanding why those first tokens act as an attention sink.

A model trained at 4K tokens can be stretched to 128K without full retraining. The signal is knowing why naive extrapolation fails and how PI, NTK-aware scaling, and YaRN each rescale RoPE frequencies differently.

At long context the KV cache, not the weights, fills the GPU. The signal is naming the levers (quantization, token eviction, head sharing, low-rank) and what each one costs in quality.

Most GPU memory in naive LLM serving is wasted on KV-cache fragmentation. PagedAttention borrows virtual memory paging to reclaim it. The signal is explaining the fragmentation problem and how blocks fix it.

Speculative decoding speeds up generation without changing the output distribution. The signal is knowing how draft-model, self-drafting (Medusa/EAGLE), and lookahead approaches differ in where the guesses come from.

Both squeeze an LLM to 4-bit weights, but they decide what to protect very differently. The signal is GPTQ's error-correcting solve versus AWQ's activation-aware scaling, and the calibration each needs.

GGUF is the format behind most local LLM runs, and its quant names look cryptic. The signal is decoding what Q4_K_M means and why mixed-precision k-quants beat naive uniform quantization.

FP8 is the format behind modern H100-class training and serving. The signal is knowing the two FP8 variants, why a floating format beats INT8 for dynamic range, and where scaling still matters.

MoE saves compute but is awkward to serve: experts must be sharded, tokens routed across devices, and batches balanced. The signal is the all-to-all communication and the load-imbalance problem, not the training story.

Speech LLMs either transcribe to text or model audio directly as discrete tokens. The signal is the semantic-vs-acoustic token split and why end-to-end audio models beat ASR-plus-LLM pipelines on latency and prosody.

Temperature 0 does not mean deterministic, and the reason is in the GPU kernels, not the sampler. The signal is naming the batch-invariance problem and knowing which fixes are real versus placebo.

A staple ML-coding screen. Writing the loop is easy; the signal is k-means++ init, a real convergence criterion, and knowing the failure modes. Here is the tight implementation plus the follow-ups interviewers always ask.

A deceptively simple ML-coding ask. Anyone can write exp/sum; the signal is the max-subtraction trick and the log-sum-exp form that keep it from overflowing. Here is the stable implementation and why the naive one breaks.

The from-scratch implementation that frontier labs and NVIDIA actually ask. Writing it proves you understand shapes, the scale, the causal mask, and how heads split and recombine. Here is a correct, readable implementation and the follow-ups.

Beam search is the decoding algorithm everyone references and few can implement correctly. The signal is keeping k hypotheses by cumulative log-prob, summing logs (not multiplying probs), and handling completed sequences and length. Here is a correct implementation and the tradeoffs.

The core operation under every embedding/RAG retrieval, asked as a coding exercise. The signal is vectorizing the similarity, normalizing correctly, and using a partial selection (argpartition) instead of a full sort. Here is the efficient implementation and the scaling follow-up.

Data loading is where training pipelines silently bottleneck. The signal is a correct shuffle-then-batch iterator plus knowing why prefetching and parallel loading keep the GPU fed.

k-NN is simple to write and a good test of vectorization and the lazy-learner tradeoff. The signal is a clean vectorized distance computation and knowing why naive prediction is O(n) and how to speed it. Here is the implementation.

Implementing conv2d proves you understand what a CNN layer actually computes, not just that you can name it. The signal is correct output-shape math, clean stride/padding handling, and knowing the im2col trick frameworks really use.

LayerNorm sits in every transformer, and implementing it checks that you know what it normalizes over and why. The signal is normalizing across the feature dimension per token, the learnable scale/shift, and the RMSNorm simplification modern LLMs adopted.

Implementing the KV cache proves you understand why decode is efficient: you append the new token's K/V and reuse the rest instead of recomputing. The signal is the append-and-attend-over-cache logic. Here is the implementation.

Implementing BatchNorm checks that you know the train/inference difference, the part everyone forgets. The signal is normalizing over the batch with running stats maintained for inference. Here is the implementation.

Implementing Adam proves you understand what's happening under .step(): momentum plus per-parameter adaptive rates with bias correction. The signal is the two moments and the bias-correction step.

Single-head attention is common; multi-head adds the split-into-heads, attend-per-head, concatenate structure. The signal is the reshape into heads and a clear reason why multiple heads help. Here is the implementation.

Dropout is five lines, yet most candidates botch two of them: disabling it at inference and scaling the survivors so the expected activation stays constant. Inverted dropout is the convention they want to see.

RoPE is why modern LLMs extrapolate to longer contexts, and it's a rotation, not an addition. Coding it shows you actually understand how position enters attention. Here is the implementation.

Many state-of-the-art training runs keep a shadow copy of the weights that's a moving average of the trajectory, and serve that instead of the final step. It's a few lines and a real accuracy boost. Here it is.

OpenAI's signature build screen: a credit ledger that grants GPU-hours, spends them, and expires unused grants in issue order. The trap is spending against the right grant first. Here is the FIFO-by-expiry design that survives every follow-up.

A from-scratch favorite that tests linear algebra fluency. The signal is centering first, using SVD instead of forming the covariance matrix, and reading variance off the singular values. Here is the implementation and the details interviewers push on.

A from-scratch test of the EM algorithm and soft clustering. The signal is the two alternating steps (responsibilities then weighted re-estimation), log-sum-exp for stability, and knowing how GMM generalizes k-means. Here is the implementation.

A from-scratch test of recurrent forward passes and backprop through time. The signal is the shared-weight recurrence, accumulating gradients across timesteps, and explaining the vanishing-gradient problem. Here is the implementation.

A from-scratch test of gated recurrence. The signal is wiring the forget/input/output gates and candidate correctly, separating cell state from hidden state, and explaining why the additive cell path fixes vanishing gradients. Here is the implementation.

A from-scratch test of modern optimizers. The signal is the moment estimates, bias correction, and the one change that matters: AdamW decouples weight decay from the gradient instead of folding it into the loss. Here is the implementation and why it wins.

A from-scratch test of how learning-rate schedules are actually computed. The signal is correct closed-form formulas, knowing when each schedule shines, and why decaying the rate helps convergence. Here is the implementation of the common ones.

A from-scratch test of how PyTorch actually works under the hood. The signal is building a computation graph during the forward pass, local derivatives per op, and a topological-order backward pass that accumulates gradients. Here is a minimal engine.

A from-scratch test of distributed input pipelines. The signal is partitioning data across workers with no overlap and no gaps, epoch-consistent shuffling with a shared seed, and handling the uneven-last-batch problem. Here is the implementation.

The most common ML fundamentals question, and a quiet seniority test: anyone recites the definition, but can you decompose the error and turn it into a concrete debugging plan?

Optimizer questions test whether you understand what each one adapts and the subtle AdamW fix that the whole field now uses. The signal is the per-parameter adaptivity story plus why coupling weight decay to Adam was a bug. Here is that answer.

SVMs separate the candidates who memorized 'maximize the margin' from the ones who can explain why a kernel gives you non-linear separation without ever touching the high-dimensional space. Here is the answer that lands the second signal.

Dimensionality questions test linear-algebra intuition and practical judgment at once. The signal is what PCA actually does (project onto max-variance directions), why high dimensions hurt, and the honest catch: it is unsupervised, so it can throw away the exact direction your label needs. Here is the answer.

EM is the canonical latent-variable algorithm, and a GMM is how it shows up in practice. The signal is the E-step/M-step alternation, why it is soft clustering where k-means is hard, and the honest caveat that it only finds a local optimum. Here is the answer.

Backprop is the algorithm that makes deep learning trainable, and the interviewer wants the chain-rule mechanics, not just 'it computes gradients.' The signal is the forward-then-backward flow and why it is efficient. Here is the answer.

BatchNorm is one of the most-asked deep-learning questions, and the trap is the train/inference difference. The signal is what it normalizes, why it stabilizes and speeds training, and why it switches to running statistics at inference. Here is that answer.

This question ties together why deep nets were hard to train and the cluster of tricks that fixed it. The signal is the multiplicative-gradient cause and naming the real fixes: ReLU, He/Xavier init, residuals, normalization. Here is the answer.

CNNs are foundational even as transformers rise, and this checks whether you understand why convolution suits images. The signal is parameter sharing and local connectivity, what pooling buys, and how the receptive field grows. Here is the answer.

Patches as tokens, global attention from layer one, and a weaker inductive bias than a CNN. The signal is naming the data regime where each architecture wins and why. Here is the answer interviewers score highest.

Forward noising is fixed, reverse denoising is learned, and the training loss is a plain noise-prediction regression. The signal is why that beats a GAN's minimax and what the VAE and U-Net each do in latent space. Here is the answer.

Self-supervision is how modern models pretrain on unlabeled data, the engine behind LLMs and modern vision. The signal is the pretext-task idea and the real difference between contrastive and masked-prediction objectives.

Voice is a major modality and a common applied-AI surface. The signal is the audio-to-text pipeline, why Whisper is resilient, and the cumulative latency budget that makes or breaks a real-time voice agent.

Sequence models are foundational and still asked, especially the gating that fixed RNNs and why attention won. The signal is connecting the vanishing-gradient story to the parallelism argument that let transformers ride the scaling wave.

GANs defined generative modeling for years, and interviewers want the minimax game, the failure modes (mode collapse, instability), and the precise reason diffusion displaced them for images while GANs still win on speed.

Autoencoders and VAEs underpin representation learning and generative modeling, including the VAE inside latent diffusion. The signal is the gap between a plain autoencoder and a variational one, and why you cannot backprop through sampling without the reparameterization trick.

Transfer learning is why you rarely train from scratch, and the real question is how much of the pretrained model to reuse versus adapt. The signal is a crisp decision grid over data size and task similarity, plus knowing when a low LR saves you from catastrophic forgetting.

The learning rate is the one hyperparameter that can NaN your run on step 50 or stall it forever. Modern training schedules it instead of fixing it. The signal is knowing exactly what warmup and decay each buy you. Here is the answer.

A staple that checks whether you know why ReLU dethroned sigmoid and how to match the output activation to the loss. The signal is the vanishing-gradient story told correctly. Here is the answer.

Everyone says 'gradient descent,' but the batch-size choice and momentum are the real interview content. The signal is the noise-vs-cost tradeoff across batch/SGD/mini-batch and why momentum earns its keep.

The loss defines what the model optimizes, and picking the wrong one quietly dooms it. The signal is matching the loss to the task and data (outliers, imbalance), not defaulting to MSE or cross-entropy on reflex.

Bad initialization makes deep nets fail to train at all, with activations that vanish or explode through depth. The signal is knowing why zero init is fatal and how to match Xavier or He to your activation function.

Dropout is the classic neural-net regularizer, but the signal is whether you can explain why zeroing activations forces redundancy, and the train-vs-inference scaling bug that trips most candidates. Here is the answer.

Data augmentation cheaply expands training data and regularizes models, but valid transforms differ by modality. The signal is the label-preserving constraint and why text is the hard one. Here is the answer.

Two cheap regularizers that fix overconfident classifiers. The signal is knowing that one softens the target and the other softens the input, and exactly why softer signals calibrate the model. Here is the answer.

'The model won't train' has a short list of usual suspects, each with a distinctive loss-curve signature. The shape of the curve names the bug before you touch a single hyperparameter. Here is how to read it.

The idea that models, like students, learn better from easy examples first is intuitive, and sometimes it works and sometimes it does nothing. Knowing when it pays off is the real signal. Here is the honest answer.

Generative training fails in distinctive ways: GANs collapse to a few outputs, diffusion samples come out noisy or blurry. The symptom tells you which knob to turn. Here is the diagnosis.

Boxes and labels, not one tag per image. The signal is choosing two-stage vs one-stage by your latency and accuracy budget, knowing what NMS and anchors actually do, and reporting mAP correctly. Here is the answer interviewers score highest.

Most CV systems fail at the seams: a preprocessing mismatch between training and serving, not the model. The signal is naming every stage from ingestion to serving and the one consistency invariant that breaks teams. Here is the answer.

Cross-entropy is the start, not the answer. The signal is matching the loss to the task structure: focal for detection's background flood, IoU-family for box overlap, Dice for imbalanced masks. Here is how to reason about it.

Semantic labels every pixel by class; instance separates each object. The signal is knowing that one cannot count overlapping objects, why Mask R-CNN adds a mask branch on RoIAlign, and what RoIAlign fixed. Here is the answer.

Most candidates can recite 'maximize the margin'. The dual is where you show you actually understand why only support vectors matter and where the kernel trick comes from. Here is the derivation an interviewer wants.

EM on a Gaussian mixture has a famous failure mode: a Gaussian collapses onto one point and likelihood shoots to infinity. Knowing why, and the three standard fixes, separates people who used sklearn from people who understand it.

Bayesian inference needs an intractable normalizing constant, and MCMC sidesteps it. The signal is explaining the acceptance ratio, detailed balance, and why you can skip the constant entirely. Here is the answer.

The Kalman filter is optimal Bayesian tracking under linear-Gaussian assumptions, and it is two steps repeated forever. The signal is explaining what the gain trades off and when the assumptions break. Here is the answer.

Raw gradient saliency maps are noisy and saturate. Integrated gradients fixes both with two axioms and a path integral, but the baseline choice quietly decides the answer. Here is what a careful candidate explains.

Anyone can say 'filter and dedup.' The signal is the funnel in cost order, the MinHash/LSH banding math, and knowing the shuffle at billions of documents is what actually costs you, plus benchmark decontamination people forget until their eval numbers get challenged.

Scarce GPUs, dozens of models, every team wanting low latency at low cost. The signal is whether you can turn that into one governed serving fleet: continuous batching, KV cache, per-tenant quotas, and cost you can actually attribute.

A GPU-heavy generative system where sampling steps dominate the bill and one bad image is a headline. The signal is the diffusion serving pipeline, the cost levers on per-image GPU time, and a mandatory two-sided safety layer.

Real-time transcription at scale tests streaming ASR, latency budgets, and GPU fleet management under heavy concurrency. The signal is streaming chunked inference with partial results, not batch transcription. Here is the design.

A GPU-heavy generative-audio system with text/genre/lyric conditioning, minutes-long coherence, and copyright constraints. The signal is the generation pipeline plus the async, cost, and safety layer that makes it shippable.

Video generation is image generation plus the brutal constraint of temporal consistency, and it is the most GPU-intensive generative task there is. The signal is diffusion over spacetime plus a serving design that survives multi-minute jobs.

AV perception is safety-critical, real-time, multimodal ML: detect and track everything around the vehicle from multiple sensors. The signal is sensor fusion plus detection/tracking under a hard latency budget and a fail-safe bar. Here is the design.

Taking a cloud-API POC into a bank or defense network kills your model provider, your judge API, and your vendor dashboards all at once. Learn the signed-bundle supply chain, local evaluation loop, and zero-egress observability that make an air-gapped LLM stack actually operable.

The trap is jumping straight to 'add more GPUs.' The signal is profiling first, then applying the cheap, no-retrain levers in the right order. Here is the diagnosis-then-optimize playbook for p99.

At thousand-GPU scale, hardware failure is the norm, not the exception, and a run that cannot resume wastes weeks. The signal is checkpointing strategy, deterministic resume, and minimizing lost work. Here is the fault-tolerant design.

Grid search is the wrong answer at scale. The signal is knowing why random beats grid, how Bayesian optimization and early-stopping schemes (Hyperband/ASHA) spend compute smartly, and how to parallelize without stragglers.

'Just set a seed' is the wrong answer. Reproducibility means pinning the environment, the data, the code, and the hardware-level nondeterminism, all at once. Here is the full checklist and where it leaks.

Four drift tests, four different assumptions. The weak answer lists them; the strong one knows which handles high-dimensional embeddings, which needs binning, and which gives a calibrated p-value. Here is how to choose.

A Deployment and a Service will serve a model, but GPUs break every Kubernetes default: scheduling, probes, autoscaling signals, and rollouts. Here is the setup that survives production, and when KServe earns its complexity.

The interviewer wants real numbers, not 'use a big GPU.' Weights are fixed, the KV cache grows with load, and the lever order decides everything. Here is the back-of-envelope and the serving stack.

The interviewer wants you to know why a model that fits on no single GPU still trains, and to do the optimizer-state memory math that motivates sharding. Here is the parallelism taxonomy and the 16-bytes-per-parameter calculation.

Quantization is the first lever for fitting and speeding up models, and the interviewer wants more than 'use fewer bits.' The signal is knowing what precision buys you, why outliers break naive quantization, and how you prove quality held. Here is that answer.

A favorite at hardware-aware shops. The signal is understanding that attention's cost is memory traffic, not FLOPs, and that FlashAttention is an exact, IO-aware reordering, not an approximation. Here is the answer that shows you think about the memory hierarchy.

The KV cache is why LLM serving is hard, and the interviewer wants the mechanics: what it stores, why it limits concurrency, and the tricks that shrink it. Here is the answer that shows you understand decode-time economics.

Decode is sequential and memory-bound, so latency tricks matter. The signal is explaining speculative decoding's draft-and-verify mechanism (and why it stays exact) plus the other levers and when each applies. Here is the latency toolkit.

Mixed precision is standard at scale, and the interviewer wants the numerics: why FP16 needs loss scaling, why BF16 mostly does not, and what stays in FP32. The signal is understanding dynamic range vs precision. Here is that answer.

A hardware-literacy question, especially at NVIDIA and the labs. The signal is understanding throughput vs latency hardware, the memory hierarchy, and why matrix multiplication maps onto GPUs and TPUs. Here is the architecture-aware answer.

Knowing the algorithms is half the job. The other half is the serving stack that actually delivers throughput inside a latency budget. The signal is matching the server to the workload and naming the four knobs that move the needle.

Distillation buys you a small fast model that keeps most of a big model's quality. The signal is explaining why soft targets transfer more than hard labels, and knowing when to distill versus quantize versus prune. Here is the model-compression answer.

At NVIDIA and the labs this compute-intimacy question is real. The signal is owning the SIMT execution model and the three classic throughput killers, with the concrete fix for each. Here is the low-level answer.

Continuous batching is the single biggest throughput lever in modern LLM serving. The signal is explaining why static batching idles the GPU on variable-length generation, and why PagedAttention is what makes the fix practical.

On-device AI is a real product surface (privacy, offline, latency), and it forces hard constraints. The signal is the quantization plus format plus runtime stack and the tradeoffs you accept under tight memory and battery budgets.

Picking GPUs is a real applied decision, and 'get the biggest one' misses the point. The signal is knowing which spec binds your workload (VRAM, bandwidth, interconnect) and the train-versus-serve difference that flips the answer.

Autoscaling GPUs is not autoscaling web servers: GPUs are scarce and expensive, model loading is slow, and the right signal is not CPU. The signal is scaling on queue and GPU metrics, taming cold starts, and the scale-to-zero economics.

Under load, a shared inference service must decide whose request runs now. The signal is queuing with priorities, backpressure, and fairness wired into batching, not first-come-first-served until the service falls over.

FSDP and ZeRO let you train models too big for one GPU without splitting the compute. The signal is the ZeRO stages (what gets sharded at each level) and the communication you pay for it. Here is the answer.

Distributed training is bottlenecked by GPU-to-GPU communication, and these collectives are how the data moves. The signal is what each one does and which parallelism strategy depends on it. Here is the answer.

Activations, not just weights, can dominate training memory, and gradient checkpointing is the standard fix. The signal is the precise trade: recompute activations in the backward pass instead of storing them. Here is the answer.

When a model is too big for one GPU you split the model itself, not just the data. The signal is distinguishing tensor parallelism (split within a layer) from pipeline parallelism (split across layers) and matching each to the interconnect. Here is the answer.

LLM serving has its own metrics, and one latency number hides the real bottleneck. The signal is splitting prefill from decode and reading GPU utilization as a clue, not a verdict. Here is the diagnostic toolkit.

A PyTorch model in eager mode is not the fastest form for inference. The signal is knowing that ONNX buys portability and TensorRT-style compilers buy hardware-tuned speed, and exactly which optimizations get you there. Here is the answer.

LLM inference has two phases with opposite resource profiles, and co-locating them makes a long prompt stall everyone else's tokens. The signal is knowing why prefill and decode fight, and what separating them costs. Here is the answer.

These four get conflated constantly, but they live at different layers: data processing, distributed training, and general orchestration. The signal is matching the tool to the workload instead of reaching for the one you know. Here is the answer.

Batch size is a training knob with non-obvious effects on speed, memory, and generalization. The signal is the large-batch tradeoffs and the learning-rate-scaling and gradient-accumulation tricks that make scaling actually work.

You rarely write a serving stack from scratch. The signal is knowing what frameworks hand you (batching, multi-model, GPU scheduling) and why LLM-specific servers exist at all when general ones already batch.

OOM is the most common wall in deep learning, and 'buy a bigger GPU' is the weakest answer. The signal is naming the memory consumers, knowing which one dominates, and matching the right lever to it.

nvidia-smi showing 100% can hide that you are using a fraction of the hardware's real compute. The signal is MFU (useful FLOPs vs peak) and the gap between 'the GPU is busy' and 'the GPU is efficient'.

Beyond FP16/BF16, FP8 is the next rung on the precision ladder, and the latest tensor cores compute on it natively. The signal is knowing the two formats, what FP8 actually buys, and why dynamic range forces careful scaling.

At long context the KV cache, not the weights, dominates GPU memory and decode bandwidth. The signal is recognizing it as the binding constraint and naming the levers that shrink it without wrecking quality.

Pruning removes redundant weights to shrink and sometimes speed up a model. The signal is the structured-versus-unstructured split and why only structured pruning reliably wins latency on commodity hardware.

Hosting one full fine-tuned model per customer scales linearly in GPUs and bankrupts you fast. There is a way to put hundreds of variants on one GPU without giving up batching. The interviewer wants to hear how.

CPU-based autoscaling that works fine for a web tier quietly fails on GPU inference: wrong signal, and replicas that take minutes to warm. The interviewer wants the signals you actually scale on and how you hide the cold start.

Paying for accelerators that idle half the time is the most common waste in ML training, and the instinct to add more GPUs makes it strictly worse. The interviewer wants the profiling discipline that finds what is starving them.

The counterintuitive truth of LLM serving: token generation is limited by how fast you can read weights from memory, not by math. Once you see that, the whole optimization menu falls out of one number.

Linear scaling is the marketing number; the real curve bends early for reasons that are physics, not bugs. Here is where the speedup goes and how to claw it back.

A 256-GPU job that wedges with no error at 3am is a special kind of pain. The causes are a short, recurring list. Here is the systematic way to find which one bit you.

Naive 4-bit quantization can tank quality, and the reflex to give up and serve fp16 leaves a big speedup on the table. The accuracy is usually recoverable. Here is the ladder of fixes.

Users feel the p99, not the median, and the tail is where serving systems quietly fail. The causes are queuing and batching effects, not a slow model. Here is how to flatten it.

Dedicating a GPU per model strands most of a fleet on idle silicon. Sharing safely is a real systems problem with four distinct mechanisms, each tuned to a different traffic shape. Here is how to pick.

A serving box that's stable on short prompts crashes the moment a 30k-token request lands, because KV-cache memory scales with sequence length times batch. Here is how to bound it without crashing.

Launching an LLM service on a vibes-based GPU count is how you get paged on day one. Capacity planning for LLMs differs from web services because tokens, not requests, are the unit. Here is how to size it.

A single long prompt can freeze every other user's token stream for hundreds of milliseconds. Chunked prefill slices that prompt so decode keeps flowing. Here is the mechanism and the knob that controls it.

A shared system prompt gets re-prefilled on every request unless the server remembers it. Prefix caching skips that work, but only when the blocks line up exactly. Here is the hashing and eviction machinery underneath.

Round-robin routing wastes a feature that doubles throughput: cache locality. Designing the router means choosing a replica by KV state, not just least-loaded. Here is the two-layer design.

Three batching strategies, three very different latency profiles. Picking wrong leaves throughput or tail latency on the floor. Here is what each one costs and when to use it.

GPU memory runs out long before you run out of conversations to cache. Offloading KV to CPU or NVMe buys capacity, but the interconnect can become the new bottleneck. Here is the bandwidth math.

FP8 serving is fast and usually fine, until it silently degrades on the one workload your benchmark did not cover. The signal is knowing what FP8 breaks and how to validate it. Here is the recipe.

Forcing valid JSON sounds free, but the mask computation can stall every decode step. The fix is precompiling the grammar into a fast automaton. Here is where the cost hides and how to remove it.

Most models do not fill a GPU, so one model per GPU burns money. The three sharing mechanisms (MIG, MPS, swapping) have very different isolation and overhead. Here is how to pick.

Autoscaling reacts in minutes, but a burst hits in seconds, and the gap is where your tail latency dies. Absorbing bursts is about buffers and shedding, not just adding replicas. Here is the playbook.

No single parallelism dimension trains a 175B model on its own. The art is layering three of them onto the right hardware so the expensive communication stays on the fast links. Here is how to size each axis.

ZeRO and FSDP both shard training state across data-parallel ranks, but the magic is in when each shard is gathered and freed. Get the memory accounting and the all-gather timing and you can size any run.

Full activation checkpointing saves memory but burns a flat 30% extra compute. Selective recomputation recovers most of that by only recomputing the cheap, memory-heavy operations. Here is how to pick what to recompute.

The collective communication in distributed training is pure overhead unless it runs while the GPU computes. Hiding it is the difference between 30% and 55% MFU. Here is how the overlap actually works and how you confirm it on a trace.

On a thousand GPUs something fails every few hours. The question is not whether you lose a node, but how many GPU-hours you lose when you do. Checkpoint frequency, sharded writes, and fast restart decide that.

When all-reduce is the bottleneck, the cause is almost always a misconfigured path: traffic on the wrong link, a downed NIC, or a topology NCCL never discovered. Here is the systematic way to find the lost bandwidth.

FP8 promises to roughly double training throughput over BF16, but with only a handful of mantissa bits the numerics are unforgiving. Per-tensor scaling and a selective recipe are what make it converge.

Data, tensor, and pipeline parallelism all leave one sequence's activations on one device, so 200k+ token training hits a wall none of them can fix. The fourth axis shards the sequence itself, and the interview lives in the communication math.

When every request thinks for 30,000 tokens, serving flips from compute-bound prefill to memory-bound decode, and the KV cache becomes the resource you actually schedule. The levers that ruled chat traffic stop being the ones that matter.

Federated learning trains across decentralized devices without centralizing data, but a malicious participant can poison the shared model. The signal is the privacy mechanism plus the outlier-resistant aggregation defenses. Here is the answer.

Encryption covers data at rest and in transit, but the moment you compute on it the data sits in cleartext in memory. Confidential computing closes that gap. The signal is the TEE concept, attestation, and the AI workloads that actually need it.

Federated learning ships gradients, not raw data. The catch: a gradient is computed from the data, so it carries the data. The signal is knowing why 'we only share gradients' is not a privacy guarantee. Here is the answer.

A backdoored model behaves perfectly until it sees a secret trigger, then flips. The signal is explaining why clean test accuracy never reveals it, and what detection actually buys you when the trigger is unknown.

Federated learning keeps data on-device, but it costs you accuracy, debuggability, and engineering complexity. The signal is naming when those costs are justified and when a simpler centralized pipeline with DP wins. Here is the answer.

This is a full interview round (OpenAI's project deep dive, Amazon's Tech Talk), not small talk. It is where they test whether you actually understand the work you claim. The signal is depth, your specific contribution, and the tradeoffs you can defend. Here is how to prepare and deliver it.

AI moves fast enough that learning speed is a core competency, and several companies ask it directly. The signal is a concrete method for ramping fast and a real, recent example of applying something new. Here is how to show learning agility, not just claim it.

Applied AI rarely waits for certainty, and companies (Amazon's Bias for Action, NVIDIA's speed) test whether you can act decisively without freezing or being reckless. The signal is a reversible, well-reasoned call with a plan to validate. Here is the arc that lands.

At the frontier labs this is a real gate, not a pleasantry. They reject strong engineers who cannot articulate genuine motivation. The signal is specific, honest alignment between what you want to build and what this company actually does.

The modal Applied AI design round. Anyone can draw embed-retrieve-generate. The signal is in chunking, hybrid retrieval, the rerank/latency tradeoff, and how you prove it works. Here is the structure that scores.

Agents are over-applied. The strong answer resists the hype: most tasks want a single structured call, and agents earn their cost only under specific conditions. Here is when to reach for one and how to stop it from compounding errors.

The two knobs that make or break a RAG system, and the ones candidates hand-wave. The signal is tuning chunking against recall and knowing exactly what dense retrieval misses that BM25 catches. Here is the reasoning, not the rules of thumb.

Enterprise RAG fails on isolation, not retrieval quality. The signal is enforcing tenant and document-level permissions server-side, at retrieval time, so the model can never surface data a user cannot see. Here is the design that survives a security review.

Moderation is a multi-stage classification problem with brutal tradeoffs: false negatives cause real harm, false positives censor legitimate users, and the adversary adapts. The signal is the tiered pipeline, per-severity precision/recall calibration, and human-in-the-loop. Here is the design.

Most RAG systems ship with no real eval, which is why most RAG systems quietly degrade. The signal is decomposing evaluation into retrieval and generation, and measuring faithfulness separately from relevance. Here is the framework that makes RAG improvements measurable.

This is two questions hiding as one: how would you have caught it before full rollout, and how do you debug it now. Answer both and you signal senior judgment. Here is the staged-rollout and root-cause playbook.

Extreme class imbalance plus a hard latency budget plus an adversary who adapts. The signal is handling imbalance honestly, choosing the operating point from costs, and designing for the feedback loop. Here is the end-to-end design.