Free lesson · AI Engineering

Your Learning Roadmap

Easy12 min readaillmrag

Your Learning Roadmap

How This Course Is Structured

I have organised this course into five phases. Each phase builds on the previous one, and by the end of each phase, you can build a specific category of AI application that you could not build before.

This is deliberate. I do not believe in front-loading 10 hours of theory before you write a line of code. Every phase has a practical milestone - something you can build, deploy, and point to. Learning AI Engineering by reading about it is like learning to swim by reading about water.

Phase 1 - Foundations (Modules 0–4)

What you learn: What AI Engineering is, how LLMs work under the hood, how to make API calls, how to control generation, and how to think about costs before you build.

What you can build after this phase: A working LLM-powered application - a chat interface, a text processor, a content generator - with streaming responses, structured output, and conversation management. You understand the cost of every API call you make and you can estimate the monthly bill for a given usage pattern.

Why it comes first: You cannot make good architectural decisions without understanding the building blocks. This phase gives you the foundation that makes everything else stick.

The economics module deserves special mention. I placed it here - in Phase 1, before prompt engineering, before RAG, before anything else - because I have watched too many engineers build for three months and then discover their application costs

Phase 2 - Core Techniques (Modules 5–9)

What you learn: The five core techniques of AI Engineering - prompt engineering, embeddings and vector search, RAG, function calling and tool use, and fine-tuning.

What you can build after this phase: A production-grade RAG system that retrieves relevant information from a document corpus and generates cited, grounded answers. An application that calls external tools and APIs through LLM function calling. A fine-tuned model customised for your specific use case.

Why this ordering: Prompt engineering comes first because it is the most accessible technique and the one you will use in every subsequent module. Embeddings and vector search come next because they are the foundation for RAG. RAG comes next because it is the most common production pattern. Tool use follows because it extends what LLMs can do beyond text generation. Fine-tuning comes last in this phase because it is the most involved technique and benefits from understanding the alternatives first - many problems that seem to need fine-tuning can actually be solved with better prompts or better retrieval.

Phase 3 - Agents and Architecture (Modules 10–12)

What you learn: AI agents (from simple to complex), system architecture patterns for AI applications, and AI product thinking.

What you can build after this phase: Multi-step AI agents that use tools, maintain memory, and handle complex tasks. You can design the architecture for an AI application from scratch - choosing the right patterns, the right models, the right trade-offs - and defend those choices in a design review or an interview.

Why this comes after Core Techniques: Agents combine prompt engineering, tool use, and often RAG into a single system. You need to understand the components before you can compose them. Architecture decisions require understanding the trade-offs of each technique, which you cannot have until you have worked with them individually.

The AI Product Thinking module is in this phase because it bridges the gap between "I can build AI features" and "I can decide which AI features to build." That product-level judgement is what separates a senior AI Engineer from a junior one.

Phase 4 - Production and Operations (Modules 13–16)

What you learn: Evaluation and testing, safety and guardrails, deployment and MLOps, and cost optimisation at scale.

What you can build after this phase: A fully production-grade AI application with systematic evaluation, safety guardrails, CI/CD with quality gates, monitoring and observability, and cost controls. This is the phase that turns your AI application from "works on my laptop" to "runs in production serving real users."

Why this comes late: Production concerns become meaningful only when you have something worth putting into production. Teaching deployment before you have built an application puts the cart before the horse. By the time you reach this phase, you have built several applications and you can see exactly why each production concern matters.

That said, I thread production thinking throughout the earlier phases. When you learn RAG in Phase 2, I mention evaluation. When you learn agents in Phase 3, I mention reliability. The dedicated modules in Phase 4 go deep on these topics, but they do not appear out of nowhere.

Phase 5 - Advanced (Module 17)

What you learn: Multimodal AI - vision, image generation, audio, speech, and video. Building applications that work across modalities.

What you can build after this phase: Applications that process images, generate images, handle audio input and output, and combine multiple modalities in a single pipeline.

Why this is last: Multimodal AI is powerful but specialised. Most AI Engineering work today is text-centric. The techniques from Phases 1–4 apply directly to multimodal work, but multimodal adds new considerations (larger payloads, different evaluation criteria, different cost structures) that are best understood in the context of the fundamentals you have already built.

Prerequisites

I am explicit about prerequisites because nothing wastes your time faster than starting a course that assumes knowledge you do not have.

Required

Python (intermediate level). You can write functions, use list comprehensions, work with dictionaries, create classes, use decorators, and understand the basics of async/await. If you can write a Python script that makes HTTP requests, parses JSON responses, and handles errors - you are ready. If you cannot, work through the appendix module (Module A: Python for AI Engineering) first. It will take you 4-6 hours and will give you everything you need.

Basic software engineering. You understand what an API is, how HTTP requests work, what JSON is, and why you use version control. You have deployed at least one application to production - even if "production" was a side project on a $5 VPS. The exact technologies do not matter. The mental model of building and shipping software does.

A computer with internet access. You will make API calls to LLM providers. Some modules will benefit from a GPU for local model inference, but it is not required - I provide cloud alternatives for every exercise.

Recommended but Not Required

Experience with any cloud platform (AWS, GCP, Azure). Helps with the deployment modules, but I will explain everything you need as we go.

Familiarity with Docker. Useful for the containerisation lessons. If you have never used Docker, you can learn the basics in an afternoon and it will serve you well beyond this course.

Basic statistics. Understanding mean, median, percentile, and what a distribution looks like. Helpful for evaluation and cost analysis. Not required - I explain the statistics we need when we need them.

Not Required

Machine learning background. I will teach you everything you need to know about how LLMs work. You do not need to know what a gradient is.

A GPU. Everything in this course can be done with API calls to hosted models. The self-hosting module covers GPU-based inference, but I provide alternatives for every exercise.

Prior AI or LLM experience. This course starts from the beginning. If you have played with ChatGPT but never made an API call, you are exactly the right starting point.

Setting Up Your Development Environment

Before we start Module 1, you need a working environment. I want you to have this ready so that when we write our first line of code, you can run it immediately.

Step 1: Python Environment

You need Python 3.10 or later. I recommend using pyenv or conda to manage Python versions, but any approach that gives you a clean Python 3.10+ environment will work.

python3 --version

Create a virtual environment for this course:

python3 -m venv ai-engineering
source ai-engineering/bin/activate  # macOS/Linux
# or: ai-engineering\Scripts\activate  # Windows

Step 2: API Keys

You will need API keys for at least one LLM provider. I recommend starting with two - one closed-source and one open-source - so you can compare them directly.

Option A (recommended for most students):

• OpenAI API key → platform.openai.com
• Anthropic API key → console.anthropic.com

Option B (budget-conscious):

• OpenAI API key (cheapest closed-source option via GPT-4o-mini)
• Ollama for local inference (free) → ollama.com

Tip: Budget tip: OpenAI and Anthropic both offer free credits for new accounts. The exercises in this course are designed to be cost-efficient - a full run through every coding exercise in the course should cost less than $20 in API fees if you use the recommended model configurations. I specify the cheapest model that produces good results for each exercise.

Step 3: Core Libraries

Install the Python libraries you will use throughout the course:

pip install openai anthropic httpx pydantic python-dotenv rich

We will install additional libraries (for embeddings, vector databases, agent frameworks, etc.) as we need them in later modules. I do not believe in installing 40 packages on day one when you only need 7.

Step 4: Project Structure

Create a project directory with this structure:

mkdir -p ai-engineering-course/{exercises,projects,notes}
cd ai-engineering-course

Keep your API keys in a .env file that is gitignored:

echo "OPENAI_API_KEY=your-key-here" > .env
echo "ANTHROPIC_API_KEY=your-key-here" >> .env
echo ".env" >> .gitignore

Warning: Never commit API keys to version control. This sounds obvious, but I have seen it happen at every company I have worked at, including Meta. Use .env files, never check them in, and use a .gitignore entry to protect yourself from accidental commits. Some of the exercises involve tools that could incur costs if your key is exposed.

Step 5: Verify Your Setup

Run this verification script to confirm everything works:

import os
print("Python environment: OK")

try:
    import openai
    print("OpenAI library: OK")
except ImportError:
    print("OpenAI library: MISSING - run: pip install openai")

try:
    import anthropic
    print("Anthropic library: OK")
except ImportError:
    print("Anthropic library: MISSING - run: pip install anthropic")

try:
    import pydantic
    print("Pydantic library: OK")
except ImportError:
    print("Pydantic library: MISSING - run: pip install pydantic")

try:
    from dotenv import load_dotenv
    print("python-dotenv: OK")
except ImportError:
    print("python-dotenv: MISSING - run: pip install python-dotenv")

print("\nEnvironment check complete.")

If all checks pass, you are ready for Module 1.

How to Use This Course Effectively

I have built this course with a specific learning model in mind. It works best if you follow it.

Read, Then Build, Then Reflect

Every topic follows a pattern: concept → example → code → exercise. The concept gives you the mental model. The example makes it concrete. The code makes it real. The exercise makes it yours.

The temptation is to read the concept, nod along, and skip the exercise. Do not do this. The exercise is where the learning happens. Reading about RAG and building a RAG pipeline activate different parts of your brain. You will think you understand something after reading about it. You will discover what you actually understand when you try to build it.

Use the AI-Generated Summaries for Review

Every lesson on AlgoInsight generates an AI summary. These summaries are designed for a specific use case: review and recall. When you come back to a topic you read last week and need a quick refresher, the summary gives you the key points in two minutes instead of fifteen.

Do not use the summary as a substitute for reading the lesson. The lesson has depth, nuance, and examples that the summary compresses away. The summary is a revision tool, not a learning tool.

Use the AI-Generated Quizzes for Self-Testing

Every lesson generates a quiz. Take it after you finish the lesson. If you score below 80%, re-read the sections you missed. If you score above 80%, move on.

The quizzes are a feedback mechanism. They tell you whether you actually absorbed the material or just felt like you did. There is a meaningful difference between those two states, and the quiz catches it.

Take Notes in Your Own Words

I provide comprehensive written content. Your job is not to copy it - it is to translate it into your own mental model. When you read about the three-layer AI stack, write one sentence in your own words about what each layer does. When you learn about a new prompting technique, write down when you would and would not use it.

The notes you write are more valuable than the notes I write, because your notes encode your understanding, not mine.

Do Not Skip Modules

The modules are sequenced deliberately. Each one builds on the previous ones. If you skip the embeddings module and jump to RAG, you will not understand why certain retrieval techniques work. If you skip the cost module, you will build things that are too expensive to operate.

The only exception is the appendix module (Python for AI Engineering). Skip it if your Python is solid. Otherwise, do it first.

Interview: If you are using this course for interview prep: The modules map directly to AI Engineering interview topics. System design questions test the knowledge from Modules 10-11. Evaluation questions test Module 13. Cost optimisation questions test Modules 3 and 16. I flag interview-relevant concepts throughout the course with interview callout boxes like this one. When you are ready to focus on interview technique specifically, AlgoInsight's AI/ML System Design Interview course is designed to follow this one.

What You Will Build

Throughout this course, you will build several projects of increasing complexity. These are not optional extras - they are the core learning experience.

Project 1: LLM-Powered Application (Module 1). A complete application that calls an LLM API, manages conversations, streams responses, and extracts structured data. Your first working AI application.

Project 2: Semantic Search Engine (Module 5). A search system that understands meaning, not just keywords. You will embed documents, store them in a vector database, and build a query pipeline.

Project 3: Production RAG System (Module 6). A question-answering system over a document corpus with retrieval, generation, and citation. The most common AI Engineering pattern, built end-to-end.

Project 4: Tool-Using Agent (Modules 7-8). An AI agent that can call external APIs, use tools through MCP, and complete multi-step tasks.

Project 5: Fine-Tuned Model (Module 9). A model customised for your specific use case, trained on your data, evaluated against your criteria.

Project 6: Production-Grade Deployment (Modules 13-15). Taking one of your earlier projects and adding evaluation, safety guardrails, monitoring, and CI/CD. The full production stack.

Each project comes with starter code, step-by-step instructions, and extension challenges for learners who want to go deeper. The projects are designed to be portfolio-worthy - the kind of work you can show in an interview or reference in a job application.

The Pace

I have designed this course to be completed in approximately 12–16 weeks at a pace of 5–8 hours per week. That is 60–120 total hours of learning, including reading, coding exercises, and projects.

If you are doing this alongside a full-time job - which I expect most of you are - that means roughly one hour per day on weekdays and a longer session on weekends. That is sustainable. It is also roughly the pace I used to prepare for my own Meta interview, minus the 127 mock interviews.

You can go faster. Some engineers will finish in 6-8 weeks at a higher intensity. You can go slower. The content is not time-locked.

But do not take months-long breaks between modules. The concepts build on each other, and the connections between modules are part of the learning. If you forget what embeddings are by the time you reach RAG, the RAG module will feel harder than it should.

Tip: My recommendation: set a recurring calendar block. Tuesday and Thursday evenings, Saturday morning. Whatever works for your schedule. Protect that time. The learners who finish courses are the ones who treat learning as a commitment, not an aspiration. I know this because I have the spreadsheet data from my own preparation to prove it - consistency beat intensity every single time.

Let's Start Building

You have the map. You have the tools. You have the plan.

Module 1 begins with your first LLM API call. Not a theoretical discussion about what an API call is - an actual API call that returns an actual response from an actual model. You will see tokens being consumed, costs being incurred, and text being generated.

That is the first step. Everything else builds from there.

The distance between where you are now and a production AI Engineering skillset is not talent. It is not luck. It is systematic work, applied consistently, with honest self-evaluation at every step.

I know this because I measured it. 23 rejections, 127 mock interviews, one spreadsheet. The data does not lie.

Let us get started.

Back to AI Engineering