Home › Guides › Machine Learning Roadmap
Tech Explained · 2026Machine Learning Roadmap 2026: A 20-Week Plan, Weekly Milestones and the Code You Actually Write
A machine learning roadmap is a sequenced plan for learning to build, evaluate and ship predictive models. A realistic version takes about 20 weeks at eight hours a week: Python and pandas first, then supervised models, then evaluation, then deployment. Skip the heavy mathematics until week 11, because untested models fail on validation, not calculus.
- Twenty weeks is the honest number at eight hours a week, and roughly 40% of that time goes to evaluation and data prep rather than to models.
- Train a dumb baseline before anything else. On the dataset worked through below, predicting the majority class alone scored 63.16% accuracy, which is the number any real model has to beat.
- The fancier model lost. A scaled logistic regression hit 98.25% accuracy against gradient boosting's 95.61% on the same split, and that ordering is common on small tabular data.
- A single train/test split is a lottery. Changing only the random seed across 20 runs moved accuracy between 95.61% and 100%, a spread of 4.39 points.
- Data leakage can manufacture a 79.5% score from pure noise. The reproducible demonstration is in the evaluation section, and it is the single most valuable thing on this page.
- Versions matter when you install. scikit-learn 1.9.1 on PyPI requires Python 3.11 or newer, so a Python 3.10 environment will quietly resolve to an older release.
Your notebook reports 94% accuracy, you send the screenshot to your lead, and the first question back is "what does it score if it just guesses the common answer?" You do not know. That one question is the gap between people who have finished a machine learning course and people who get hired to do machine learning, and no amount of extra model-fitting closes it. This roadmap is built around closing it.
The reader I have in mind throughout is a backend developer in Pune, 2021 batch, comfortable with Python and SQL from work, with about eight spare hours a week and no mathematics beyond first-year engineering. Every week below is sized for that person. If you have twenty hours a week, halve the calendar; if you have four, double it, but do not reorder the phases.
What a Machine Learning Roadmap Should Actually Cover in 2026
Most published plans are reading lists with weeks attached. The problem is not the content, it is the proportion: they put linear algebra and calculus in weeks 1 to 6, which is exactly when a learner has no model to apply them to, and they put evaluation last, which is where almost every real failure lives.
So here is the opinion this page commits to. Defer the mathematics. Spend the first ten weeks getting a model to run honestly end to end, then go back and learn the mathematics of the two or three models you actually used. You lose some depth in weeks 1 to 10 and you will not be able to derive gradient descent on a whiteboard in month two. The trade is worth it, because the thing that gets you past a screening round is a project whose numbers hold up, not a derivation.
The four layers worth your time, in this order:
Where the 20 weeks actually go
Note how little of it is models, and how much is the work either side of them.
Recommended effort split from this guide's own plan, not a survey figure. Checked 11 October 2026.
The 20-Week Machine Learning Roadmap, Week by Week
Each phase ends in something you can show someone. That constraint is what stops a roadmap turning into a tutorial queue you never leave.
The 20-week plan at eight hours a week
Every phase ends in an artefact, not a finished video course.
Python, pandas and looking at your data
Load a messy CSV, fix dtypes, handle missing values, group and join. Deliverable: a notebook that answers five business questions about one dataset with charts, and no model in it at all.
Your first supervised models
Linear and logistic regression, decision trees, k-nearest neighbours. Deliverable: a classifier that beats a majority-class baseline, with the baseline number written down next to it.
Pipelines and ensembles
scikit-learn pipelines, column transformers, random forests and gradient boosting. Deliverable: the same project refactored so that every preprocessing step lives inside the pipeline object.
Evaluation, cross-validation and leakage
Precision, recall, ROC AUC, stratified k-fold, class imbalance, threshold choice. Deliverable: a written half-page on why your chosen metric is the right one for your problem.
Feature engineering and the mathematics you now need
Encoding, scaling, target encoding and its dangers, plus the linear algebra and partial derivatives behind the models you have already fitted. Deliverable: a measured improvement over week 10's score.
Shipping it
Experiment tracking, a model registry, an inference API, a drift check. Deliverable: a running endpoint someone else can call, with the training run recorded and reproducible.
Sized for roughly eight study hours a week. Checked 11 October 2026.
A deep learning primer belongs somewhere in weeks 18 to 20, and PyTorch 2.14.1 is the current PyPI release as of today, requiring Python 3.10 or newer. Resist starting there. Tabular business problems, which are most of the paid work in India, are still won by gradient boosting far more often than by neural networks.
Also read: Python for Data Analysis in 2026: A 10-Week Beginner Roadmap With Weekly Milestones, which is the gentler on-ramp if weeks 1 to 4 below feel too fast.
Weeks 1 to 4: Set Up an Environment That Will Not Fight You
Pin your versions on day one. The commands below are what the Pune developer would run, and the version constraints come from the PyPI metadata for each package as of 11 October 2026: scikit-learn 1.9.1 declares requires_python >=3.11, pandas 3.0.6 does the same, while MLflow 3.17.0 and PyTorch 2.14.1 still accept Python 3.10.
python3.11 -m venv .venv
source .venv/bin/activate
pip install "scikit-learn==1.9.1" "pandas==3.0.6" "mlflow==3.17.0"
python -c "import sklearn; print(sklearn.__version__)"
# 1.9.1
Here is what usually goes wrong. You install into the system Python 3.10 that shipped with your distro, pip cannot satisfy scikit-learn 1.9.1, so it silently resolves an older release instead and three weeks later a tutorial's keyword argument does not exist and you blame yourself. Check the printed version, every time, before you blame your code.
Machine learning for beginners: the habit that matters most in month one
Spend week 1 to 4 refusing to fit a model. Load one dataset, plot every column, find the nulls, find the duplicated rows, find the column that is secretly a date stored as text. This feels like procrastination and it is the opposite. The 15% of your time this roadmap assigns to feature work is only productive if you can already see your data, and a live Data Analyst course covering Excel, SQL, Python and Power BI teaches exactly this layer in a structured way if self-study stalls here.
Weeks 5 to 10: Your First Real Model, and Why the Baseline Comes First
A scikit-learn tutorial in 30 lines: baseline first, then two models
This is a complete, reproducible worked example. It uses a dataset bundled with scikit-learn, so it needs no download and no GPU, and the numbers below were produced by running this code on scikit-learn 1.9.1 on 11 October 2026.
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import roc_auc_score
X, y = load_breast_cancer(return_X_y=True, as_frame=True)
print(X.shape, round(y.mean(), 4)) # (569, 30) 0.6274
Xtr, Xte, ytr, yte = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=42)
dummy = DummyClassifier(strategy="most_frequent").fit(Xtr, ytr)
print("baseline:", round(dummy.score(Xte, yte), 4)) # 0.6316
logreg = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
logreg.fit(Xtr, ytr)
print("logreg:", round(logreg.score(Xte, yte), 4),
round(roc_auc_score(yte, logreg.predict_proba(Xte)[:, 1]), 4))
# 0.9825 0.9954
hgb = HistGradientBoostingClassifier(random_state=42).fit(Xtr, ytr)
print("boosting:", round(hgb.score(Xte, yte), 4),
round(roc_auc_score(yte, hgb.predict_proba(Xte)[:, 1]), 4))
# 0.9561 0.9901
Read the output rather than the code. Three things in it are worth more than a month of videos.
| Model | Test accuracy | ROC AUC | What it tells you |
|---|---|---|---|
| Majority class only | 63.16% | 0.5000 | The floor. A model at 70% is barely working, not "pretty good". |
| Logistic regression, scaled | 98.25% | 0.9954 | Thirty-five points above the floor from a model you can explain in an interview. |
| Histogram gradient boosting | 95.61% | 0.9901 | More complexity, worse result. Default settings are not a serious attempt. |
First, 63.16% was free. Any score you report without its baseline is uninterpretable. Second, StandardScaler is inside the pipeline, not applied to the whole frame beforehand, which is the difference between an honest number and the one in the next section. Third, the simpler model won here, by 2.6 accuracy points. On 569 rows with 30 clean numeric features, that is not an upset, it is the expected outcome, and a learner who has internalised it stops reaching for boosting on every problem.
How to Learn Machine Learning Without Paying for Compute
Weeks 1 to 16 of this plan need no GPU at all. The example above trains in under a second on a laptop. You will want hosted compute around week 18, when you touch deep learning, and the free tiers are real but conditional in ways worth knowing before you depend on one.
| Option | What you get free | The catch | Use it for |
|---|---|---|---|
| Your own laptop | Everything in weeks 1 to 16 | None worth worrying about | All tabular work. Do not skip to the cloud. |
| Google Colab free tier | A hosted notebook, usually a T4 GPU when one is available | Google's own FAQ describes free access as subject to "dynamic usage limits that sometimes fluctuate" and says it does not provide guaranteed or unlimited resources; runtimes time out when idle | Short GPU experiments you can afford to lose |
| Kaggle Notebooks | GPU and TPU sessions plus hosted datasets | Kaggle's documentation is quoted as capping execution at 12 hours for CPU and GPU sessions and 9 hours for TPU; the widely repeated figure of roughly 30 GPU hours a week is user-reported, not a published commitment | Competitions, and any week-18 fine-tuning run |
| Colab Pro | Paid, not free | Third-party pricing read from the signup page in September 2026 listed Pro at 9.99 USD a month for 100 compute units and Pro+ at 49.99 USD for 600; verify on the signup page before buying | Only once you have a specific run that needs it |
My advice, and it costs you nothing: do not buy compute during this roadmap. If you reach week 18 and a run genuinely will not fit in a Kaggle session, that is the moment to pay, and not before.
Weeks 11 to 16: Evaluation, Leakage and the Mistake That Fakes a 79.5% Score
This is the section that separates the roadmap from a tutorial list. Run the code below. It builds a dataset of 200 rows and 5,000 columns of pure random noise, with a random label. There is no signal in it. None. A correct evaluation must land near 50%.
import numpy as np
from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
rng = np.random.default_rng(0)
X = rng.normal(size=(200, 5000)) # pure noise, zero real signal
y = rng.integers(0, 2, size=200)
cv = StratifiedKFold(5, shuffle=True, random_state=0)
# WRONG: pick features using all the data, then cross-validate
Xsel = SelectKBest(f_classif, k=20).fit_transform(X, y)
print("leaky: ", round(cross_val_score(
LogisticRegression(max_iter=1000), Xsel, y, cv=cv).mean(), 4))
# 0.795
# RIGHT: selection inside the pipeline, refitted on each training fold
pipe = Pipeline([("sel", SelectKBest(f_classif, k=20)),
("clf", LogisticRegression(max_iter=1000))])
print("honest:", round(cross_val_score(pipe, X, y, cv=cv).mean(), 4))
# 0.545
Cross-validated accuracy on a dataset with no signal in it
Selecting features before splitting invented 25 points of performance out of nothing.
What leaky feature selection scored on pure random noise, against 54.5% when the same selection was moved inside the pipeline. Both figures were produced by running the code above on scikit-learn 1.9.1.
Reproduced locally on scikit-learn 1.9.1, 11 October 2026.
Twenty-five points of performance, conjured from random numbers, by one ordering mistake. This is how portfolio projects that score 0.97 in a notebook score 0.6 in production, and it is the first thing an experienced interviewer probes when a number looks too good. The fix is mechanical: every transformation that learns anything from the data, which means scalers, encoders, imputers, feature selectors and target encoders, goes inside the Pipeline. Never before the split.
-
No baseline. Fit
DummyClassifierfirst, every single time. It takes four seconds. -
Trusting one split. Running the earlier logistic regression across 20 different
random_statevalues moved test accuracy between 95.61% and 100%, a 4.39 point spread. Five-fold cross-validated AUC on the same data was far more stable at 0.9953 with a standard deviation of 0.0053. Report the cross-validated number. - Accuracy on imbalanced data. At a 2% fraud rate, predicting "never fraud" scores 98% and catches nothing. Use precision, recall and AUC.
- Tuning on the test set. If you have adjusted anything after looking at the test score, that score is now a training score. Keep a third split you touch once.
Also read: Python Projects for Beginners in 2026: 6 Builds, Code Skeletons and Free Datasets for project scaffolding you can apply this evaluation discipline to.
Finished weeks 1 to 16 on your own? The AI Engineer Course is where the shipping half gets taught live
The course description puts it plainly: most courses teach you to chat with a model, this one teaches you to build agents that plan, use tools and act, certified on both Microsoft Copilot Studio and Claude Code. It runs 100+ hours live over 16 weeks, which is the same order of effort as the roadmap above, with someone reviewing your work.
Explore the course
Weeks 17 to 20: What Shipping Looks Like, Using Swiggy's Ranking Stack
InfoQ reported in May 2026 on how Swiggy rebuilt search autocomplete ranking. The shape of it is the best argument available for why weeks 17 to 20 exist. Swiggy replaced hand-tuned heuristic ranking with a learned ranking model running inside OpenSearch. Click-through rate, conversion and ordering behaviour stream into offline training pipelines; a feature store serves both precomputed and streaming features, so the system can react to recent user behaviour without recomputing everything in real time; trained models land in a model registry before deployment.
Count the machine learning in that description. One model. Everything else is plumbing: feature serving, training pipelines, a registry, an online store. That ratio is what the job is, and it is why the last four weeks of this roadmap are not optional garnish.
The loop you are building in weeks 17 to 20
The highlighted box is the only place preprocessing may be fitted. Everything else is operations.
Structure drawn from InfoQ's May 2026 report on Swiggy's autocomplete ranking system. Checked 11 October 2026.
The two tools to learn, and nothing more
Use MLflow for tracking and the registry; version 3.17.0 is the current PyPI release and accepts Python 3.10 or newer, so it will install into almost any environment you already have. Then wrap the model in a small FastAPI service. That is enough. Resist Kubeflow, Airflow and a feature store in week 18; you will add machinery you cannot debug. If you want the operations half taught properly rather than scavenged, 360DT's MLOps Engineer course built around Azure AI-300 covers tracking, registries, endpoints and drift monitoring live, and the Microsoft Fabric data engineering program for DP-700 is the right companion if the feature pipelines are the part of the Swiggy story that interested you most.
import mlflow
from sklearn.model_selection import cross_val_score
mlflow.set_experiment("churn-baseline")
with mlflow.start_run():
scores = cross_val_score(pipe, X, y, cv=cv, scoring="roc_auc")
mlflow.log_param("model", "logreg+scaler")
mlflow.log_metric("cv_auc_mean", scores.mean())
mlflow.log_metric("cv_auc_std", scores.std())
mlflow.sklearn.log_model(pipe, name="model")
What This Machine Learning Roadmap Deliberately Leaves Out
Two honest caveats, because a plan that claims to cover everything is lying to you.
The first: this is not a path to a research role. If you want to work on model architecture at a lab, you need the mathematics early and properly, a master's degree is close to mandatory, and twenty weeks of applied scikit-learn will not substitute. This roadmap is for the applied job, which is the one that actually has openings in Bengaluru, Pune and Hyderabad.
The second is sharper. Classical machine learning and AI engineering have genuinely split into two careers, and a lot of 2026 content pretends otherwise. If your interest is chatbots, retrieval and agents, you need embeddings, retrieval quality and prompt evaluation far more than you need random forests, and weeks 5 to 16 of this plan are the wrong investment for you. Read How Do Large Language Models Work? Tokens, Embeddings and Attention Explained for 2026 first, and if that is the direction that pulls you, the Generative AI Developer course mapped to Azure AI-103 or the CCDV-F developer certification prep is a straighter line than this roadmap is. The full certifications overview lays out which route each credential belongs to.
The step most people can skip
Deep learning from scratch in month two. Building a neural network with raw NumPy is a lovely exercise that teaches you backpropagation and will not appear in a single interview for an applied role in India. Do it in month six if you are curious. If your target is cloud and deployment work instead, the AWS Solutions Architect and DevOps course is a more direct use of those same twenty weeks.
Related guides
- AI Engineer vs Machine Learning Engineer in 2026: Salary, Skills and Which Role to Pick in India settles the fork this guide's second caveat raises, before you spend twenty weeks on the wrong one.
- What Is an MLOps Engineer in 2026? Role, Skills, AI-300 Certification and Career Path in India is the job description that weeks 17 to 20 are actually training you for.
- MLOps Engineer Salary in India 2026: Advertised Pay by Experience, Company Type and Skill Stack tells you what the deployment half of this skill set is advertised at.
- AI Engineer Interview Questions 2026: 18 Real Questions With Model Answers is the pressure test for week 20, and several questions target exactly the leakage trap above.
- What Is Apache Spark? How It Works, Spark vs Hadoop and Your First PySpark Job in 2026 is the next thing to learn once your training data stops fitting in pandas.
- Data Scientist Salary in India 2026: What 17,000+ Listings Pay and Where the Money Moved is useful for deciding whether the adjacent title pays better than the one you are aiming at.
What I Would Do in Your Position
Start tomorrow with weeks 1 to 4 and do not buy anything. Four weeks of pandas on one dataset you actually care about, with no model in the notebook, will put you ahead of most people who have watched three times as much material. Then fit the dummy classifier before the real one, keep every transformation inside the pipeline, and run the noise experiment from the leakage section yourself so that 79.5% becomes a number you have seen rather than a claim you read.
Where self-study reliably breaks is weeks 17 to 20, because nobody reviews your work and a model that serves predictions to one user on localhost teaches you almost nothing about serving predictions to thousands. That is the part worth paying for. Sit in on a free webinar first to see whether the teaching style suits you, then take the AI Engineer course for the shipping half, or book a demo class and ask the trainer to walk you through how they would deploy the model you built in week 16.
Frequently asked questions
How long does it take to follow a machine learning roadmap from scratch?
About 20 weeks at eight hours a week, or roughly 160 hours, if you already write Python comfortably. Without Python, add six to eight weeks at the front. The common failure is not slowness, it is skipping the evaluation phase in weeks 11 to 16 and ending up with projects whose numbers nobody can trust.
Do I need to learn maths before machine learning?
Not before. School-level algebra and an intuition for averages and distributions are enough to start. Learn the linear algebra and partial derivatives in weeks 14 to 16, once you have fitted the models those ideas describe, because the mathematics is far easier to absorb when it explains something you have already seen behave oddly.
Which programming language is best for machine learning in 2026?
Python, without a serious rival for learning. scikit-learn 1.9.1 requires Python 3.11 or newer per its PyPI metadata, so install 3.11 or 3.12 rather than whatever your operating system ships. SQL is the necessary second language, because the training data almost always starts in a database.
Can I learn machine learning for free?
The first 16 weeks of this plan, yes, entirely on a laptop with free libraries and public datasets. What free resources do not give you is someone telling you your validation is wrong, which is the error you cannot detect yourself by definition. That is the specific thing a live cohort or a code review buys.
Is scikit-learn still worth learning, or should I start with PyTorch?
Start with scikit-learn. Most paid machine learning work in India is tabular prediction, where gradient boosting and logistic regression still win, as the worked example above shows. PyTorch 2.14.1 is current and worth a primer in weeks 18 to 20, but reaching for it first means learning deep learning before you can evaluate a model honestly.
What should my first machine learning project actually be?
A binary classifier on tabular data, with the majority-class baseline written in the README next to your score, all preprocessing inside a scikit-learn pipeline, and a cross-validated metric rather than a single split. That README line about the baseline does more in an interview than a second project would.
How do I know if my model result is real or leaked?
Three checks. Did anything learn from the data before the split? Is your score suspiciously far above the baseline for the amount of signal you would expect? Does it hold under five-fold cross-validation, where the noise example above collapsed from 79.5% to 54.5%? If a number feels too good, assume leakage and go looking.
Is a machine learning certification worth it for getting hired in India?
A certification gets a resume read; a project with honest evaluation gets you through the technical round. If you are choosing, pick a credential whose syllabus forces you to build and deploy something, such as the deployment-focused Microsoft and Claude tracks, rather than one that tests terminology. Do it alongside the roadmap, not instead of it.
About this guide. 360 Digital Transformation is an Anthropic Partner and a Microsoft Authorized Training Partner. Other certification bodies, vendors and employers named here are not affiliated with us. Tools and versions change quickly; commands and figures cited were checked on 11 October 2026.
Python
Claude API
FAISS
ChromaDB
LangChain
LangGraph
CrewAI
AutoGen (AG2)
