Self-paced learning, from the foundations
Full-Stack AI Engineering
Start with how a computer works. Learn Python, understand how AI models learn, and connect those skills to real applications with a frontend, backend and database.
All four courses are currently free in the learning portal. Paid checkout is not active.
A glimpse of what you’ll explore
What does RAM do?
RAM holds information a running program needs.
Work towards building an AI product you can explain, test, deploy and improve.
275 foundation lessons · 55 engineering units
- English and Urdu lessons
- Visual explanations and worked examples
- Small coding activities before larger builds
- Project files, repair tasks and evidence prompts
What you’ll learn to do
Build understanding in small steps, then apply it to work you can inspect and explain.
- Write Python programs, use Git and work confidently with files and a Linux terminal.
- Connect a browser interface to APIs, databases and accounts.
- Use mathematics, real data and evaluation to understand machine learning.
- Train a small neural network and work with PyTorch.
- Explain tokens, embeddings, Attention and how a language model produces text.
- Build document retrieval and bounded tool-using applications with clear failure handling.
- Test an AI product, protect user data and practise deployment and recovery.
- Explore distributed training, custom CUDA kernels and Kubernetes after the core route.
Put your skills into a real build
These projects connect the smaller lessons. Start with guidance, then change a requirement and explain your choices.
PROJECT 01
A notebook that remembers
Write a small Python app that saves notes to a file and loads them again.
PROJECT 02
A document question-answering app
Split documents, retrieve relevant passages and attach passage references to an answer.
PROJECT 03
A private AI study assistant
Connect an interface, accounts, notes and model answers, then test access, failures and recovery.
Plan your study time
Provisional planning estimate, not measured student completion times. Includes lessons, practice, revision and projects.
Interactive calculation requires JavaScript. Provisional estimates require suitable tools, access and feedback.
Planning is not a guarantee of completion or mastery. The optional selection includes core plus all optional specialisations.
Excluded: electives, ungraded external-model work, waiting/provider delays and review queues.
Method and exclusions
Editorial task budgets, not measured learner timing. Electives, ungraded external-model work, waiting/provider delays and review queues are excluded.
Estimate basis: provisional editorial planning; not measured student completion times · 2026-10-30
Your learning route
19 core stages + 3 advanced specialisations. Open a chapter to see the topics in order.
Start with the foundations. Revisit an earlier topic whenever a term or task feels unfamiliar.
01Start from zero6 stages
- 0
Starting assessment and orientation
Find the starting point without assuming prior knowledge. Ask one question at a time; teaching begins after the assessment unless clarification is requested.
- 1
Computer foundations
Understand the physical machine and its saved and running work before using development tools.
- 2
Windows workspace and tool setup
Create, locate, save and run a real project without assuming command-line experience.
- 2B
Linux foundations on Windows
A complete first Linux route from WSL and Ubuntu to independently organising and inspecting a small workspace.
- 3
Python from the first instruction
Move from running examples to writing and explaining small programs with explicit inputs, outputs and error cases.
- 4
Developer tools and problem solving
Use repeatable debugging, tests, version control and documentation rather than guessing or accepting unexplained generated code.
02Build the engineering foundations6 stages
- 5
Internet, APIs, databases and backend
Build a service with explicit request contracts, stored records and permission boundaries before adding a complex interface.
- 6
Frontend and the first full-stack product
Build a usable browser interface, connect the backend and add one prepared-model feature early.
- 7
Math and real data
Build each mathematical idea from meaning and a visual before formulas, then use it on small inspectable data.
- 8
Machine learning and honest evaluation
Choose an appropriate baseline, train on permitted data and explain performance and failures on unseen examples.
- 9
Neural networks and PyTorch
Calculate a tiny network yourself, then train, debug and reload a real PyTorch model.
- 10
AI hardware, precision and memory
Understand capacity, numerical formats and bottlenecks before choosing hardware or interpreting speed claims.
03Build and operate AI products7 stages
- 11
LLMs and Transformer internals
Trace real text from bytes and token IDs through attention to a next-token distribution.
- 12
Train, adapt and run models
Understand where weights come from, perform a small measurable adaptation and serve a model with known constraints.
- 13
Reliable LLM applications and evaluation
Treat the model as an uncertain component inside a tested application with clear contracts, limits and review.
- 14
RAG, tools and reliable agents
First retrieve and cite trustworthy evidence; then build bounded actions with explicit permissions and failure handling.
- 15
Vision, speech, images and video
Understand each medium’s data and build small inspectable multimodal workflows with evaluation and consent.
- 16
Production, security and maintenance
Deploy a complete product, observe it, protect its data and prove that it can recover from failures.
- 17
Independent capstones and review
Demonstrate independence with unfamiliar requirements, observed failures and a qualified reviewer. Supplied solutions do not satisfy this stage.
04Advanced specialisations3 stages
- A
Distributed training and inference
Extend a correct single-process workload to coordinated processes and real multi-device execution with measured limits.
- B
C/C++ foundations and custom CUDA
Learn the required compiled-language concepts before implementing, verifying and profiling a custom GPU kernel.
- C
Kubernetes and larger AI platforms
Progress from local reconciliation to multi-node operations, security, GPU scheduling and observed recovery.
What you need to begin
Read, try, then build. The right practice environment becomes part of the lesson.
Your starting point
- No programming or AI experience is assumed.
- Start with a short assessment; unfamiliar terms are introduced along the way.
- Learn the mathematics inside the route, beginning with meaning, visuals and small calculations.
Your practice setup
- Use a laptop or desktop for coding and full projects; a phone is useful for reading and revision.
- Early exercises run in the browser. Later work uses local Python, Git, an editor and a Linux environment.
- You do not need a GPU to begin. Specific advanced GPU, distributed and cluster labs need suitable hardware or a separately arranged environment.
- Model downloads need internet access and disk space. Any external hosting or paid services are separate from course access.
Questions before you start
A few clear answers to help you choose your next step.
Can I start without knowing Python or AI?
Yes. The route begins with computer basics, files and tools before Python. It also introduces Linux and the mathematics needed for later AI topics.
Do I need an expensive GPU?
You can start on an ordinary laptop or desktop. Early programs and small model exercises use the browser or CPU. Later GPU and distributed labs explain their own hardware requirements.
Will I build applications while learning the theory?
Yes. Small Python projects come early. You then connect interfaces, APIs and databases before moving into model training, retrieval, agents and deployment.
Does the route include advanced AI engineering?
It includes separate advanced routes for distributed training, custom CUDA kernels and Kubernetes. Follow them after the relevant programming, model and deployment foundations.
Keep exploring
Connect this route to another skill, or start with a short beginner guide.