Model
Software trained to recognize patterns and generate outputs from the information it receives.
AI Engineering Fundamentals · AI-FND · v0.3.21-r1 Practical Build Edition
Learn how to build AI applications—and how to make them dependable.
New to AI engineering? You can start here. The course explains the mental models first, then progressively introduces the engineering terms and production controls behind modern language-model applications: prompts, structured outputs, retrieval and RAG, tools, workflows, evaluation, security, observability, cost and reliable operations.
My Learning progress
0% complete
0 of 12 curriculum modules completed · 0/12 currently published modules complete · 0 with lab + knowledge-check evidence.
New to AI? Start here
No previous AI or machine-learning experience is required.
Basic Python and command-line familiarity help with the labs, but the AI-specific ideas are introduced from first principles. You will learn the plain-English idea first and the engineering terminology immediately after it.
Prompt
The instructions and information you give a model for a particular task.
Token
A small piece of text that a language model processes. Token counts affect context limits, speed and cost.
Context
The information available to the model for the current request: instructions, conversation, retrieved documents and tool results.
Inference
Running an already-trained model to produce an output. This is different from training the model itself.
How the learning works
Plain English first. Engineering depth next.
Each module explains the problem, builds a mental model, introduces the technical terms, applies them in an account-free lab, shows failure modes and connects the result to production engineering.
WHY→PLAIN ENGLISH→MENTAL MODEL→ENGINEERING DETAIL→TRY IT→BREAK / FIX→PRODUCTION VIEW
Why this course exists
A fluent answer is not proof that an AI system is ready for production.
The course follows one system, Atlas Assist, from requirement to release evidence so learners see how model behaviour becomes a controlled software system.
Problem→Contract→Model + Context→RAG + Tools→Evals→Guardrails→Observe→Operate
Learner outcomes
After this course, you should be able to design and defend the system—not just call a model API.
Turn an AI idea into a testable application contract with explicit failure behaviour.
Select and serve models using workload quality, latency, context, memory, governance and cost evidence.
Build grounded RAG systems with measurable retrieval and citation behaviour.
Use structured outputs and tools without delegating authorization to the model.
Choose deterministic workflows before agents and bound agent state, tools, budgets and approvals.
Create eval datasets and regression gates that block critical quality or security regressions.
Threat-model prompt injection, sensitive data, output handling and model/data supply chain risks.
Instrument AI applications for latency, cost, quality, fallback and tool/retrieval diagnosis.
Defend a production promotion decision with evidence rather than a demo.
Prerequisites
Engineering foundation recommended; no AI API purchase required.
You do not need ML mathematics or model-training experience. Python and Linux confidence will make the labs substantially easier.
Recommended knowledge
- Python: variables, functions, JSON, HTTP basics
- Linux shell and local files
- Basic APIs and software testing
- Containers are helpful for production context
This course is not
- An ML model-training/deep-learning mathematics course
- A collection of prompt “hacks”
- An Ollama, OpenAI or agent-framework certification
- A claim that agents should replace deterministic software
- A substitute for domain-specific safety/legal review
Core lab environment
Python 3 + shell. Core labs are account-free and provider-neutral. Ollama is the optional local real-tool path; hosted APIs may be substituted if your organization approves them.
Recommended Academy preparation
If a prerequisite feels unfamiliar, use the existing engineering path first.
Running case · Atlas Assist
One assistant. Twelve modules. One accumulating evidence chain.
Atlas Assist answers internal support questions from approved knowledge, cites sources, can perform one bounded read-only asset lookup, and must abstain or escalate when evidence or authority is insufficient.
Core account-free lab pack
The v0.3.19-r2 pack remains the lightweight teaching baseline for the 12 guided module labs.
Download core lab packNEW · Practical Build Lab Pack
Build with FastAPI, Pydantic, Ollama, embeddings/FAISS, RAG, bounded tools, evaluation, security tests, OpenTelemetry and Docker. Includes preflight and automated validators.
Download practical packEvidence over screenshots
The practical capstone requires a running service, citations/abstention, security controls, evaluation evidence, telemetry and container packaging.
Practical Build Track
Build it, break it, diagnose it, fix it, validate it.
The practical pack adds a real engineering layer without making the beginner path depend on paid APIs or one hardware profile.
Preflight→FastAPI + Pydantic→Ollama→Embeddings + FAISS→RAG→Tools→Evals + Security→OpenTelemetry→Docker Capstone
Global learner setup
Linux, macOS and Windows/WSL2 are supported. CPU-only learners can use smaller local models; GPU acceleration is optional.
Failure-driven learning
Labs intentionally exercise unavailable models, malformed outputs, weak retrieval, unsupported questions, tool denial and operational failure states.
Automatic validation
Pack-level and capstone validators distinguish “it ran once” from a reproducible engineering result.
Learning sequence
Begin with the application. Finish with a production release decision.
The learner-facing titles explain the idea simply. Each card also shows the formal engineering focus so you learn the vocabulary in context.
How an AI application works
Engineering focus: AI systems: behaviour, uncertainty and engineering contracts
An AI model is only one part of an application. In this module you learn what the model does, what the surrounding software must control, why answers can vary, and how to define what “good” and “safe” mean before writing code.
Open module →Run and connect to an AI model
Engineering focus: Models, inference and local serving
Learn what happens when an application sends a request to a model, how local serving with Ollama works, and how to choose a model using practical constraints such as memory, speed, context size and task quality.
Open module →Give the model clear instructions
Engineering focus: Prompt and context engineering
Learn how to separate instructions from user or document data, give the model only the context it needs, and treat prompts as versioned application assets that must be tested rather than as one-off tricks.
Open module →Get predictable answers and safe tool requests
Engineering focus: Structured outputs and tool contracts
Move beyond free-form text. Define the shape of an answer, validate it before software trusts it, and treat a model’s request to use a tool as a proposal that still needs normal application authorization.
Open module →Search by meaning, not only keywords
Engineering focus: Embeddings, semantic search and retrieval
Learn how text can be represented numerically so similar ideas can be found even when they use different words. Then compare keyword, vector and hybrid retrieval and measure whether search actually finds the right evidence.
Open module →Let AI answer from your documents
Engineering focus: RAG: grounding, citations and failure modes
Build a retrieval-augmented generation (RAG) pipeline that finds relevant evidence, gives it to the model, cites sources and abstains when the available evidence is not good enough.
Open module →Use workflows first, agents when they add value
Engineering focus: Workflows, tools and agentic systems
Start with predictable software workflows. Then learn when model-directed decisions are useful, how tools and state are bounded, and where approvals, budgets, stop conditions and recovery are required.
Open module →Test whether the AI actually works
Engineering focus: Evaluation, testing and regression engineering
Turn quality into evidence. Build evaluation cases, measure important failure slices, compare versions and prevent prompt, model or retrieval changes from silently making the application worse.
Open module →Protect the AI application
Engineering focus: AI security, safety and governance
Learn how prompt injection, poisoned retrieved content, sensitive-data leakage and tool abuse become application security problems, and how layered controls reduce risk.
Open module →See what the AI system is doing
Engineering focus: AI observability and operations
Trace retrieval, model and tool steps; measure latency, errors, fallbacks, usage and quality signals; and collect enough telemetry to diagnose failures without unnecessarily logging sensitive content.
Open module →Run AI reliably and control cost
Engineering focus: Production architecture, economics and reliability
Design fallbacks, routing, concurrency and service objectives so the AI feature can handle traffic, failures and budget limits while making explicit trade-offs between quality, latency and cost.
Open module →Build and validate a production AI system
Engineering focus: Production AI engineering capstone
Bring the complete engineering chain together for Atlas Assist: requirements, model choice, RAG, tools, evaluation, security, observability, reliability and a release decision supported by evidence.
Open module →Reference standards and current practice
Primary-source anchored, provider-neutral engineering.
The curriculum uses primary guidance for structured outputs/evaluation, local model capabilities, AI risk, GenAI application security and telemetry conventions rather than relying on influencer patterns.
Application contracts & evals
Local inference
Ollama API · tool calling · structured formats · embeddings
Security & risk
Observability
OpenTelemetry semantic conventions. GenAI conventions evolve; production teams should pin and review the convention version they adopt.
Learning modules
FREE
All 12 modules are open learning content.
Hands-on labs
FREE
Account-free core labs plus optional local Ollama practica.
Assessment
FREE
30 randomized questions, 35-minute server timer, pass ≥75%, maximum 2 attempts per 24 hours.
Course completion certificate
FREE
After completing all modules, core labs and knowledge checks, request a publicly verifiable self-paced completion credential. It does not represent an assessment score.
Request completion certificateAssessment-verified certificate
OPTIONAL · ₹499 incl. GST
Certification follows a qualifying timed assessment. It records GNU Group Learning Academy assessment completion; it is not vendor accreditation or a professional licence.
Knowledge assessment
Apply what you learned.
The assessment uses practical AI engineering situations. You do not need to memorize jargon: focus on how the system should behave, what evidence is available and which control belongs outside the model.
The 84-question bank spans seven domains and contains 42 scenario/application questions. Each 30-question attempt preserves domain quotas and guarantees at least 14 scenarios.
12 MODULES→30 QUESTIONS · ≥14 SCENARIOS→35 MIN · PASS ≥75%→2 ATTEMPTS / 24H→OPTIONAL CERTIFICATION
2.5–3.5 hour production AI capstone
Defend a release decision for Atlas Assist.
Connect application contract, model/routing, prompt/context, RAG, structured output, tool policy, evals, threat controls, telemetry, SLO/fallback and residual risk. The capstone is formative; certificate eligibility is based on the timed Academy assessment, not the capstone validator.
Contract→Evidence→Tools→Evals→Security→Operate→PROMOTE / HOLD / ROLLBACK