Learn AI engineering from zero: the build-first roadmap

This is the roadmap we would follow if we had to learn AI engineering from zero today. It has six stages. Each one names the free material to learn from, and each one ends in a project you build, run and show. The projects are the point. Courses tell you how something works; a project is where you find out whether you understood it.

The order, the projects and the time estimates are our opinion. None of the courses or tools below is made by webridgeAI, and we have no arrangement with any of them. Every course detail, price and limit quoted here comes from the resource's own page, read on 18 October 2026. Free tiers and course pages change, so check the page before you plan around a detail.

How this roadmap works

Three rules run through every stage.

1. Every stage ends in a project you ship. Not a quiz, not a certificate. A repository with working code, a README and, from stage 2 on, something another person can try. If you finish a course and have nothing to show, you have done half the stage.

2. Watch less, build more. As a rule of thumb (ours), spend one hour watching or reading for every two to three hours typing, breaking and fixing. If you notice you have watched three lectures in a row without opening an editor, stop and build.

3. One course per stage, finished. Each stage lists one main course and sometimes an alternative. Pick one and finish it. Starting four courses at once feels productive and leaves you with four first chapters.

That is roughly 8 to 12 months at 8 hours a week. Faster with more hours, slower with fewer. Nobody can promise you a job at the end of it, and anyone who does is selling the promise. What you will have is the skill and the projects that show it.

The method: how to learn while building

This is the part most roadmaps skip, and it is the part that does the most work. Use it in every stage.

1. Pick a project one size too big

Choose something you do not quite know how to build yet, but where you can describe what "done" looks like in one sentence. "A tool that tells me what I spent on food each month" is a good size. "An AI that manages my finances" is not, yet.

2. Build the ugly version first

Get something working from start to finish on the first day, however bad. Load the data, do the simplest possible thing with it, print a result. A working ugly version tells you where the real problems are. A beautiful first half tells you nothing.

3. Copy, then change one thing

Tutorials are fine. Type them out by hand rather than copying and pasting, then change one thing: a different dataset, a bigger model, a different task. The moment the code stops working on your change is the moment you start learning, because now you have to understand it.

4. Get unstuck in this order

1. Read the whole error message, including the last line of the traceback.
2. Shrink the problem: the smallest piece of code that still fails.
3. Read the official documentation for the function that failed.
4. Ask an AI assistant to explain the error, not to write the fix. Our four codes for learning with AI work well here, especially ELI5 and Quiz me.
5. Then search, or ask in the course's forum or Discord.

One rule for AI assistants while you learn: never keep code you cannot explain line by line. Using an assistant to write code you do not understand is the fastest way to finish a project and learn nothing from it.

5. Keep a build log

Add a LEARNING.md file to every project and write in it every time you work. It takes two minutes and it is the best study material you will ever have, because it is about your own mistakes.

## 2026-10-20
Goal: get the validation loss below the baseline.
Tried: doubled the learning rate.
Broke: loss went to NaN after 200 steps.
Fixed: went back to 3e-4 and added gradient clipping.
Learned: NaN usually means the steps are too big, not that the data is wrong.
Next: try a bigger model with the old learning rate.

6. Measure before you improve

Before you change anything, write down a number: accuracy on a held-out set, the loss, how many of 20 test questions the app answers correctly. Then change one thing and measure again. Without a number, "it seems better" is a guess. From stage 4 on, this habit is called evaluation, and it separates people who build AI systems from people who demo them.

7. Ship it, then write it up

Finishing means three things: the code is on GitHub, the README explains what it does and how to run it, and (from stage 2) there is a demo someone can try. Then write a short post: what you built, one thing that broke, and how you fixed it.

8. Rebuild it from memory

A week after you finish a project, rebuild its core without looking at your old code. Whatever you cannot rebuild, you did not really learn yet. This takes an evening and it is worth more than the next three tutorials.

Stage 0: set up your workbench

Time: about a week. Goal: a place to write code and keep it.

• Python. Install Python on your computer, or start in a browser notebook. Google Colab is, in its own FAQ's words, "free of charge to use". The same FAQ says that in the free version, access to GPUs is "heavily restricted", resources are "not guaranteed and not unlimited", and a free notebook runs for at most 12 hours. That is enough for this roadmap until stage 4.
• git and GitHub. Make a GitHub account. The Pro Git book by Scott Chacon and Ben Straub is free to read online. Its first three chapters are enough: committing, pushing, and branches.
• An editor. Any code editor you like. What matters is that you write code in files, not only in notebooks.

Project: create a repository called learning-ai with a README that says what you are learning and why, and a LEARNING.md with your first entry.

You are ready to move on when: you can create a file, commit it and push it to GitHub without looking up the commands.

Stage 1: Python and just enough maths

Time: 4 to 8 weeks (our estimate). Goal: write real programs, not just follow along.

Learn from (pick one)

• CS50's Introduction to Programming with Python (Harvard). The page says you are welcome to take it "for free" through OpenCourseWare, with no prerequisites, and for learners "with or without prior programming experience". It runs through functions, conditionals, loops, exceptions, libraries, unit tests, file input and output, regular expressions and object-oriented programming, with a problem set each week and a final project. A paid certificate is optional.
• Python for Everybody by Charles Severance. Free lessons, lectures, a book and autograded assignments.
• Already code in another language? The official Python tutorial is written for programmers new to Python.

Then spend a week on NumPy and pandas, the two libraries every later stage assumes. Their own getting-started pages are enough.

The maths, only as much as you need

You do not need a maths degree. You need three ideas, and you need them visually first:

• Vectors and matrices: what multiplying them means. 3Blue1Brown's linear algebra series is the clearest version we know.
• Derivatives: what a slope tells you, and the chain rule.
• Probability basics: averages, spread, and what "likely" means as a number.

Learn each one when a later stage needs it, not all up front. Stage 3 is where derivatives start to matter.

Build (pick one)

• Your spending, explained. Export your bank or card statement as a CSV, load it with pandas, sort transactions into categories with rules you write, and chart the monthly totals. Real, messy data you care about.
• A file organiser. A command-line tool that sorts a messy downloads folder by type and date, with a dry-run mode that shows what it would do first.
• A personal dataset. Collect something over two weeks (your sleep, your commute times, your step count) in a CSV, then write a script that summarises it.

You are ready to move on when: you can open a blank file and write a 100-line script that reads data, transforms it and writes a result, and you can read a traceback and find the line that failed.

Stage 2: machine learning foundations

Time: 6 to 10 weeks (our estimate). Goal: train a model, measure it honestly and put it somewhere a person can use it.

Learn from (pick one)

• fast.ai Practical Deep Learning for Coders, if you learn best by building first. It is free. The page describes 9 lessons of around 90 minutes, asks for about a year of coding experience and high school maths, and says that by the end of the second lesson you will have built and deployed your own model.
• Andrew Ng's Machine Learning Specialization (Stanford Online and DeepLearning.AI on Coursera), if you want the concepts first. Beginner level, and the page estimates 2 months at 10 hours a week. Its FAQ says that if you audit the course for free you will not receive a certificate, and that financial aid is available. The same page also says the course cannot be taken for free, so check the enrolment options yourself before you start.

Alongside either, read the scikit-learn getting started page. scikit-learn is open source, and that one page covers fitting, pipelines and cross-validation, which you will use for the rest of your career.

The ideas this stage must leave you with

• Training, validation and test sets, and why you never judge a model on the data it learned from.
• Overfitting: a model that memorised instead of learning.
• Metrics: accuracy, precision and recall, and when accuracy lies (when 95 percent of examples are one class).
• Baselines: the dumbest reasonable answer, such as always predicting the most common class. A model that does not beat the baseline has learned nothing.
• Data leakage: when information from the answer slips into the inputs and makes a model look far better than it is.

Build (do both)

• A first competition. Kaggle's Titanic competition (predict which passengers survived) is where many people make their first submission. Do it once, end to end, beat a baseline, and write down what moved your score.
• A model on data you collected. This is the real project. Photos you took (fast.ai shows you how to train an image classifier on them), listings you saved, a year of your own messages labelled by topic. Collecting and cleaning the data will teach you more than the model will. Deploy it with a simple demo (stage 5 covers Gradio, and fast.ai shows you a way in lesson 2).

You are ready to move on when: you can explain why a validation set exists to a friend who does not code, you have beaten a baseline honestly, and a person who is not you has tried your model.

Stage 3: deep learning by hand

Time: 6 to 10 weeks (our estimate). Goal: understand what happens inside a neural network well enough to write one.

This is the stage where most people's understanding becomes real, because you stop calling libraries and start writing the parts they hide.

Learn from

• For intuition first: 3Blue1Brown's neural networks series on what a network is, gradient descent and backpropagation. Watch it before the next course, and again after.
• The main course: Neural Networks: Zero to Hero by Andrej Karpathy, "a course on building neural networks, from scratch, in code". The lectures are on YouTube. It asks for solid Python and intro-level maths. You build a small automatic-differentiation engine (micrograd), a character-level language model (makemore) that grows over several lectures, a GPT, and the tokenizer that feeds it.
• The framework: PyTorch's Learn the Basics, eight short sections from tensors to saving a trained model. Each section has a "Run in Google Colab" link, so you need no setup.

Type along with every Zero to Hero lecture. Watching it without typing is a C-tier way to spend an A-tier course.

Build

• Rebuild micrograd from memory. After the first lecture, close the video and write it again from a blank file. Then use it to train a tiny network on a toy problem.
• makemore on your own list. Train the character-level model on a list you care about: names from your language, your city's street names, song titles. Generating new ones that sound real is the moment it clicks.
• A small PyTorch model on a real dataset, with your own training loop (not a Trainer class): load data, batch it, forward pass, loss, backward pass, step, log the loss.

When the loss will not go down

You will hit this. Work through it in this order:

1. Try to overfit a single small batch. If the model cannot memorise 10 examples, the bug is in the code, not the data.
2. Check the data: print a batch and look at it. Labels in the wrong order are more common than you would think.
3. Lower the learning rate by 10 times and try again.
4. Check that you reset the gradients on every step.

You are ready to move on when: you can write a training loop without a template, explain backpropagation on paper with a two-neuron example, and debug a model that is not learning.

Stage 4: transformers and LLMs

Time: 8 to 12 weeks (our estimate). Goal: understand how today's language models work, and adapt one to your own task.

Learn from

• Read first: The Illustrated Transformer by Jay Alammar, a visual walk through attention, multi-head attention, positional encoding and the rest. Then the paper it explains, Attention Is All You Need (Vaswani and others, 2017), which introduced the Transformer. It reads far more easily after the illustration and after Zero to Hero's GPT lecture.
• The main course: the Hugging Face LLM course, "completely free and without ads". It covers the Transformers, Datasets and Tokenizers libraries, classic language tasks, sharing demos and advanced topics. Its third chapter is about fine-tuning a pretrained model on your own task. It asks for good Python and is better after an introductory deep learning course, which you now have.
• Fine-tuning on a small budget: the PEFT library. Its documentation explains that these methods "only fine-tune a small number of (extra) model parameters", which is what makes training large models possible "on consumer hardware". LoRA is the method you will meet first. Unsloth is an open-source framework that supports LoRA and QLoRA fine-tuning if you want a faster path.

Build

• Fine-tune a small model on a narrow task, and prove it helped. Pick something small and yours: sort your own notes into topics, rewrite text in one fixed format, classify support-style questions you have written. Write 20 to 50 test examples before you train. Run them through the model before and after fine-tuning and put both numbers in the README. Use only data you own or have permission to use.
• Know when not to fine-tune. Try the same task with a well-written prompt and a few examples first. If that gets you most of the way, a prompt is cheaper than a training run. Writing down which one won, and why, is part of the project.
• Stretch: train your own small chat model. Karpathy's nanochat covers tokenization, pretraining, fine-tuning, evaluation and inference in one small repository. Its README puts a GPT-2-class model at about $48 of rented GPU time (about 2 hours on an 8×H100 node). Our guide to building your own LLM from scratch walks through it. Karpathy now marks his older nanoGPT repository as deprecated and points to nanochat instead.

You are ready to move on when: you can explain tokens, attention and the context window without notes, you have fine-tuned a model and measured the difference, and you can say when you would not fine-tune.

Stage 5: build AI applications

Time: 6 to 10 weeks to your first shipped app (our estimate), and then for as long as you keep building. Goal: turn models into software that people use.

This is the stage most job titles called "AI engineer" are about. It rests on everything before it: when an application misbehaves, the reason is usually in stage 2 (bad evaluation), stage 3 (you do not know what the model is doing) or stage 4 (the wrong model for the task).

The skills, in the order we would learn them

1. Calling a model through an API. Pick one provider and read its quickstart. Claude's, for example, needs a Console account and an API key, then pip install anthropic and a few lines of Python. API calls are paid per use, so read the provider's pricing page before you run anything in a loop.
2. Prompting well. Specific instructions, examples and a stated format beat clever role-play. Our guide on what to write instead of "act as an expert" covers the evidence.
3. Retrieval (RAG). Give a model the right pieces of your own documents at question time. Build it once without a framework so you see every step: split documents into chunks, turn each into an embedding, find the chunks closest to the question, and put them in the prompt.
4. Tools and agents. A model that calls functions in a loop. Our guide to building a working AI agent in Python is a complete one in about 120 lines. Anthropic's essay Building effective agents (December 2024) is the best short read on when not to build one: it advises finding "the simplest solution possible" and adding complexity only when it is needed, and it names the common patterns (prompt chaining, routing, parallelisation, orchestrator-workers, evaluator-optimiser). The free Hugging Face Agents course goes further, with a final assignment and a free certificate.
5. Evaluation. A fixed set of test questions with the answers you expect, run automatically every time you change a prompt, a model or a retrieval setting. This is the single most important habit in this stage.
6. Running models locally. For privacy, cost or offline use. Our guide to running Gemma 4 on your laptop gets you there in one command.
7. Shipping. Gradio is an open-source Python package for putting a web interface on a Python function, and demo.launch(share=True) gives you a public link while it runs on your machine. To host it, Hugging Face Spaces: its documentation says static Spaces are free for everyone, Gradio Spaces need a paid plan, and free personal accounts can still host up to 2 Gradio Spaces on ZeroGPU. On free hardware a Space goes to sleep when it is not used.

Retrieval in its smallest form

This is the core of a retrieval system with no framework, using the open-source Sentence Transformers library (pip install -U sentence-transformers). Everything a framework adds is built around these lines.

from sentence_transformers import SentenceTransformer
 
model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
 
notes = [
    "The rent is due on the 1st of every month.",
    "The wifi password is on the back of the router.",
    "Bins go out on Tuesday night.",
]
note_vectors = model.encode(notes, normalize_embeddings=True)
 
question = "When do I take the rubbish out?"
question_vector = model.encode([question], normalize_embeddings=True)
 
scores = note_vectors @ question_vector.T   # higher means closer in meaning
best = scores.argmax()
print(notes[best])

The next steps are the project: split long documents into chunks, keep the top three matches instead of one, pass them to a model with the question, and ask it to say which note it used.

Build (in this order)

1. Chat with your own notes. Retrieval over a folder of your own documents, with the app quoting which note each answer came from. Then test it with 20 questions you know the answers to, and count how many it gets right.
2. An agent with two tools. Start from our 120-line agent and give it two tools that matter to you. Add a step limit and log every tool call.
3. An evaluation harness. 30 test cases for project 1 or 2, scored automatically, run before every change. Put the score in the README and update it as it improves.
4. The capstone: one app a stranger uses. Small and real beats big and imaginary. A tool for your college's notes, a helper for a hobby group, a checker for a task your friends do every week. Ship it, watch someone use it, fix what confuses them, and write up what you learned.

You are ready to call yourself an AI engineer when: you have shipped an app that someone other than you uses, its README shows how you measured it, and you can explain why it works and where it fails.

Twenty project ideas, by stage

Use data you own or have permission to use. Every project below is one you can finish.

A week that works

Two schedules we would use. Both are our suggestion; adjust them to your life, not the other way round.

About 8 hours a week (a job or college alongside):

About 15 hours a week: the same shape, with a lesson and a build session most days, and one long build block at the weekend. Keep the Sunday rebuild. It is the hour that makes the rest stick.

What to show for it

Three finished projects show more than ten finished tutorials. For each one:

• A README that a stranger can follow: what problem it solves, a link or a short video of it working, how to run it, the numbers you measured, and what you would do next.
• The build log, kept in the repository. It shows how you think, which a finished project alone cannot.
• A short write-up for each project: what you built, what broke, how you fixed it.
• A demo link wherever you can. A person who can try it in ten seconds is far more likely to look at the code.

Pin your three best repositories on your GitHub profile, in the order you would want someone to read them.

What to skip

• Courses that promise an income or a job in 30 days. Our guide to five red flags in an AI course has the full check to run before paying for anything.
• Paid prompt-engineering certificates. Prompting is a skill you build in stage 5 in a few weeks of practice. It is not a credential.
• Following AI news as study. It feels like learning, but you end up knowing names rather than how anything works. Read the news after you have built something; it will make much more sense.
• Collecting courses. Starting a fifth course is the most comfortable way to avoid building your first project.

Honest notes

• The order, the projects and every time marked as ours are our opinion and our estimate. Your pace will differ, and that is fine.
• Nobody can promise a job at the end of this or any roadmap. What it gives you is the skill and the proof of it.
• Free tiers change. Colab's GPU access and Hugging Face's hosting rules are quoted as they read on 18 October 2026.
• We have no arrangement with any course, book or tool named here, and nothing here is sponsored.

Sources

All read on 18 October 2026.

• CS50's Introduction to Programming with Python: cs50.harvard.edu/python
• Python for Everybody: py4e.com
• The Python tutorial: docs.python.org/3/tutorial
• Pro Git, Scott Chacon and Ben Straub: git-scm.com/book
• Google Colab FAQ: Colaboratory FAQ
• fast.ai Practical Deep Learning for Coders: course.fast.ai
• Machine Learning Specialization: Coursera, Machine Learning Specialization
• scikit-learn getting started: scikit-learn.org, getting started
• Neural Networks: Zero to Hero, Andrej Karpathy: karpathy.ai/zero-to-hero.html
• PyTorch, Learn the Basics: PyTorch tutorials, Learn the Basics
• The Illustrated Transformer, Jay Alammar: jalammar.github.io/illustrated-transformer
• Attention Is All You Need, Vaswani and others, 2017: arxiv.org/abs/1706.03762
• Hugging Face LLM course: huggingface.co/learn/llm-course
• PEFT documentation: huggingface.co/docs/peft
• Unsloth documentation: unsloth.ai/docs
• nanochat, Andrej Karpathy: github.com/karpathy/nanochat
• nanoGPT (marked deprecated by its author): github.com/karpathy/nanoGPT
• Claude API, get started: platform.claude.com/docs/en/get-started
• Building effective agents, Anthropic, December 2024: anthropic.com/engineering/building-effective-agents
• Hugging Face Agents course: huggingface.co/learn/agents-course
• Sentence Transformers: sbert.net
• Gradio quickstart: gradio.app/guides/quickstart
• Hugging Face Spaces overview: huggingface.co/docs/hub/spaces-overview