AI Learning Roadmap for Developers
A structured, no-fluff learning path from first principles to shipping production LLM systems — for engineers who already code and want to understand the actual stack.
AI is not a subject you can "finish." But for a working software engineer, there is a specific, learnable body of knowledge that separates someone who uses AI tools from someone who builds AI systems. The distinction is not a PhD — it's understanding the stack deeply enough to debug it, tune it, and make responsible engineering tradeoffs.
Foundations
Foundations
4–8 weeks
Core ML
Core ML
8–12 weeks
LLMs & GenAI
LLMs & GenAI
8–10 weeks
Production
Production
Ongoing
This roadmap is opinionated by design. It skips entire subfields that are either too niche for product engineers or well-covered by specialists elsewhere. What it prioritises is the shortest path from "I can call an API" to "I can reason about, train, deploy, and maintain a model in production." Each phase builds on the last. Do not skip phases.
Who this is for. You already write code professionally. You're comfortable with Python. You've probably called the OpenAI API. Now you want to understand what's actually happening — and how to build systems that don't break in production. This roadmap is for you.
Phase 1 — Foundations (4–8 weeks)
Machine learning is applied linear algebra and statistics with an optimisation loop on top. You cannot shortcut this foundation without paying for it later when debugging a model that refuses to converge or produces confident wrong answers. The goal here is not academic depth — it's the minimum maths you need to read a paper and understand why it works.
Mathematics you actually need
Linear Algebra — vectors, matrices, dot products, eigenvalues
Core: understand why embedding similarity is a dot product. Resource: 3Blue1Brown "Essence of Linear Algebra" series.
Calculus — derivatives, chain rule, gradients
Core: understand backpropagation at an intuitive level. You do not need to derive it by hand, but you need to know what it's doing.
Probability & Statistics — distributions, Bayes, entropy, log-likelihood
Core: cross-entropy loss is the beating heart of language model training. Understanding it changes how you read loss curves.
Information Theory — KL divergence, mutual information
Optional: useful for understanding RLHF reward models and VAEs, but not required for Phase 2.
Python and the scientific stack
NumPy — vectorized operations, broadcasting, array indexing
Think in arrays, not loops. This is where most engineers need to rewire their instincts.
Pandas — data loading, cleaning, groupby, merge
Real datasets are messy. You'll spend more time here than you expect.
Matplotlib / Seaborn — plot loss curves, confusion matrices, distributions
Visualisation is a debugging skill, not a presentation skill.
Phase 2 — Core Machine Learning (8–12 weeks)
This phase covers the classical and deep learning models that underpin everything in GenAI. Skipping to transformers without this phase means you'll misread attention diagrams, misinterpret training curves, and make wrong assumptions about what "training" even means for an LLM.
Classical ML (2–3 weeks)
Linear & Logistic Regression, Regularisation (L1/L2)
The template for all supervised learning. Understand overfitting and the bias-variance tradeoff here, not in a neural network.
Decision Trees, Random Forests, Gradient Boosting (XGBoost)
Still the dominant approach for tabular data in production. Know when NOT to reach for a neural net.
Evaluation metrics — accuracy, precision, recall, F1, AUC, NDCG
Choosing the wrong metric in production is a product bug, not just a model bug.
Deep Learning (5–7 weeks)
Feedforward networks, activation functions, backprop
Build one from scratch in NumPy before using PyTorch. It's a week of work that pays off for years.
PyTorch — tensors, autograd, DataLoader, training loop
The de facto framework for research and production LLM work. Learn PyTorch, not TensorFlow.
CNNs — convolutions, pooling, feature maps
Still used in multimodal models. Understanding spatial attention requires understanding convolutions first.
RNNs, LSTMs, sequence modelling
Understand WHY transformers replaced RNNs. You cannot appreciate the answer without knowing the original problem.
Phase 3 — LLMs & Generative AI (8–10 weeks)
This is the core of the roadmap. Everything before was prerequisite. Here you learn the actual mechanisms that power GPT, Claude, Gemini, and their open-source equivalents — and how to work with them as a practitioner, not just a user.
Transformers and attention
"Attention Is All You Need" — read the paper, not just the blog posts
Two hours of careful reading will save you weeks of confused intuition.
Multi-head self-attention, Q/K/V matrices, positional encoding
Implement a minimal transformer in PyTorch. Andrej Karpathy's nanoGPT is the gold standard reference.
Tokenization — BPE, WordPiece, SentencePiece
Tokenization bugs are some of the hardest to diagnose. Know how your model sees text.
Working with LLMs
Prompt engineering — zero-shot, few-shot, chain-of-thought, ReAct
Not a soft skill — it's a system design skill with measurable impact on output quality.
RAG — retrieval-augmented generation, vector databases, chunking strategy
The most practical LLM architecture pattern for production. Learn Chroma or Qdrant alongside LangChain or LlamaIndex.
Fine-tuning — LoRA, QLoRA, instruction tuning
Understand the cost-quality tradeoff before defaulting to "just fine-tune it."
AI Agents — tool use, function calling, multi-agent orchestration
Agents are the fastest-moving area right now. Learn the patterns before the frameworks, as frameworks change weekly.
RLHF, DPO, reward modelling
Optional for most product engineers, essential for AI teams building model alignment or custom training pipelines.
Phase 4 — Production AI Systems (Ongoing)
Building an AI system that works in a notebook is a different problem from building one that works reliably for 10,000 users, returns correct results 99% of the time, and degrades gracefully when the model produces nonsense. This phase is a professional discipline, not a curriculum — it evolves with the stack.
Recommended Resources by Phase
| Phase | Resource | Type | Cost |
|---|---|---|---|
| Phase 1 | 3Blue1Brown — Linear Algebra series | Video | Free |
| Phase 1 | StatQuest with Josh Starmer | Video | Free |
| Phase 2 | fast.ai Practical Deep Learning | Course | Free |
| Phase 2 | Andrej Karpathy — Neural Networks: Zero to Hero | Video | Free |
| Phase 3 | Hugging Face NLP Course | Course | Free |
| Phase 3 | LangChain / LlamaIndex docs + tutorials | Docs | Free |
| Phase 3 | DeepLearning.AI Short Courses (RAG, Agents) | Course | Free |
| Phase 4 | MLOps Community, Weights & Biases resources | Community | Free |
The most important habit. Build something at every phase. Theory without implementation doesn't stick. A RAG pipeline over your own documents, a fine-tuned classifier on a Kaggle dataset, a minimal agent with tool use — these are worth more than 10 additional courses.
Building AI systems is what we do at DestinPQ
From AI agents to full-stack AI products — we've walked this roadmap and built production systems on the other side. Let's talk.
From the DestinPQ founders — practical writing on AI, engineering, and building for real businesses.