roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Sets you up for Machine Learning Engineer interviews — building, training, and shipping models to production. Spans Python and math foundations, deep learning, LLMs and fine-tuning, and MLOps.
10054 of 10054 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 10054 new. 0 cut, outside your plan.
The round that sets a machine learning engineer loop apart is ML coding: write k-means, a logistic regression trained by gradient descent, or a single attention layer from plain tensors, with no library doing the fitting. It usually sits beside an algorithms problem rather than replacing it. A breadth conversation on machine learning follows; from middle level up come an ML system design round and often a deep dive into a model you trained, and behavioral questions usually take the final slot. The breadth round is a chain of whys. Why does boosting mostly reduce bias while a random forest mostly reduces variance? Why does a network that validated well misbehave in production until someone notices it was left in training mode, so dropout stayed on and batch norm normalized each request by its own batch? Why does fp16 training need a loss scaler when bf16 usually does not? How much memory does full fine-tuning take once Adam's two moment estimates per parameter are counted, and what does LoRA take off that bill? The design round hands over a product problem, such as ranking search results or moderating uploaded images, and seniority shows in where the answer stops. An early-career candidate picks a model and a metric. A senior one begins from constraints: a latency budget for the scoring call, features computed the same way in the training job and at serving time, labels that arrive weeks late, and what to watch once the input distribution shifts.
The first module pairs computer science fundamentals with mathematics, and the mathematics carries more weight here: [linear algebra, probability and optimization](/topics/found-math-statistics) are the shapes, distributions and gradient steps the model modules take for granted. [Algorithms](/topics/found-dsa) follow because most loops still open with a coding problem. The working tools come next, [Python](/topics/lang-python) and Git, and then data, ordered by size: [SQL](/topics/lang-sql) and relational concepts for the tables training data is usually first found in, [in-memory dataframes and arrays](/topics/data-libraries-concepts) for turning those rows into features, and [distributed processing engines](/topics/data-processing-concepts) for the training set no single machine holds. That middle step comes in two passes: the library-neutral ideas first, then [pandas](/topics/data-pandas), the library tabular exercises in an ML loop usually expect, where the same ideas meet their traps, such as a merge on a non-unique key that silently multiplies rows or a chained assignment that copy-on-write turns into a no-op. The model theory runs from [classical methods](/topics/found-ml-fundamentals) into [deep learning](/topics/found-deep-learning), and only then does [PyTorch](/topics/ai-pytorch) arrive with the other frameworks, when `loss.backward()` is a call to an algorithm you have already traced by hand. Then the plan reverses that habit. [Model hubs](/topics/ai-huggingface-hub) put the tools first: a checkpoint pulled by name with its tokenizer, a dataset loaded beside it, and the Trainer adapting the weights to a new task. The module after them opens the box: [large language models](/topics/found-llms) from the transformer up, what [LoRA and its relatives](/topics/found-fine-tuning-peft) change about the fine-tuning you just ran, and the geometry of the embeddings you produced. Scale follows, for the model that no longer fits on one GPU: data parallelism, then [sharding parameters and optimizer state](/topics/ai-distributed-training-fsdp-deepspeed), the collectives that move gradients, and launches that survive a lost node. From there the concern turns from training a model to keeping one. Testing and [Docker](/topics/cloud-docker) precede the lifecycle tools, because a model is reproducible only when its code and environment are; [experiment tracking](/topics/ai-mlflow-experiment-tracking) and a registry then record which run produced which artifact, SHAP explains its predictions, and cloud concepts say where the GPUs are rented. Serving sits where the design round needs it: [ML system design](/topics/found-ml-system-design) inside general system design, and [serving concepts](/topics/ai-serving-concepts) such as the KV cache and continuous batching, which explain why vLLM, TGI and Triton with TensorRT-LLM are built as they are. Application security and the [behavioral round](/topics/found-behavioral) close the plan.
For a first ML role, the weight falls on the upper half of the plan: the coding round, the mathematics, ML fundamentals and deep learning, to the point where a gradient can be derived on a whiteboard rather than recalled. Senior candidates are usually expected to have trained and shipped models, so their hours go to sharding, the lifecycle tools and serving, and to rehearsing the design round aloud with numbers attached: requests per second, a latency budget, GPU memory per replica. Short on time, lean on importance first: kept to must know, it cuts the long theory modules down to the questions interviewers keep coming back to, and a level range matched to the job trims them further. With months, change study order from by frequency to by topics, since the turn from hubs to internals and the scale module each assume the stretch before them, and spend the extra weeks fine-tuning one open checkpoint with LoRA, tracking its runs and serving it with vLLM, because the deep-dive round asks why the rank, the learning rate and the batch size were set as they were, which is easy to answer for a job you ran and hard to fake for one you did not. The plan ends at the served model. Kubernetes, the orchestrators that rerun a training pipeline when new data lands and the delivery pipelines that carry a new model version into production are the platform beneath it, covered by the [MLOps Engineer roadmap](/roadmaps/mlops). Building an application on a model, with retrieval-augmented generation, agent frameworks and tool calling, is the [AI Engineer roadmap](/roadmaps/ai-engineer).
The round that sets a machine learning engineer loop apart is ML coding: write k-means, a logistic regression trained by gradient descent, or a single attention layer from plain tensors, with no library doing the fitting. It usually sits beside an algorithms problem rather than replacing it. A breadth conversation on machine learning follows; from middle level up come an ML system design round and often a deep dive into a model you trained, and behavioral questions usually take the final slot.
The breadth round is a chain of whys. Why does boosting mostly reduce bias while a random forest mostly reduces variance? Why does a network that validated well misbehave in production until someone notices it was left in training mode, so dropout stayed on and batch norm normalized each request by its own batch? Why does fp16 training need a loss scaler when bf16 usually does not? How much memory does full fine-tuning take once Adam's two moment estimates per parameter are counted, and what does LoRA take off that bill?
The design round hands over a product problem, such as ranking search results or moderating uploaded images, and seniority shows in where the answer stops. An early-career candidate picks a model and a metric. A senior one begins from constraints: a latency budget for the scoring call, features computed the same way in the training job and at serving time, labels that arrive weeks late, and what to watch once the input distribution shifts.
The first module pairs computer science fundamentals with mathematics, and the mathematics carries more weight here: linear algebra, probability and optimization are the shapes, distributions and gradient steps the model modules take for granted. Algorithms follow because most loops still open with a coding problem.
The working tools come next, Python and Git, and then data, ordered by size: SQL and relational concepts for the tables training data is usually first found in, in-memory dataframes and arrays for turning those rows into features, and distributed processing engines for the training set no single machine holds. That middle step comes in two passes: the library-neutral ideas first, then pandas, the library tabular exercises in an ML loop usually expect, where the same ideas meet their traps, such as a merge on a non-unique key that silently multiplies rows or a chained assignment that copy-on-write turns into a no-op.
The model theory runs from classical methods into deep learning, and only then does PyTorch arrive with the other frameworks, when loss.backward() is a call to an algorithm you have already traced by hand. Then the plan reverses that habit. Model hubs put the tools first: a checkpoint pulled by name with its tokenizer, a dataset loaded beside it, and the Trainer adapting the weights to a new task. The module after them opens the box: large language models from the transformer up, what LoRA and its relatives change about the fine-tuning you just ran, and the geometry of the embeddings you produced. Scale follows, for the model that no longer fits on one GPU: data parallelism, then sharding parameters and optimizer state, the collectives that move gradients, and launches that survive a lost node.
From there the concern turns from training a model to keeping one. Testing and Docker precede the lifecycle tools, because a model is reproducible only when its code and environment are; experiment tracking and a registry then record which run produced which artifact, SHAP explains its predictions, and cloud concepts say where the GPUs are rented. Serving sits where the design round needs it: ML system design inside general system design, and serving concepts such as the KV cache and continuous batching, which explain why vLLM, TGI and Triton with TensorRT-LLM are built as they are. Application security and the behavioral round close the plan.
For a first ML role, the weight falls on the upper half of the plan: the coding round, the mathematics, ML fundamentals and deep learning, to the point where a gradient can be derived on a whiteboard rather than recalled. Senior candidates are usually expected to have trained and shipped models, so their hours go to sharding, the lifecycle tools and serving, and to rehearsing the design round aloud with numbers attached: requests per second, a latency budget, GPU memory per replica.
Short on time, lean on importance first: kept to must know, it cuts the long theory modules down to the questions interviewers keep coming back to, and a level range matched to the job trims them further. With months, change study order from by frequency to by topics, since the turn from hubs to internals and the scale module each assume the stretch before them, and spend the extra weeks fine-tuning one open checkpoint with LoRA, tracking its runs and serving it with vLLM, because the deep-dive round asks why the rank, the learning rate and the batch size were set as they were, which is easy to answer for a job you ran and hard to fake for one you did not.
The plan ends at the served model. Kubernetes, the orchestrators that rerun a training pipeline when new data lands and the delivery pipelines that carry a new model version into production are the platform beneath it, covered by the MLOps Engineer roadmap. Building an application on a model, with retrieval-augmented generation, agent frameworks and tool calling, is the AI Engineer roadmap.