The AI Interview Ramp — a visual roadmap for AI/ML interviews
Shared foundations, then two lanes: Research Scientist (evals, optimization, scaling, post-training) and Staff MLE / AI Infrastructure (serving, training at scale, checkpointing, RAG) — then a breadth sweep and mock-round drills.
Phase 1 — Foundations first
The architecture, the numbers, and the measurement habits both rooms lean on. Read these regardless of which lane you walk into.
- The Transformer, End to End — The block you draw first in either room — attention on real numbers, the KV cache, RoPE — before you specialize.
- Mixture of Experts, Routed Honestly — Routing, load balancing, and the honest trade-offs of a sparse model — the architecture question most current-model rounds reach for.
- GPU Arithmetic: the Numbers That Decide ML Systems — FLOPs, bandwidth, roofline — the numbers under every claim you will make in either lane, computed instead of guessed.
- Evals & Experimental Design — How you know a change actually helped — the experimental-design discipline a paper reviewer and a systems reviewer both probe.
- Optimization Dynamics: Why Adam, Why Warmup, Why Cosine — Why Adam, why warmup, why cosine — the training-dynamics vocabulary that shows up in loss-curve questions on either side of the table.
- Scaling Laws, Honestly — What a scaling curve predicts, and exactly where it stops being true — the arithmetic behind every "how big should this model be" conversation.
Phase 2 — Go deep in your lane
Two tracks from here. Research drills the post-training math a paper-reading round probes; infra drills the systems that train and serve models at real scale.
Research Scientist track
- Alignment & post-training
- The Post-Training Pipeline (SFT → RLHF → DPO) — SFT → RLHF → DPO end to end — the pipeline behind almost every "how would you align this model" question.
- GRPO Advantage: Z-Score Your Siblings, Line by Line — The three lines of real code that turn a batch of sampled completions into an advantage signal, read close instead of memorized.
Staff MLE / AI Infrastructure track
- Training at scale
- Distributed Training, End to End — A 70B model needs 1.1 TB of state, fourteen times what one GPU holds — data/tensor/pipeline parallelism and the interconnect that decides what you can afford.
- Sharding in JAX — How JAX spreads one array across a device mesh — the sharding annotations that turn a single-device program into a cluster program.
- The SPMD Partitioner: One Program Across a Device Mesh — One program, compiled once, run identically on every device — the partitioner that inserts the collectives for you.
- Anatomy of a FlashAttention Kernel — Why attention is memory-bound and how tiling plus online softmax fixes it — the kernel-level question most infra rounds eventually reach.
- Checkpointing
- The Checkpoint Lifecycle: What Happens Between save() and Durable — Everything that happens between calling save() and the checkpoint actually being durable — the failure modes hiding in that gap.
- What "Atomic" Means on a Filesystem vs. an Object Store — What "atomic" really means on a filesystem versus an object store, and why the difference breaks naive checkpoint code.
- The B-Tree Merge: Thousands of Checkpoint Files into One Atomic Manifest — Merging thousands of per-host checkpoint files into one atomic manifest — the B-tree structure that makes it fast.
- Loading a Safetensors Checkpoint on a Multihost Cluster, Line by Line — Loading a sharded checkpoint on a multihost cluster so every host reads exactly its own bytes, no more.
- Zero-RPC Sharding: How 1,000 Hosts Agree Who Writes Which Bytes — How 1,000 hosts agree on who writes which bytes with zero coordination RPCs.
- Inference & serving
- Design an LLM Serving Platform — Prefill is compute-bound, decode is memory-bandwidth-bound — the roofline behind continuous batching, paged attention, and disaggregation.
- Quantization for Deployment — The bits-per-weight trade that decides your serving cost, computed rather than asserted.
- How Qwix Quantizes Any Flax Model Without Touching Its Code — Quantizing a model without touching its code — the interception trick that swaps ops underneath a Flax model.
Phase 3 — Breadth sweep
Both lanes read the same six here — the applied systems and compiler internals that come up regardless of which room you walked into.
- Design a RAG System — Retrieval-augmented generation as a system — chunking, embeddings, the retriever, and the latency budget the LLM call has to fit inside.
- Design a Recommendation System (in the LLM Era) — The funnel from candidate generation to ranking to re-ranking — recsys design in the LLM era.
- Design a Feature Store — The dual store that keeps a training-time feature and a serving-time feature meaning the same thing.
- ML Reliability in Production — What actually breaks in a production ML system, and the guardrails that catch it before a user does.
- Inside XLA: ~200 Passes and the Fusion Decision — What happens between your model code and the GPU kernels that run it — roughly 200 compiler passes and the fusion decision that dominates them.
- Tracing → jaxpr: the One Trick Behind Every JAX Transform — The one trick — tracing a Python function into a typed graph — behind jit, grad, and vmap alike.