Machine learning engineer roadmap: seven stages, each with a checkpoint

A machine learning engineer turns a model into software other people can rely on. The work is preparing data, training and evaluating models honestly, and running them in production where they are tested, monitored and retrained. To get there, learn in seven stages: (1) Python written as software, (2) the data tools, (3) the maths and statistics a model uses, (4) classical machine learning, (5) production habits, (6) deep learning and a specialism, and (7) a portfolio that proves each of the earlier stages. Move on when you can pass a stage's checkpoint without copying code.

If you only want the order for learning machine learning itself, read where to start with machine learning. This roadmap goes further: it adds the engineering that separates someone who trains models in a notebook from someone who ships them.

The seven stages at a glance

Stages 3 and 4 overlap. Learn each piece of maths just before the model that needs it, not all of it up front.

Stage 1: Python, written as software

Most machine learning tutorials teach Python as a calculator. An engineer needs Python as a language for building things that other people run. Beyond the basics, learn:

• Defining functions and arguments and scope, so code is reusable rather than copied between cells.
• Modules and packages and uv, packages and environments, so a project installs the same way on any machine.
• Exceptions and debugging, so a bad input fails clearly instead of silently.
• Testing with assert and pytest and formatting, linting and type checking, the habits every code review expects.
• Classes and objects, dataclasses and the estimator pattern, which is how scikit-learn and most ML libraries are designed.
• Time and space complexity and hash tables, because data work is where slow code first hurts.

The Python track starts from zero, and its first ten lessons, from Why Python? to loops, have free videos. If you are new to the language, read Python for machine learning for what to learn and what to skip.

Checkpoint: write a function that cleans a list of records, put it in a module, add a pytest test that covers a bad record, and install the project in a fresh environment with uv.

Stage 2: The data tools

Before a model sees data, someone has to load it, clean it, join it and look at it. The Data Tools track covers the four libraries in the order you will use them:

1. NumPy: shape, dtype and reshaping, indexing and masks, and vectorised operations and broadcasting. Shape errors are the most common bug in model code; this is where you learn to read them.
2. pandas: cleaning data, groupby and aggregation, and merging, joining and reshaping. A wrong join silently duplicates or drops rows, which is a modelling bug that no model can fix.
3. Matplotlib and seaborn: readable charts, so you look at the data before you trust a metric.
4. scikit-learn: estimators: fit, predict, transform and pipelines. A pipeline keeps preprocessing inside cross-validation, which prevents data leakage.

Run one complete model early, even before you understand its inside. Machine learning code in Python walks through a full example.

Checkpoint: load a table with missing values and a second table to join, clean and merge them, plot the target against two features, and fit a scikit-learn pipeline that beats a do-nothing baseline on held-out data.

Stage 3: The maths and statistics a model uses

Engineers need the maths for intuition and debugging more than for proofs. When a loss goes to nan, a gradient vanishes or a metric looks too good, the maths tells you where to look. The specific set is listed in prerequisites for machine learning; these lessons cover it:

• Reading formulas: reading ML notation and the maths inside one prediction.
• Linear algebra: the dot product, the matrix–vector product, and later the covariance matrix and singular value decomposition for dimensionality reduction.
• Calculus: derivatives (free video), partial derivatives and the gradient, and the chain rule through a computation, which is backpropagation in miniature.
• Numerics: floating point and numerical stability, the reason libraries compute log-probabilities instead of probabilities.
• Statistics: who is in the dataset, Bayes' theorem, maximum likelihood estimation, confidence intervals, and cross-entropy and log loss, the loss most classifiers minimise.

The Maths and Statistics tracks show each idea on a picture first. Their opening modules are part of the free sample. For a shorter path through the statistics, read statistics for data science.

Checkpoint: take the formula for logistic regression's prediction and its log loss, and explain in plain words what each symbol is, what the gradient tells the model to do, and why the loss is computed on log-probabilities.

Stage 4: Classical machine learning

Learn how the classic algorithms work, not only how to call them. Classical models still run most predictions on tables of business data, and they teach the evaluation discipline every later model needs.

Start with linear regression trained by gradient descent. The Machine Learning course opens its regression module with three free video lessons: linear regression, gradient descent and gradient descent for linear regression.

Then follow the order in the course outline:

1. A first classifier and generalisation: k-nearest neighbours, overfitting and underfitting, the test set and cross-validation.
2. Measuring a model: the confusion matrix, precision and recall, thresholds and ROC curves, imbalanced data, and evaluating regression properly.
3. Probabilistic and linear classifiers: Naive Bayes, logistic regression and support vector machines.
4. Preparing data: encoding, scaling, missing values and leakage.
5. Trees and ensembles: decision trees, random forests and gradient boosting, usually the strongest choice for tabular data.
6. Explaining models, dimensionality reduction, clustering and anomaly detection.

The course outline lists every lesson in that order. Lessons that are still being recorded are labelled.

Checkpoint: implement linear regression with gradient descent in NumPy and match scikit-learn's LinearRegression coefficients on the same data. Then train a classifier on an imbalanced dataset and explain why accuracy is the wrong metric for it.

Stage 5: Production habits

This stage is what makes you a machine learning engineer. A model in a notebook helps one person once. A model in production has to give the same answer for the same input, handle bad inputs, and tell someone when it stops working.

Learn to:

• Make training reproducible. Pin the environment, fix random seeds, save the configuration with every result, and retrain from a single command.
• Package and serve a model. Save the fitted pipeline, not just the model, so preprocessing travels with it. Put it behind a small HTTP API that validates its inputs. Learn enough Docker to run it the same way anywhere.
• Compare models honestly. A higher score on one test set can be noise. Permutation and resampling tests and designing and reading an A/B test show how to tell.
• Monitor and retrain. Log the inputs and predictions, watch whether the input distribution drifts from the training data, and decide in advance what triggers retraining.

The Machine Learning course's final core module, Models in the Real World, is built for this stage: probability calibration, whether model B is really better, A/B testing a model, from notebook to production, monitoring and drift, reproducibility and experiment tracking, fairness and privacy. Its lessons appear in the outline as they are released.

Checkpoint: someone else can clone your project, run one command to retrain the model, start an API, send it a request and get a prediction, and send it a malformed request and get a clear error.

Stage 6: Deep learning and a specialism

Most modern AI roles expect deep learning. It builds on everything above: a neural network is trained by the same gradient descent, its loss is the same cross-entropy, and it is evaluated with the same test-set discipline. Learn how backpropagation works, how to train a network reliably (learning rates, initialisation, regularisation, reading loss curves), and the main architectures: convolutional networks for images and Transformers for text and more. Learn one framework well; PyTorch vs TensorFlow helps you choose.

SchoolWhool does not have a deep learning track yet. The deep learning course roadmap sets out a study order, and machine learning vs deep learning explains when each is the right tool.

Then specialise:

• Computer vision: classification, detection and segmentation. Start from what is computer vision.
• Natural language processing and LLMs: text classification, search, and building on language models. Start from what is natural language processing and transfer learning vs fine-tuning.
• Tabular and time-series modelling: forecasting, ranking and recommendations, where gradient boosting and careful evaluation often beat deep learning.

If you are drawn to building products on top of existing models rather than training them, read AI engineer vs machine learning engineer before you choose.

Checkpoint: train a small network, plot its training and validation loss, change one thing (learning rate, size or regularisation), and explain why the curves moved the way they did.

Stage 7: A portfolio that proves each stage

Two or three complete projects beat ten half-finished ones. A reviewer is checking for the stages above, so make each one visible:

Machine learning portfolio projects gives three project briefs with evaluation plans. The Statistics track's end-to-end EDA project lab is a guided first project that ends in a decision, not just a chart.

Write up what did not work as well as what did. A rejected approach, a leak you found or a metric that misled you shows a reviewer more judgement than another library on a list.

How long does it take to become a machine learning engineer?

It depends on where you start and the hours you put in, so any fixed number would be a guess. Measure progress by checkpoints instead: when you can pass each one without looking up every line, you have the skills the stage stands for. Keep a short log of what you built at each checkpoint and where you got stuck.

Do I need a degree?

You can learn every topic on this roadmap without one, from free lessons, textbooks and documentation. Whether an employer requires a degree depends on the employer and the role. Where it does not, a portfolio that passes stage 7's table is how you show what you can do.

Should I learn deep learning first?

No. Deep learning code you cannot debug teaches very little. Stages 1 to 5 give you the tools to tell whether a neural network is learning or just memorising, and that is the skill deep learning work depends on.

Your next step

Open the learning path and start at the first stage you cannot pass yet. Lesson parts and key terms are free to read, and so are the free videos. A free account adds the quizzes and saves your progress across every course, with no payment.

To choose a course for each stage, see the best machine learning course comparison. For a shorter version of this roadmap, follow how to learn AI from scratch in 12 weeks.