Generative AI Engineer Programme

Programme Overview

Plenty of people can get a large language model to do something impressive in a demo. Far fewer can build a system around one that gives correct, grounded answers to real users, stays within budget, passes a security review and can be deployed, monitored and handed over. Employers hire for the second thing, and that is what this programme teaches.

Over sixteen weeks, at around five hours a week, you work through twelve sections: a short software-engineering bridge, seven core sections on how Generative AI systems are built, a production and AWS deployment section, an independent capstone, a section on turning a vague business request into a deliverable project, and a team challenge set by a real company. There are 183 lessons and 93 hands-on labs, every one of which runs in your own JupyterLab workspace on Vecorra, our learning platform.

The material is written and taught by the engineers who build these systems for Trillectra AI’s clients. The case studies are drawn from that work.

Who the Programme Is For

The programme is designed for:

Final-year students and recent graduates in computer science, data science, software engineering, mathematics or a related subject, who can write Python and want to start a career building AI systems
Software developers, data analysts and data scientists who are being asked to add Generative AI to what they already do
Career changers who have learned Python and completed some project work, and now need the engineering discipline and the portfolio to be taken seriously

What you need before you start

You need to be able to write basic Python: functions, loops, lists and dictionaries, reading and writing files, and installing a package. You should be comfortable using a web browser and a terminal, and willing to learn Git.

You do not need prior experience of machine learning, cloud platforms or software engineering practice. The pre-course section covers Git, testing, APIs, Docker and the AWS basics, and a short diagnostic at the start tells you which parts of it you can skip.

If you are unsure whether your Python is strong enough, use Talk to us first on the training page and tell us. We would rather talk it through than have you rule yourself out.

How the Programme Is Taught

Everything runs on Vecorra. Each section is split into short modules, and each module into lessons of ten to forty minutes. Most lessons are paired with a lab: a JupyterLab notebook, already set up with the libraries, data and API access it needs, in which you build the thing the lesson just explained. A quiz at the end of each module gives you immediate feedback with an explanation for every answer.

A trainer leads a live online session each week, introducing the week’s topic, working through an example and running the lab with the cohort. Between sessions, you work through the lessons at your own pace. An AI tutor is available in every lesson and lab for the first question, and you can message your trainer directly on the platform; the trainer also posts announcements to the cohort, so you never have to hunt through email for what was said.

Each core section ends with an optional case study for a fictional client, such as a regulatory-compliance assistant for a financial firm or an accounts-payable agent for a retailer. These are marked against a published rubric and are the best preparation for the capstone, but they are additional to the 85 hours and you can choose how many to attempt.

The primary API throughout is OpenAI’s, with open-weight models from Hugging Face where running a model locally teaches more. You will also use LangChain, LangGraph and LlamaIndex, FAISS and pgvector, FastAPI and Docker, GitHub Actions, and Amazon Bedrock, ECR, App Runner, CloudWatch and IAM on AWS.

Programme Structure

Duration: 16 weeks Effort: About 85 hours of guided work, around 5 hours a week, plus optional case studies Format: Weekly live online sessions, self-paced lessons and labs on Vecorra, a quiz per module Delivery: Online

The twelve sections

Pre-course: AI Engineering Foundations (about 7 hours). Python services, Git and pull requests, pytest, FastAPI, Docker, and AWS IAM, S3 and Bedrock.
Generative AI Foundations (6 hours). How language models work, how they are trained, the current model landscape, and how to work with their behaviour and limits.
Prompt Engineering and Structured Outputs (7 hours). Prompts that behave reliably in production, JSON-schema outputs, tool calling and the OpenAI API in practice.
RAG and Embeddings (8 hours). Retrieval-augmented generation that is grounded, cited and measurably evaluated.
Fine-Tuning and Model Adaptation (6 hours). When to fine-tune rather than prompt or retrieve, LoRA and QLoRA, and the OpenAI fine-tuning API.
Agents and Tool Use (9 hours). Function-calling loops, ReAct and planning, the Model Context Protocol, guardrails and human-in-the-loop controls.
Evaluation and LLMOps (6 hours). Golden sets, LLM-as-judge, regression testing, CI gates, tracing and cost analytics.
Safety, Security and Governance (5 hours). Prompt injection and defences, personal data, UK GDPR and the EU AI Act as they apply to real systems.
Production Deployment (6 hours). Serving patterns, cost and latency, self-hosting trade-offs, and a full deployment path on AWS.
Capstone (11 hours). An independent, portfolio-grade build against one of three industry briefs.
AI Solution Discovery and Delivery (5 hours). Turning an ambiguous company challenge into a measurable, safe and deliverable project.
Employer Challenge Studio (9 hours). A team project on a real company’s challenge, from discovery to deployment and handover.

A typical cohort spends one week on each section, two weeks each on RAG and on agents, and the final three weeks on the employer challenge.

Curriculum

Section 0: AI Engineering Foundations

Four modules and a practical. Python for AI services: project structure, types and error handling; HTTP, JSON and async; configuration, secrets and structured logging. Git, testing and team engineering: branches, pull requests and code review; pytest; continuous integration with GitHub Actions. APIs, validation and data: your first FastAPI and Pydantic service; SQL and application state; API security, health checks and observability. Containers and AWS fundamentals: Docker for AI services; IAM and least privilege; S3, Amazon Bedrock and boto3; the AWS cost and security baseline. The section ends with a support-triage API that must pass automated tests and a code-review checklist.

Section 1: Generative AI Foundations

How LLMs work: tokens and tokenisation; embeddings; attention and the transformer; decoder-only generation. How models are trained: pretraining, supervised fine-tuning, RLHF and preference tuning, and why models behave as they do. The model landscape: frontier and open-weight models in 2026; context windows and their trade-offs; choosing a model on cost, latency and quality. Working with model behaviour: sampling parameters; determinism and its limits; capabilities and limits; the mechanics of hallucination. Case study: model selection for a law firm.

Section 2: Prompt Engineering and Structured Outputs

Prompting fundamentals: roles, system messages and instructions; zero-shot and few-shot; structure and formatting; iterating from draft to reliable. Reasoning and patterns: chain-of-thought; reasoning models and their API differences; patterns that work and anti-patterns that fail. Structured outputs and tools: JSON-schema outputs; function and tool calling; designing reliable tool signatures; validating and repairing model output. The OpenAI API in practice: authentication, requests and streaming; multimodal inputs; errors, retries and cost control; prompt versioning and testing. Case study: a support-triage engine for a telecoms firm.

Section 3: RAG and Embeddings

Embeddings and search: embedding models; vector search with FAISS and pgvector; hybrid search combining BM25 and vectors; measuring retrieval quality. Chunking and processing: preparing documents; chunking strategies; metadata and structured documents; choosing and testing chunk sizes. Building RAG: the architecture end to end; rerankers; query rewriting and expansion; grounding and citations; RAG with LangChain and LlamaIndex. Evaluating RAG: faithfulness and relevance metrics; building an evaluation harness; failure modes and debugging. Case study: a regulatory-compliance assistant.

Section 4: Fine-Tuning and Model Adaptation

When to adapt: fine-tune, RAG or prompting; curating and formatting a training dataset; data quality, bias and coverage. Parameter-efficient tuning: supervised fine-tuning revisited; LoRA and QLoRA; LoRA-tuning a small open-weight model on CPU; quantisation. OpenAI fine-tuning in production: the fine-tuning API end to end; evaluating a tuned model; catastrophic forgetting and regression risk; distillation. Case study: tone adaptation for an insurance claims team.

Section 5: Agents and Tool Use

Tool-calling foundations: the core loop; designing tool schemas; parallel calls and batching; handling tool errors and retries. Agent patterns: ReAct and planning loops; memory and state; the Model Context Protocol, its servers and clients, and when to use it; multi-agent patterns. Guardrails and reliability: guardrails for agentic systems; human-in-the-loop approvals; agent failure modes and debugging; computer-use agents. Agent frameworks: LangChain agents and tool binding; LangGraph stateful graphs; choosing between frameworks and the raw SDK. Case study: an accounts-payable agent for a retailer.

Section 6: Evaluation and LLMOps

Evaluation design: golden sets and rubrics; LLM-as-judge and its biases; calibrating judges against human labels; choosing metrics for different tasks. Testing and CI: regression testing for prompts; CI gates for GenAI changes; prompt and model versioning. Observability in production: tracing; online evaluation and A/B testing; drift detection and feedback loops; token and cost analytics. Case study: an evaluation harness for the compliance assistant.

Section 7: Safety, Security and Governance

Attacks and defences: direct and indirect prompt injection; jailbreaks; layered input and output controls; red-teaming your own system. Data protection: detecting and handling personal data; training-data and context leakage; UK GDPR applied to Generative AI, from lawful basis to automated decisions; Article 22 as reformed by the Data (Use and Access) Act 2025. Governance: the EU AI Act’s risk tiers and GPAI obligations; provider versus deployer responsibilities; model and system cards; incident response. Case study: red-team and harden the accounts-payable agent.

Section 8: Production Deployment

Serving patterns: API gateways; streaming and partial responses; rate limits, retries and reliability; structured concurrency. Cost and latency: caching, including semantic caching; batching and throughput; model routing and fallbacks; capacity planning and unit economics. Operating open-weight models: vLLM and self-hosted serving; when self-hosting wins; monitoring dashboards. Production on AWS: Bedrock runtime and model access; ECR, App Runner and ECS/Fargate; CloudWatch, secrets and runtime IAM; deployment from GitHub Actions with OIDC. Case study: production-harden the compliance assistant.

Section 9: Capstone

You choose one of three briefs: a repairs copilot for a housing association, a research-analyst copilot for a financial firm, or a clinical-admin letters copilot for an NHS-style organisation. You build the complete system on your own: retrieval over a realistic corpus, at least one agentic capability with tool use, an evaluation harness and layered guardrails, deployed with the discipline from Sections 7 and 8. It is marked against a published, weighted rubric, and the finished workspace becomes the centrepiece of your portfolio and your rehearsal for the certification practical exam.

Section 10: AI Solution Discovery and Delivery

Discover the problem: stakeholder interviews; problem framing, baselines and success measures; data, process and risk discovery. Design the solution: should this use Generative AI at all; architecture decision records; acceptance criteria, backlog and delivery plan. Deliver, demonstrate and hand over: team delivery and Git evidence; stakeholder demos and change control; return on investment, handover and portfolio evidence. Practical: a full discovery pack for a simulated client.

Section 11: Employer Challenge Studio

Working in a team of three to five, you take on a challenge set by a real company, with a named sponsor and either approved data or a synthetic equivalent. The work runs in three sprints: a baseline and thin end-to-end slice; quality and integration; hardening and AWS deployment. Each sprint has a gate that must be passed before the next begins, covering scope, evaluation, safety and deployment readiness. You finish with a final evaluation and value case, a demonstration to the employer, a handover pack, and an individual viva in which you explain your own contribution. Every team member must author meaningful code, review a colleague’s work and leave a Git record that shows it.

Learning Outcomes

By the end of the programme you will be able to:

Take an ambiguous business request, work out whether Generative AI is the right tool, and turn it into a scoped project with a baseline and a measure of success
Build a tested Python and FastAPI service that calls a language model through a well-designed prompt and returns validated, structured output
Build a retrieval-augmented generation system over a document corpus, with citations, and show with an evaluation harness how accurate it is and where it fails
Build an agent that uses tools safely, with guardrails, human approval where it matters, and a clear record of what it did
Decide when fine-tuning is justified, and carry it out on both an open-weight model and through a hosted API
Set up evaluation, regression testing and tracing so that a system can be changed with confidence once it is live
Recognise and defend against prompt injection and data leakage, and explain what UK GDPR and the EU AI Act require of the system you have built
Containerise a service and deploy it to AWS through a controlled path, with logging, runtime IAM, health checks and a rollback plan
Work in a team through Git branches, pull requests and code review, and explain your own contribution under questioning

Certification

The programme prepares you for the Vecorra Certified Generative AI Engineer (Associate) certification, code VCA-GAI. It has two parts: a 90-minute theory exam of 50 scenario-based questions drawn from a seven-domain blueprint, with a pass mark of 70 per cent, and a practical exam completed in a JupyterLab workspace and graded on the artefacts you produce. The blueprint is vendor-neutral and covers the same seven areas as Sections 1 to 8 of the programme. The certification is valid for three years.

The capstone in Section 9 is designed as a rehearsal for the practical exam, and the module quizzes throughout the programme draw on the same question bank as the theory exam.

What You Leave With

A capstone repository and write-up you built independently, marked against a published rubric
A contribution record from a real employer challenge, with the employer’s feedback where they consent to share it
Evidence of a service you deployed to AWS yourself
A Git history of branches, pull requests and reviews that shows how you work in a team
Three interview stories you can tell with evidence: a technical decision, a failure you debugged, and a trade-off you negotiated with a stakeholder
Preparation for the VCA-GAI certification

Fees and How to Enrol

The programme costs £699, including VAT. You can pay it in one payment or as four monthly payments of £174.75; the total is the same either way, and the monthly payments stop automatically after the fourth. Both give you access to the course material for life and to the JupyterLab lab environment for six months from your first payment. Vecorra certification exams are booked separately.

Enrolment is on Vecorra, our training platform. Create an account, choose the programme and pay; your workspace is ready the same day, and your trainer and cohort are on the platform with you. If you are not sure you meet the prerequisites, or you want to talk about timing or funding before you pay, use Talk to us first on the training page and we will reply by email.

About Trillectra AI

Trillectra AI is a UK company that builds Artificial Intelligence systems for organisations, provides Data Science and Generative AI training, and carries out applied research with universities and industry. The people who wrote and teach this programme are the same people who deliver our client work, and the case studies are drawn from it.

Innovate. Educate. Elevate.