LLM Engineering Course
Prompting, context engineering, structured output, model APIs, and the evaluation and cost work that turns a working demo into something a team can ship.
Prompting, context engineering, structured output, model APIs, and the evaluation and cost work that turns a working demo into something a team can ship.
- Provider-agnostic, not tied to one vendor
- Structured output and function calling
- Evaluation before optimisation
- Token cost modelled from day one
- Modules
- 8
- Format
- Online
- Mentorship
- Weekly 1:1
- Project
- Production
Why this track
What you get that a general AI course does not cover.
Provider-agnostic by default
You will build the same abstraction across OpenAI, Anthropic and open-weight models. When pricing or model availability shifts, you change a config value instead of rewriting your application.
Context is the real problem
Most teams fail at LLM work because their context is poorly built, not because their prompt is weak. This track spends serious time on retrieval, ordering, compression and caching for context windows.
Evaluation before optimisation
You write a test set before you tune anything, so every later change is measured. Prompt tweaks that feel better but score worse get thrown out, on purpose.
Cost treated as a design constraint
Model routing, caching and prompt compression are covered as engineering problems with measurable outcomes, not afterthoughts you discover on the invoice.
Curriculum
Eight modules, each ending in something you can show.
- M01
How language models actually work
Tokens, attention, next-token prediction and decoding. Enough of the internals to debug output and reason about latency and cost.
- Tokenisation and vocabulary
- Self-attention
- Decoding strategies
- Context windows
Tools
- transformers
- tiktoken
- M02
Prompting and context engineering
Instruction hierarchy, few-shot examples, output contracts, and building context that stays on budget as it grows.
- Instruction hierarchy
- Few-shot selection
- Chain-of-thought
- Context budgeting
Tools
- promptfoo
- OpenAI
- Anthropic
- M03
Structured output and tool use
Schema-constrained generation, function calling, JSON mode and validation. Getting output you can parse without regex.
- JSON schema
- Function calling
- Tool choice
- Parse validation
Tools
- pydantic
- zod
- jsonschema
- M04
Model APIs and abstraction layers
Streaming, retries, rate limits, and a provider interface that lets you swap models without rewriting business logic.
- Streaming responses
- Retry with backoff
- Rate limits
- Provider abstraction
Tools
- LiteLLM
- openai-python
- anthropic-sdk
- M05
Building LLM evaluations
Assembling a test set, scoring with model-graded and deterministic checks, and wiring it into CI so regressions surface early.
- Golden datasets
- LLM-as-judge
- Deterministic checks
- CI integration
Tools
- promptfoo
- deepeval
- ragas
- M06
Latency and cost optimisation
Prompt and result caching, model routing by difficulty, batching, and reading a cost model before you ship.
- Semantic caching
- Model routing
- Batching
- Cost modelling
Tools
- Redis
- vLLM
- M07
Multimodal and long-context work
Images, documents and audio into models. Where long context genuinely helps, and where retrieval still wins.
- Vision inputs
- Document parsing
- Long context vs retrieval
- Context compression
Tools
- OpenAI vision
- Gemini
- Unstructured
- M08
Production patterns and guardrails
Content filtering, prompt-injection defence, fallbacks, and graceful degradation when the model is unsure or unavailable.
- Injection defence
- Guardrails
- Fallback chains
- Graceful failure
Stack
- guardrails-ai
- presidio
- FastAPI
Roles this maps to
Where this track lines up with real job descriptions.
LLM Engineer
The role this track is built for. You own the application layer: prompts, context, evaluation and cost.
AI Platform Engineer
A natural fit if you gravitate toward the abstraction and serving layer rather than product features.
AI Backend Engineer
The LLM work sits on top of ordinary backend skills, so this pairs well with a strong API background.
What you can do afterwards
Concrete capabilities, not a certificate.
- Ship a typed, provider-agnostic LLM client with streaming, retries and cost tracking
- Build an evaluation harness with a golden dataset wired into CI
- Cut a model's token spend measurably through caching, routing and compression
- Defend an application against prompt injection and malformed output
Questions
Do I need to know which model to use before starting?
No. The first module covers how models work and how they are selected. The abstraction you build in module 4 is the point: you should be able to change models without touching application code.
Is this track useful if I already know ChatGPT prompting?
Prompting is roughly one module of eight. Most of the track is context engineering, evaluation, cost and production reliability, which is where the actual engineering work lives.
Will this cover fine-tuning?
It covers the decision: when fine-tuning is worth it and when prompting or retrieval is the cheaper answer. Most teams over-index on fine-tuning early, so understanding that trade-off matters more than the technique itself.
How is this different from the Agentic AI track?
This track goes deep on the model layer itself. The Agentic AI track treats models as components inside agent systems and goes deep on loops, planning and orchestration. The Agentic AI track includes this material as its foundation.
Related tracks
Ready when you are
Applications for the next cohort are open. You pick your track during the first month, so you can change if the material does not suit you.