Reference

ML Engineer Roadmap

The long-term curriculum: foundations → classical → DL → production.

The map these notes live inside: a sequential spine from foundations through production ML, with specialty branches and a bucket-list checklist.

A long-term curriculum covering foundations through production. Use it as a map: learn sequentially on the spine, then branch into specialties as needed.

Phase 0 — Foundations (months, ongoing)

Programming & software engineering

Python (core language, typing, packaging), Git, Linux basics, debugging, profiling
Data structures & algorithms (enough for interviews and efficient pipelines)
SQL; basic cloud (AWS/GCP/Azure): storage, compute, IAM, networking at a user level

Math & statistics

Linear algebra: vectors, matrices, eigendecomposition / SVD (concept + use cases), norms
Calculus: derivatives, gradients, chain rule (for understanding optimization)
Probability: distributions, expectation, variance, Bayes, MLE / MAP intuition
Statistics: hypothesis testing, confidence intervals, experimental design basics

Core ML literacy

Supervised vs unsupervised vs semi-supervised vs self-supervised vs RL (definitions)
Bias–variance, generalization, overfitting, regularization, cross-validation

Phase 1 — Classical machine learning

Core methods

Linear & logistic regression; regularization (Ridge, Lasso, Elastic Net)
k-NN, Naive Bayes, trees, forests, gradient boosting (XGBoost, LightGBM, CatBoost)
SVMs + kernels (conceptual + when they shine)
Clustering: k-means, GMM, hierarchical; evaluation (silhouette, domain constraints)
Dimensionality reduction: PCA, ICA (awareness), t-SNE / UMAP (mostly visualization)
Recommenders: matrix factorization, implicit feedback (awareness)

Practical ML skills

Feature engineering, encoding categoricals, handling missing data & outliers
Imbalanced data: resampling, class weights, proper metrics
Model selection, hyperparameter search, statistical rigor (leakage avoidance)
Interpretability: SHAP, partial dependence, simpler baselines first

Tooling

numpy, pandas, scikit-learn; experiment tracking basics

Phase 2 — Deep learning

Neural network fundamentals

MLPs, activations, initialization, loss functions, softmax / multi-class
Optimization: SGD, momentum, Adam / AdamW, learning-rate schedules
Regularization: weight decay, dropout, early stopping, data augmentation
Batch normalization, layer normalization (when / why)
Training stability: vanishing / exploding gradients (diagnosis + mitigations)

Convolutional models (vision)

CNN building blocks, modern CNN families (awareness), transfer learning
Object detection / segmentation (conceptually: one-stage vs two-stage)
Video models (high level)

Sequence models

RNN / LSTM / GRU; limitations; seq2seq + attention historically

Transformers

Self-attention, positional encodings, encoder–decoder vs decoder-only
Pretraining / finetuning, prompt engineering (for applied work), parameter-efficient tuning (LoRA, etc., as patterns)

Generative models (breadth)

Autoregressive models, VAEs, GANs (basics + failure modes), diffusion models (high level)

Frameworks

PyTorch or TensorFlow deeply; mixed precision; distributed training awareness

Phase 3 — Specialized application tracks

Pick 2–4 over time; depth follows job or project needs.

Track	Topics
NLP	Tokenization, embeddings, classification / NER / QA patterns, retrieval-augmented systems; evaluation beyond accuracy
Computer vision	Classification / detection / segmentation pipelines; deployment constraints (latency)
Tabular ML in production	Often GBDT-heavy; calibration, monotonic constraints (where used)
Time series	Stationarity, ARIMA / Prophet (awareness), forecasting metrics, leakage in time
Reinforcement learning	MDPs, value / policy methods, exploration; simulators; when RL is / isn’t worth it
Graph ML	Graph convolutions / message passing (awareness); fraud, recommendations
Recommender systems at scale	Two-tower models, candidate generation + ranking, online metrics

Phase 4 — ML engineering / production

System design for ML

Training vs serving separation; batch vs online features; idempotency
Data versioning, model versioning, reproducibility
Latency / throughput, autoscaling, cost tradeoffs

MLOps

CI/CD for ML, pipelines (Airflow, Prefect, Kubeflow — concept-level is fine at first)
Monitoring: drift, data quality, label quality, performance regression alerts
Deployment patterns: batch scoring, real-time APIs, edge (awareness)
Security & privacy basics: access control, secrets, PII handling, model theft risks

Reliability & operations

Incident response, rollbacks, canaries, shadow deployments
Testing: unit tests for features, contract tests, offline / online consistency checks

Phase 5 — Data & platform depth (senior trajectory)

Data engineering awareness: ETL/ELT, streaming (Kafka concepts), warehouses / lakes, schema evolution
Scalable training & inference: data-parallel training, multi-GPU, orchestration (Slurm, K8s at a practical level); quantization, pruning, distillation (when models must be small / fast)
Evaluation at scale: A/B testing, causal caution (when claims require causality), experimentation platforms

Phase 6 — Responsible AI & product sense

Fairness metrics & tradeoffs, bias sources, documentation (model cards)
Robustness / adversarial awareness for deployed models
Translating business metrics to ML metrics; scoping projects realistically

Phase 7 — Communication & leadership

Writing design docs, reviewing others’ work, mentoring
Cost / benefit framing, risk assessment, stakeholder communication

How to use this roadmap

Sequential spine: Foundations → classical ML → DL core → production / MLOps → specialties
Parallel habits: coding + reading papers + building projects + (optionally) competitions
Proof of skill: 2–3 portfolio projects showing end-to-end (data → train → evaluate → deploy / monitor), not only notebooks

Everything bucket list (checklist)

[ ] Math: linear algebra, calculus, probability / stats
[ ] CS: Python, DS&A, SQL, software design
[ ] ML: supervised / unsupervised, evaluation, feature work, classical algorithms
[ ] DL: CNN / RNN / transformers, training practice, generative overview
[ ] Domains: NLP and/or vision and/or tabular and/or recsys (depth as needed)
[ ] Engineering: APIs, containers, CI/CD, reproducibility, monitoring
[ ] Responsible AI + communication

*Last updated: April 2026*