From Python day one to shipping AI in production. Five stages, in honest order.
Most "AI roadmaps" online are dumps of links. They tell you what exists, not what to do. This is the opposite. Five stages. Time budget per stage. The three projects that prove you cleared it. And the one trap at each stage that wastes most learners a year. Written by the people who have walked 11,000+ Modern Age Coders students through it.
The map is below. The cohorts that walk it with you are right here.
View all 60+ courses →Python & AI Kids
The pre-roadmap on-ramp. Real Python at kid pace with first-touch AI tools.
Python Complete Teens
The teen Stage-1 course. Finish here before any ML library work.
AI & ML Complete
The big middle of the roadmap. Maths, classical ML, deep learning, mentor-led.
Generative AI Masterclass
The Stage-5 capstone. LLMs, RAG, agents, evaluation — the engineer's job.
This is not a YouTube playlist disguised as a career plan.
We have watched students lose entire years to "AI roadmaps" that are sixty links to free courses. The links are not the problem. The problem is they are unranked, untimed, and unsequenced. A real path through this material is ruthless about ordering and ruthless about cutting.
This page picks one path. You will not learn everything in AI by following it. You will learn the right things, in the right order, for the goal of becoming a working AI engineer in 14–24 months. Other goals (research, mathematics depth, MLOps specialisation) need other paths. We say so when it matters.
Every stage has a clear "you are done with this when..." signal. No checkbox. A concrete behavioural milestone — the day you sit down and the work just flows. That is when you graduate to the next stage. Not earlier.
One stage at a time. In order. Don't skip.
The single most common mistake we see — and we see it monthly — is students trying to do Stage 4 (deep learning) before they have actually finished Stage 1 (Python fluency). The result is six months of confused frustration. The order below is non-negotiable. Each stage compounds on the previous one.
Python fluency, not Python literacy.
The first stage is unglamorous and the most important. Almost everyone underestimates it. You are not done with Python when you can write a for-loop. You are done with Python when reading other people's code feels easy, when writing a 200-line script feels small, and when debugging is a five-minute habit rather than an hour-long ordeal.
This stage uses no AI at all. No PyTorch. No LLM API. Just Python — language, ecosystem, command line, git. We are building the keyboard fluency that every later stage takes for granted.
What you will learn
- Core language — data types, control flow, functions, classes
- Standard library essentials — pathlib, json, datetime, collections
- Virtual environments, pip, requirements.txt
- Git, GitHub, basic command line
- Reading and debugging error tracebacks
- Writing tests with pytest
Three milestone projects
- A CLI tool that does something real — a budget tracker, a habit logger
- A small Flask or FastAPI web app with a real route
- Read and modify someone else's open-source Python repo
Mathematics, the working amount.
You do not need a maths degree to be an AI engineer. You need a precise, small subset of mathematics, learned well, so the libraries and papers later in this roadmap stop being opaque. We will tell you the exact subset and let you skip the rest. Three subjects. No more.
Linear algebra (vectors, matrices, dot products, projections). Calculus (derivatives, the chain rule, gradient descent). Probability (distributions, expectation, Bayes' rule). That is it. Twenty hours per subject. Sixty hours total. Then a few weeks consolidating with code.
What you will learn
- Linear algebra — matrix multiplication, dot product, eigenvalues at intuition level
- Calculus — derivatives, chain rule, gradient descent
- Probability — distributions, expectation, variance, Bayes' rule
- How to translate maths notation into numpy code
- Just enough statistics to read a confusion matrix
Three milestone projects
- Implement matrix multiplication in pure numpy. Compare with numpy's own.
- Hand-code gradient descent on a one-parameter function. Plot the loss curve.
- Build a small Monte Carlo simulation of a real problem — Plinko, dice odds, an election poll.
Classical machine learning, not yet deep learning.
Before neural networks. Yes, before. Linear regression. Logistic regression. Decision trees. Random forests. K-means clustering. The same arc Andrew Ng's old course took you through, but tighter and with modern tooling. scikit-learn is your home for this stage.
You are learning two things in parallel: classical ML techniques (which still solve 70% of real industry problems) and the surrounding workflow — data cleaning, splits, cross-validation, metrics, the bias-variance tradeoff. The workflow is more important than any individual algorithm.
What you will learn
- Pandas, numpy, matplotlib — the trio of working data scientists
- Regression, classification, clustering — the algorithm families
- Cross-validation, train/val/test splits, common pitfalls
- Metrics — accuracy, precision, recall, F1, ROC
- Feature engineering and feature selection
- Hyperparameter tuning and the curse of dimensionality
Three milestone projects
- Solve a Kaggle "Titanic" or "Housing Prices" problem from scratch, end-to-end, with honest cross-validation
- Build a recommendation system on a public dataset — books, movies, anything
- Deploy one of these as a small FastAPI service. The first time your model talks to the world.
Deep learning, built up from scratch.
Now the neural networks. Now PyTorch. Now the architectures that power every modern AI system. The right way to learn this is from the bottom up — perceptron, multilayer perceptron, backpropagation by hand, then CNN, then RNN, then transformer. Our Inside Neural Networks pillar page is the conceptual companion to this stage.
The middle of this stage is where you will build your first real model from scratch — a small image classifier, a tiny language model. The end of this stage is where you can read a deep learning paper and roughly understand what it is saying. That is a non-trivial milestone.
What you will learn
- PyTorch — tensors, autograd, nn.Module, training loops
- Perceptron through multilayer perceptron through backpropagation
- Convolutional networks for images
- Recurrent networks (briefly) then transformers
- Loss functions, optimisers (SGD, Adam, AdamW)
- Regularisation, batch normalisation, dropout
- How to use a GPU. How to debug an OOM error.
Three milestone projects
- Train an MNIST classifier from scratch — the deep learning equivalent of "Hello, World"
- Build a small image classifier on a non-trivial dataset (CIFAR, custom)
- Implement a tiny transformer language model — see our build-your-own-GPT walkthrough
LLMs, agents, and shipping AI in production.
The home stretch. You can now read papers, train small models, deploy services, and write production Python. Stage 5 brings these together into the actual job: building AI products. RAG systems. Fine-tuned models. Agents that do work. Evaluation pipelines. The full LLM application stack.
This is also the longest stage and the most open-ended. The field is moving fast. The skill at this stage is not what you know — it is how quickly you can learn the next thing. The previous four stages were about building that learning muscle on a stable foundation. Now you use it.
What you will learn
- The full LLM application stack — APIs, prompts, RAG, fine-tuning
- Embeddings and vector databases
- Agent architectures — ReAct, planning, memory, tool use (see our agents pillar)
- Evaluation — how to know your AI app is actually working
- Latency, cost, caching — production realities
- Reading and reproducing the latest papers
Three milestone projects
- Build a RAG application on a real corpus — your company's docs, a textbook, your own notes
- Fine-tune a small open-weight model on a domain-specific task
- Build and deploy a multi-step agent that genuinely saves you an hour a week
The students who finish this roadmap are not the ones who studied the hardest. They are the ones who refused to skip a stage.— What we have learned from teaching this for six years
The MAC courses that walk you through this stage by stage.
Each course below maps to one or two stages of the roadmap. You can self-study every stage if you have the time and discipline; or you can join a live small-batch cohort that runs alongside other learners with a mentor checking your work weekly. Both work. The cohort path finishes 4–6 months faster on average.
For kids, age 8–12 — start Stage 1 early
Junior · weekly liveVibe Coding for Kids
The pre-Stage-1 on-ramp. Scratch through first Python with AI-assisted projects.
Python & AI Kids Masterclass
Real Python with first-touch AI tools. The fastest Stage-1 path for a serious kid.
Kids AI Mastery
The Stage-5 starter pack — using LLM tools to build real things, kid-paced.
For teens, age 13–18 — complete Stages 1–4 by college
Senior · weekly livePython Complete Masterclass
The full Stage-1 course for teens. Finish here before any ML library work.
AI & ML Masterclass · Teens
The Stage 3 and 4 course taught at teen pace — from sklearn through small transformers.
Vibe Coding for Teens
Stages 1 and 5 stitched into a project-led year for teens who want to ship things now.
For adults & college, age 17+ — the engineer track
Pro · weekly livePython Zero to Advanced
The serious Stage-1 course. Finish in three months. Then move on.
AI & ML Complete
The big middle of the roadmap. Maths, classical ML, deep learning. Cohort-led, mentor-checked.
Generative AI Masterclass
The Stage-5 capstone. LLMs, RAG, fine-tuning, agents, evaluation — the modern AI engineer's job.
Tell us where you are. We will tell you what to do next.
The hardest part of any roadmap is honestly figuring out which stage you are actually on. Most learners overestimate by one stage. A senior MAC mentor will spend 25 minutes with you, sample your code, and tell you the truth — and the exact next three months of work. Free. No sales call.
The questions a serious learner asks next.
I am 14 — is this roadmap really for me?
Yes. We have students who started Stage 1 at age 12 and were on Stage 4 by age 16. The roadmap was designed to be age-agnostic above 12; the only thing that changes with age is the weekly time budget and the maturity of the projects. The teen courses listed above are this roadmap, teen-paced.
I am 45, mid-career, no coding background. Should I attempt this?
Yes — with one adjustment. Extend each stage's time budget by 30%. The cognitive part is no harder; what changes is the hours-per-week you can sustain alongside a job. We have placed adults on Stage 5 within 18 months. The full path is 22–28 months for most career-changers. The Coding Comeback for Women programme is built around this exact pacing.
Do I really need to do Stage 3 (classical ML) before Stage 4?
Yes — and this is the single most common skip. Classical ML is where you learn honest evaluation, the bias-variance tradeoff, and what overfitting actually feels like. Without that intuition, your deep learning models will silently leak and you won't know it. Two weeks of classical ML saves you six months of confused debugging in Stage 4. We will fight you on this in the orientation call. Listen to us.
Can I parallelise stages?
Sparingly. Stages 2 and 3 can run in parallel (maths-with-numpy, ML-with-sklearn) and that works well. Trying to run Stage 1 alongside Stage 4 is the disaster pattern — you spend three months looking up syntax instead of learning deep learning. The general rule: the next stage requires the previous one to feel automatic, not just possible.
What if I want to do research, not engineering?
This roadmap is built for engineering. For research, swap Stage 5 for a research path — read papers daily, do reproduction studies, pick a sub-field early, find a mentor in academia. Stages 1–4 are identical. The branch happens at Stage 5.
How much can I expect to earn after Stage 5?
Honestly variable. In India, a Stage-5 finisher with one shipped project commands ₹8L–₹18L for a first AI engineer role; the ceiling is much higher and rising. Globally — US, EU, UK — entry-level AI engineering ranges from $90k to $180k. We are quoting honest median ranges from MAC alumni 2023–2025. The frontier salaries you read about in the news are outliers, not the median.
What about JEE / college simultaneously?
If you are a Class 11-12 JEE aspirant, follow our JEE coding track instead. It compresses Stages 1 and partial-2 into a JEE-friendly 3 hours/week and resumes the full roadmap after JEE Advanced. For college students, the full roadmap fits inside a four-year degree if you give it ten hours a week.
Where do the MAC courses fit if I am self-studying?
You can self-study every stage. The courses give you three things you cannot get alone: a fixed weekly cadence so you do not drift, a mentor who reads your code, and a cohort of peers at the same stage. Roughly 70% of MAC's AI students said in our 2025 survey they would have dropped off without the cohort. Self-study is harder; not impossible. Pick honestly.
What should I read alongside this page?
Three things. How AI Actually Works for the conceptual map. Build Your Own GPT in Python for the Stage 4 capstone. Inside Neural Networks for the deep-learning depth that Stage 4 needs. And, in print, Andrej Karpathy's blog plus Sebastian Raschka's "Build a Large Language Model From Scratch" book.