Published։ February 27, 2025
Introduction to Cloud Computing
Your AI Engineer Learning Roadmap
Click any phase to explore
1
Python and Developer Foundations
▶
Everything in AI engineering runs on Python. This phase gives you the programming fundamentals, developer tools, and coding habits you'll rely on for the rest of the path.
▶
Beginner Python
Why it matters
Every framework, library, and tool on this roadmap is Python-based. This is where your AI engineering journey starts, and getting these fundamentals right makes everything that follows click faster.
What to learn
- Variables, data types, lists, loops, and conditionals
- Dictionaries and data structures
- Working with APIs using the requests library
- Writing reusable functions
Tools
Python 3.11+pipvenv
Introduction to Python Programming ↗
Python Dictionaries, APIs, and Functions ↗
▶
Intermediate Python
Why it matters
Open any AI framework's source code and you'll see classes, decorators, and error handling everywhere. These patterns are the connective tissue of production Python, and you'll use them constantly from Phase 2 onward.
What to learn
- Object-oriented programming (basic and intermediate)
- List comprehensions and lambda functions
- Decorators and regular expressions
- Error handling and input validation
Tools
Python 3.11+classesdecorators
▶
Git, CLI, and Developer Workflow
Why it matters
You can't deploy an AI app or collaborate with a team without version control and command-line skills. These are table stakes for any engineering role, and the sooner they feel natural, the faster you'll move.
What to learn
- CLI navigation and file management
- Virtual environments and environment variables
- Git basics: clone, branch, commit, merge, pull requests
- Setting up and customizing your IDE
Tools
GitGitHubBash/ZshVS Code
Milestone project
Build a Food Ordering App with menus, cart management, and order processing. Push it to GitHub with a clean README.
def add_to_cart(cart, item, price, qty=1):
if item in cart:
cart[item]["qty"] += qty
else:
cart[item] = {"price": price, "qty": qty}
total = cart[item]["price"] * cart[item]["qty"]
print(f"Added {qty}x {item} — subtotal: ${total:.2f}")
return cart
if item in cart:
cart[item]["qty"] += qty
else:
cart[item] = {"price": price, "qty": qty}
total = cart[item]["price"] * cart[item]["qty"]
print(f"Added {qty}x {item} — subtotal: ${total:.2f}")
return cart
You're a Python developer ✓
2
LLM Fundamentals and AI App Development
▶
Now that you can write Python, it's time to connect it to the technology driving the AI industry. You'll learn how LLMs work, how to talk to them through APIs, and how to ship real AI applications that other people can use.
▶
How LLMs Work
Why it matters
You don't need to derive transformer math, but you do need to understand what's happening when you call an LLM. Knowing how tokens, context windows, and temperature work lets you make smarter decisions about which model to use and how to use it.
What to learn
- AI chatbot capabilities and limitations
- Tokenization and context windows
- Model families: GPT, Claude, Gemini, Llama, Mistral, DeepSeek
- Choosing the right model for the job
Tools
OpenAI APIAnthropic API
▶
Prompt Engineering
Why it matters
The difference between a cool demo and a production-ready feature often comes down to how well you prompt the model. This isn't a standalone career; it's a core skill every AI engineer uses daily.
What to learn
- OpenAI Chat Completions API
- Managing conversation context and token budgets
- Prompting techniques for reliable, high-quality responses
Tools
OpenAI Chat APIAnthropic Messages API
▶
Function Calling, Tool Use, and MCP
Why it matters
This is where LLMs stop being chatbots and start being useful. Function calling lets models trigger real actions: query a database, call an API, or execute code. MCP (Model Context Protocol) is quickly becoming the universal standard for connecting agents to tools.
What to learn
- Structured outputs and validation with Pydantic
- Function calling and agentic tool loops
- Building reusable tool servers with MCP
Tools
Function callingMCPPydantic
▶
APIs for AI Applications
Why it matters
AI engineering is about connecting models to products, and APIs are the glue. You need to consume third-party APIs confidently and understand how authentication, rate limits, and pagination work before you build your own.
What to learn
- Query parameters and data filtering
- Authentication methods and API keys
- Rate limits and pagination strategies
Tools
requestsREST APIsJSON
▶
Building and Deploying AI Apps
Why it matters
The gap between "works in a notebook" and "runs in production" is where most beginners stall. FastAPI and Docker are how professional AI engineers ship systems that other people can actually use.
What to learn
- Building LLM-powered APIs with FastAPI
- Containerizing applications with Docker
- Multi-service architectures with Docker Compose
- Production patterns: health checks, multi-stage builds, non-root users
Tools
FastAPIDockerDocker Compose
Milestone projects
Build a Dynamic AI Chatbot, a Multi-Provider LLM Gateway, and deploy a complete AI service with FastAPI and Docker.
import openai
client = openai.OpenAI()
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "What is RAG?"}
]
)
print(response.choices[0].message.content)
You can build and ship AI apps ✓
3
Data, Math, and Machine Learning
▶
You can build AI apps, but to build good ones, you need to understand the science underneath. This phase gives you the data skills, statistical thinking, and ML knowledge that separate engineers who use AI from engineers who understand it.
▶
Data Analysis and Visualization
Why it matters
Before you can build ML models or evaluate RAG pipelines, you need to be comfortable wrangling data. Pandas and NumPy are the backbone of every data workflow in Python, and these skills will save you hours of debugging later.
What to learn
- NumPy arrays and boolean indexing
- Pandas: exploration, cleaning, aggregation, combining datasets
- String manipulation and handling missing data
- Visualization: line graphs, scatter plots, histograms, distributions
Tools
NumPyPandasMatplotlib
Introduction to Pandas and NumPy ↗
Data Visualization in Python ↗
Data Cleaning and Analysis ↗
▶
Probability and Statistics
Why it matters
Statistics is the language ML models speak. Without it, you're tuning knobs without understanding what they do. This is also how you'll evaluate whether your AI systems are actually working or just getting lucky.
What to learn
- Sampling and frequency distributions
- Central tendency, variability, and z-scores
- Probability rules, permutations, and combinations
- Bayes' theorem and Naive Bayes classifiers
- Hypothesis testing and chi-squared tests
Tools
PythonSciPy
Introduction to Statistics ↗
Intermediate Statistics ↗
Probability in Python ↗
Hypothesis Testing ↗
▶
Machine Learning Foundations
Why it matters
Understanding how ML models learn, evaluate, and fail gives you intuition you can't get from API docs alone. The math here (calculus, linear algebra) isn't busywork; it's what makes the difference when you need to debug a model or choose the right approach.
What to learn
- Supervised ML: KNN, model evaluation, hyperparameter tuning
- Unsupervised ML: K-means clustering
- Calculus for ML: functions, limits, optimization
- Linear algebra: vectors, matrices, linear systems
Tools
scikit-learnNumPy
Introduction to Supervised ML ↗
Introduction to Unsupervised ML ↗
Calculus for ML ↗
Linear Algebra for ML ↗
▶
Intermediate Machine Learning
Why it matters
Real-world ML problems rarely fit neatly into a beginner tutorial. You need to know how to select between models, engineer features, and optimize performance. These techniques carry directly into evaluating and improving AI systems.
What to learn
- Linear and logistic regression
- Gradient descent optimization
- Decision trees and random forests
- Cross-validation, regularization, and feature engineering
Tools
scikit-learn
Linear Regression Modeling ↗
Logistic Regression Modeling ↗
Decision Tree and Random Forest ↗
Optimizing ML Models ↗
▶
Deep Learning with PyTorch
Why it matters
LLMs and embedding models are deep learning models. Understanding how neural networks process sequences, text, and images gives you X-ray vision into the systems you've been calling through APIs since Phase 2.
What to learn
- Sequence models and time series
- Natural language processing (NLP)
- Computer vision with CNNs
- Building and training a pneumonia detection model
Tools
PyTorch
Milestone projects
Predict heart disease with supervised ML, segment customers with K-means, build regression and classification models, and train a CNN for pneumonia detection from chest X-rays.
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import cross_val_score
model = RandomForestClassifier(n_estimators=100, random_state=42)
scores = cross_val_score(model, X_train, y_train, cv=5)
print(f"Cross-val accuracy: {scores.mean():.3f} (+/- {scores.std():.3f})")
model.fit(X_train, y_train)
print(f"Test accuracy: {model.score(X_test, y_test):.3f}")
You understand the science behind AI ✓
4
Embeddings, RAG, and AI Agents
▶
This is where it all comes together. You'll combine your Python skills, LLM knowledge, and ML understanding to build the systems companies are hiring for right now: semantic search, RAG pipelines, and autonomous AI agents.
▶
Embeddings and Semantic Search
Why it matters
Embeddings turn text into numbers that capture meaning. "How do I return an item?" and "What's your refund policy?" land close together in vector space even though they share zero keywords. This is the foundation of every RAG system you'll build.
What to learn
- Generating embeddings with APIs and open models
- Visualizing high-dimensional embeddings
- Similarity metrics: cosine similarity, Euclidean distance, dot product
- Building semantic search systems
Tools
OpenAI EmbeddingsSentence Transformers
▶
Vector Databases and Search
Why it matters
You can't search millions of embeddings with a for loop. Vector databases are purpose-built for fast similarity search at scale, and they're the backbone of every production RAG system.
What to learn
- ChromaDB fundamentals and HNSW indexing
- Document chunking strategies
- Metadata filtering and hybrid search
- Production databases: pgvector, Qdrant, Pinecone
- Semantic caching and memory patterns
Tools
ChromaDBPineconepgvector
▶
Building RAG Systems
Why it matters
RAG (retrieval-augmented generation) gives LLMs access to your data without retraining. It's the single most in-demand AI engineering pattern in production right now, and knowing how to build, debug, and secure one is the skill most likely to land you a job.
What to learn
- RAG architecture: retrieval, context management, grounded generation
- Advanced retrieval: query expansion and reranking
- Diagnosing common failure modes
- Security and prompt injection defense
- Self-RAG and autonomous evaluation
Tools
LangChainLlamaIndexRAGAS
▶
LLM Evaluation
Why it matters
AI systems are probabilistic: the same input can produce different outputs. You can't just write unit tests and call it done. Evaluation is what separates a prototype that impresses in a demo from a system you can trust in production.
What to learn
- Foundation metrics and evaluation frameworks
- LLM-as-Judge and automated evaluation
- Production observability and monitoring
Tools
RAGASDeepEvalLangSmith
Coming soon in the Dataquest path
▶
AI Agents
Why it matters
Agents can reason about a task, break it into steps, use tools, and iterate toward a goal autonomously. This is the fastest-growing area in AI engineering and where most new work will concentrate over the next few years. If there's one thing to bet on, it's this.
What to learn
- Agent architectures and tool use patterns
- Building agents with function calling
- Memory, state management, and planning strategies
- Multi-agent orchestration
- Agent evaluation and safety
Tools
LangGraphCrewAIMCP
Coming soon in the Dataquest path
Milestone projects
Build a Knowledge Base Search System with vector databases, and ship a production RAG application with evaluation metrics for retrieval accuracy and answer quality.
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain.chains import RetrievalQA
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain.chains import RetrievalQA
vectorstore = Chroma.from_documents(
documents=chunks,
embedding=OpenAIEmbeddings()
)
qa_chain = RetrievalQA.from_chain_type(
llm=ChatOpenAI(model="gpt-4o-mini"),
retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
)
answer = qa_chain.invoke("What is our refund policy?")
print(answer["result"])
You're a job-ready AI engineer ✓
