Linear algebra, calculus, probability and statistics, taught as the tools you reach for when a model will not train — not as a semester of proofs. Start here if the notation in a paper is what stops you reading it.
Vectors, matrices, projections and eigendecomposition, always attached to the model they show up in.
Derivatives, gradients, the chain rule, and gradient descent built by hand before autograd does it for you.
Distributions, expectation, Bayes and maximum likelihood — the vocabulary every loss function is written in.
Sampling, confidence intervals, hypothesis tests and the A/B test you will be asked to design in an interview.
Floating point, overflow, log-sum-exp and the reasons a correct formula still returns NaN.
Vectorized Python, dataframes, SQL and the pipelines that feed a model. Most of the working day of an ML engineer is spent here, and most interview take-homes are won or lost here.
The Python that ML code is actually written in: types, generators, decorators, context managers and a test suite.
Broadcasting, striding, and deleting the loop — the skill every framework is built on top of.
pandas and Polars, joins, group-bys, time series, and finding the problem in the data before it becomes a problem in the model.
Window functions, CTEs, query plans and the schema design questions that appear in ML interviews.
Encoding, scaling, splits that do not leak, and pipelines that produce the same features in training and serving.
Supervised learning, regularization, tree ensembles, unsupervised methods, recommenders and reinforcement learning. Gradient boosting still wins more production problems than deep learning does, and interviewers know it.
Linear regression derived, implemented and diagnosed — the template every supervised model follows.
Decision boundaries, cross-entropy, thresholds, and the metrics that matter when classes are imbalanced.
L1, L2, cross-validation, learning curves, and deciding what to do next from evidence rather than instinct.
Decision trees to XGBoost and LightGBM — still the strongest baseline on tabular data, and interviewers know it.
Clustering, dimensionality reduction, density estimation and anomaly detection without labels to check yourself against.
Collaborative filtering, matrix factorization, two-tower retrieval and the cold start problem.
MDPs, value and policy methods, Q-learning and policy gradients — the machinery RLHF is built from.
Networks from scratch, then everything that makes a real one converge: initialization, normalization, optimizers, error analysis, convolutions and sequence models. The bridge between knowing the maths and shipping a model.
Forward pass, backward pass and a working network in NumPy before you are allowed to import a framework.
Initialization, normalization, dropout, weight decay and the vanishing gradient -- everything between a network that exists and one that converges.
Learning rate schedules, warmup, batch size effects, gradient clipping and mixed precision.
Error analysis, data-centric iteration, baselines and knowing which experiment to run next.
Convolutions, the architectures that mattered, detection and segmentation, and vision transformers.
RNNs, LSTMs, encoder-decoders and the attention mechanism that replaced them.
Tokenization through to a transformer you have implemented yourself and trained at scale. The architecture every frontier system is built from, understood well enough to modify rather than import.
Byte-pair encoding, vocabulary design, and what an embedding space actually contains.
Self-attention, multi-head attention and a complete transformer implemented from the paper, with every shape written out.
Data pipelines, curricula, stability tricks and the failure modes of long training runs.
Full fine-tuning, LoRA, QLoRA and adapters — adapting a pretrained model on a budget you actually have.
Classification, extraction, summarization and the evaluation each one needs.
Scaling laws, instruction tuning, RLHF and DPO, retrieval, tool-using agents, evaluation that is not vibes, and the diffusion and multimodal families. This is the frontier, and it moves — the track is versioned and kept current.
Objectives, scaling laws, compute-optimal training and how frontier models are actually built.
SFT, reward models, RLHF, DPO and the constitutional methods — how a base model becomes an assistant.
Context construction, decoding parameters, constrained generation and schema-valid output every time.
Chunking, embeddings, vector search, reranking and the evaluation that tells you whether any of it worked.
Tool calling, planning, multi-step execution, memory, and the failure modes that only appear in loops.
Benchmarks, model-graded evaluation, human review and building an eval set that actually predicts production.
Denoizing diffusion, latent diffusion, and the models that put images, audio and text in one system.
Distributed training, GPU kernels, inference optimization, feature and data infrastructure, monitoring, and the cost arithmetic behind every architecture decision. Senior roles are decided on this material.
Requirements, metrics, architecture and tradeoffs — the framework behind every design interview and every real system.
Data, tensor and pipeline parallelism, ZeRO and FSDP, and making a run survive a failed node.
The memory hierarchy, arithmetic intensity, fused kernels and writing your own in Triton.
Quantization, batching, KV cache management, speculative decoding and the latency budget behind them.
Feature stores, streaming versus batch, point-in-time correctness and lineage.
Drift detection, shadow deploys, canaries, rollback and the on-call reality of owning a model.
Unit economics, build versus buy, and making the case for an ML investment to people who do not build models.
The five loops an ML engineer actually faces — breadth, coding, ML system design, depth, behavioral — plus the negotiation conversation at the end. Pairs with the question bank and mock interviews in Pro.
Rapid questions across the whole field, answered at the depth the interviewer is actually probing for.
Algorithms, plus the ML-specific coding rounds — implement k-means, write attention, vectorize this.
Forty-five minutes, a vague prompt and a whiteboard — structured so you finish with time to spare.
Paper discussions, deep dives on your own projects, and the derivations you may be asked to produce.
Stories that hold up to follow-ups, and the compensation conversation at the end.