AI Agent Engineering Foundations
From Python, data and cloud basics to a deployed generative AI application and a governed multi-agent system
About this course
A six-phase foundation programme for early-career engineers. It starts with Python, data stores, containers and MLOps, moves through microservices and large language model fundamentals, builds retrieval-augmented generation with guardrails, and then designs, instruments and governs single- and multi-agent systems.
The fifth phase is a team build of a full-stack generative AI application, and the sixth turns that build into a clear, well-structured presentation for a leadership audience. Model comparisons use more than one provider so that choices are made on evidence rather than habit.
What you’ll be able to do
- Manipulate, visualise and store structured, semi-structured and unstructured data, and choose the right store for each
- Containerise, deploy and scale services on Azure with secrets and access handled properly
- Explain how large language models work well enough to reason about tokens, context, cost and model choice
- Design and evaluate prompts and retrieval pipelines with measured rather than assumed quality
- Build, trace and govern single- and multi-agent systems with approval in front of every irreversible action
- Ship a tested full-stack generative AI application and present it clearly to a leadership audience
Before you start
What this course assumes you can already do.
- Basic programming in any language and comfort with the command line.
- No prior machine learning, cloud or SQL experience is assumed; the first phase builds it.
The curriculum
Open any module to see its objective, every teaching topic, the practice brief and the checkpoint.
Recaps and reference material are included in the LMS.
PART 1Foundations and Data Essentials
01Python Refresher and Data Basics
Work fluently with pandas and NumPy, visualise data to make one point clearly, and classify data by structure and origin.
- NumPy arrays and pandas DataFrame manipulationHands-on
- Visualisation with matplotlib and seabornHands-on
- Structured, semi-structured and unstructured dataConcept
- Where data comes from: application databases, user files and organisational storesConcept
- Telling a data story in a Jupyter notebookHands-on
A notebook that answers one question
Pick a public or synthetic dataset of at least ten thousand rows and write a notebook that answers a single business question stated at the top. Clean only the columns you need, show three charts that each carry one message, and finish with a conclusion and one honest caveat about the data.
Knowledge checkpoint with explained answers
02Git and Cloud Basics
Collaborate through branches and pull requests, and understand how cloud subscriptions and resource groups organise work, access and cost.
- Git essentials: commits, branches and pull requestsHands-on
- Cloud versus on-premise, and how subscriptions and resource groups organise workConcept
- Walkthrough of one Azure subscription and its resourcesDemonstration
- Team repository exercise: one commit per personHands-on
Run a clean pull-request cycle
Create a repository for a tiny utility, protect the main branch, and ship three changes through separate branches and pull requests. Deliberately create one merge conflict and resolve it. Then sketch, in a short README section, how you would organise a subscription and resource groups for a team of four building a chatbot.
Knowledge checkpoint with explained answers
03AI Basics
Place today’s language models in the history of AI, choose evaluation metrics deliberately, and compare model providers on durable criteria.
- From machine learning to large language models: a short historyConcept
- How deep learning architectures evolved from RNNs to transformersConcept
- Deep learning frameworks: PyTorch, TensorFlow and KerasConcept
- Evaluation metrics for regression and classificationConcept
- Positioning model providers: Claude and GPT families comparedConcept
- Mapping AI applications to technique and metricHands-on
Choose the metric before the model
Take four realistic AI use cases, such as fraud flagging, delivery-time prediction, document routing and product search. For each, name the type of AI involved, the evaluation metric you would report and the error that costs the business most. Explain with numbers why accuracy alone would mislead in at least two of them.
Knowledge checkpoint with explained answers
04Deployment Essentials
Containerise an application, deploy and scale it on Kubernetes, automate delivery, and keep credentials out of code.
- Dockerfiles, images and containersHands-on
- Deploying and scaling an AI app on Azure Kubernetes ServiceHands-on
- Automated build, test and deploy with Azure PipelinesHands-on
- Access control and secrets: RBAC and Azure Key VaultConcept
- Containerise, deploy and scale a prebuilt web appHands-on
Ship a container with no secrets in it
Containerise a small API, push the image to a registry and deploy it to a managed Kubernetes cluster with two replicas. Store its one credential in a secret store and grant access through a role rather than a key. Add a pipeline that rebuilds and redeploys on merge, then scale to four replicas and back.
Knowledge checkpoint with explained answers
05MLOps
- The model lifecycle: development, release and productionConcept
- Tracking experiments and metrics with MLflowHands-on
- Logging and registering modelsHands-on
- Monitoring models after releaseConcept
Make one result reproducible
Train three variants of a simple model on a public dataset and track every run with MLflow, including parameters, metrics and the data version used. Register the best model and promote it, then register a second version and roll back. Write down which monitoring signals you would alert on once it serves predictions.
Knowledge checkpoint with explained answers
06Data Stores and Structured Data
Choose between relational and document stores, design a normalised schema, and write SQL from simple queries to views, functions and procedures on a managed database.
- Types of data stores: relational databases and document storesConcept
- The relational model and normalisationConcept
- Designing an ERD and implementing it in PostgreSQLHands-on
- SQL syntax essentialsHands-on
- Queries, functions, stored procedures, views and join strategiesHands-on
- Azure SQL: a managed database and a processing pipelineHands-on
From diagram to trustworthy tables
Design a schema for a small appointment-booking service with customers, providers, slots and bookings. Draw the ERD, implement it with keys and constraints, and load sample data. Write a view for daily utilisation and a stored procedure that books a slot without allowing double booking, then prove the rule holds.
Knowledge checkpoint with explained answers
07Unstructured and Semi-Structured Data
Store and query documents in Cosmos DB with a sound partition key, and turn scanned and digital PDFs into usable text and structure.
- Storage options for unstructured and semi-structured data: Azure Storage and Cosmos DBConcept
- Cosmos DB fundamentals: global distribution, low latency and request unitsConcept
- Modelling JSON documents and choosing a partition keyHands-on
- CRUD, the SQL API and consistency levels in Cosmos DBHands-on
- OCR and document intelligenceConcept
- Reading PDFs with open-source libraries and Azure Document IntelligenceHands-on
Pick the right store and parse the documents
You receive a folder of supplier invoices, half scanned and half digital, plus a JSON feed of order events. Parse the invoices with an open-source library and with a managed document model, and compare field accuracy on ten documents. Store the parsed invoices and events in a document database with a partition key justified by the query pattern.
Knowledge checkpoint with explained answers
08Data Pipelines
Turn manual data work into a scheduled, re-runnable pipeline that fails loudly, and compare it with a managed pipeline service.
- What a data pipeline is and why it must be repeatableConcept
- Automating with Python scripts and schedulingHands-on
- Building a data processing pipeline in Azure Machine LearningHands-on
A pipeline you can safely re-run
Build a pipeline that ingests a daily CSV drop, validates it, cleans it and writes a curated table. Run it twice on the same input and prove the output does not duplicate. Break the input deliberately and show that the run fails loudly with a useful log line. Then port one step into an Azure Machine Learning pipeline.
Knowledge checkpoint with explained answers
PART 2Application and Generative AI Essentials
09Python Configuration, Validation and Microservice Basics
Structure a Python service with validated input, external configuration and useful logs, and understand when microservices are worth their cost.
- Working with JSON, YAML and configuration filesHands-on
- Data validation and serialisation with PydanticHands-on
- Logging, error handling and project structureHands-on
- REST principles and a microservices overviewConcept
- Flask basics: routes and lightweight APIsHands-on
A validated, configurable service
Build a small Flask service that accepts an order as JSON, validates it with Pydantic and returns a priced quote. Read tax rates and currency from a YAML configuration file, log each request with a correlation id, and return clear client-error responses for invalid input. Arrange the code so a new engineer can find the validation logic in under a minute.
Knowledge checkpoint with explained answers
10Building Microservices with FastAPI
Build typed, tested FastAPI endpoints with explicit contracts, and run them on Azure with a managed identity instead of keys.
- FastAPI essentials: path, query, body and status codesHands-on
- Pydantic schemas in FastAPI, including nested modelsHands-on
- Unit testing APIs with pytestHands-on
- Azure fundamentals for services: resource groups, storage and managed identityConcept
- A FastAPI service that reads digital PDFsHands-on
A tested document-reading API
Build a FastAPI service with an endpoint that accepts a PDF upload, reads its text with PyMuPDF and returns the page count, a title guess and the first five hundred characters. Define request and response schemas, reject non-PDF uploads with the right status code, and write pytest tests for success and failure. Describe how it would reach storage through a managed identity.
Knowledge checkpoint with explained answers
11Core Azure Services: Compute, Messaging and Load Balancing
Choose Azure compute, messaging and load-balancing services from the traffic pattern, and decouple slow work so failures do not cascade.
- Decoupling with Azure Queue Storage and Service BusConcept
- Azure Load Balancer and Application Gateway basicsConcept
- Azure Functions and App Service in practiceHands-on
Choose compute and messaging for a real workload
A document service receives uploads in bursts and runs a slow processing step. Design it on Azure: choose between Functions and App Service for the front door, choose a queue or broker for the hand-off and choose a load-balancing option. Deploy a minimal version with a queue between upload and processing, and show a burst being absorbed.
Knowledge checkpoint with explained answers
12Middleware, Queues and Distributed Architecture
Make services resilient and observable with middleware, message queues, sensible concurrency and health probes.
- Middleware patterns: logging, metrics, retry and circuit breakerHands-on
- Integrating message queues in Python: Service Bus and RabbitMQHands-on
- Load-balancing strategies: round robin and least connectionsConcept
- Concurrency with Uvicorn and GunicornHands-on
- Health checks and readiness probesHands-on
- Observability: structured logs and Prometheus metricsHands-on
Make a flaky dependency survivable
Put a deliberately flaky downstream service behind your API. Add retries with backoff, a circuit breaker, readiness and liveness probes, structured logs and Prometheus metrics. Load-test several worker counts, then kill the dependency and show the API degrading gracefully instead of hanging. Record which metric told you first what was wrong.
Knowledge checkpoint with explained answers
13Introduction to Generative AI
Explain what generative AI is, which model families produce which kinds of content, and where it does and does not fit an enterprise problem.
- What generative AI is and how it differs from predictive AIConcept
- Types of generation: text, image, audio and codeConcept
- Model families: transformers, diffusion models and GANsConcept
- Enterprise applications across industriesConcept
- Mapping generative AI types to problem statementsHands-on
Say where generative AI fits and where it does not
Collect eight problem statements from a domain you know. For each, decide whether generative AI fits, which modality it would use, what a failure would look like and who must check the output before it is used. At least two answers should conclude that a non-generative approach is better, with the reason stated.
Knowledge checkpoint with explained answers
14LLM Fundamentals
Reason about how language models are built and tiered, what tokens and context cost, and how to compare providers on measured evidence.
- Anatomy of language models: GPT, BERT and LLaMAConcept
- Transformer architecture basicsConcept
- Pretraining versus fine-tuningConcept
- Tokenisation and embeddingsHands-on
- Model tiers and long context: Claude, GPT and open-weight models comparedConcept
- Exploring GPT and Claude through playgrounds and APIsHands-on
Measure, do not guess
Choose five tasks, such as summarising a policy, answering from a table, classifying tickets, drafting an email and explaining code. Run each on two providers and two model tiers, recording tokens, latency, estimated cost and a rubric score. Recommend a default model and a fallback, and state what evidence would change your mind.
Knowledge checkpoint with explained answers
15Prompt Engineering and Model APIs
Design, evaluate and debug prompts against a fixed test set, and call several model providers through one thin, reliable wrapper.
- Prompt types: zero-shot, few-shot and chain-of-thoughtConcept
- Prompt design principles and prompt tuningConcept
- Evaluating and debugging promptsHands-on
- Calling OpenAI, Azure OpenAI and Anthropic APIsHands-on
- Provider-specific prompting: structured prompts and principle-guided instructionsHands-on
- Prompts for summarisation, Q&A and classification with LangChain and PromptLayerHands-on
A prompt with an evaluation behind it
Pick a classification task with at least six categories and build a labelled set of forty examples. Write a zero-shot prompt, a few-shot prompt and a structured prompt, run each against two providers and score them. Debug the worst category and show the fix improving its score without breaking the others.
Knowledge checkpoint with explained answers
PART 3Generative AI Systems
16Retrieval-Augmented Generation and Vector Databases
Build a retrieval-augmented pipeline, choose a vector store for a stated workload, and measure retrieval separately from answer quality.
- RAG architecture and flowConcept
- Vector databases compared: Pinecone, Weaviate, FAISS and Azure AI SearchConcept
- Indexing, retrieval and latency considerationsConcept
- Building a RAG pipeline with LangChain and Azure AI SearchHands-on
- Retrieval versus long context: testing a hybrid approach with ClaudeHands-on
Measure retrieval before you judge answers
Index at least fifty policy or product documents and write twenty questions with known answers and known source passages. Measure how often the right passage appears in the top five results, then measure answer correctness. Change one retrieval setting, re-measure both, and compare with a long-context approach on the same questions.
Knowledge checkpoint with explained answers
17Generative AI Experimentation
Run fair, reproducible experiments on generative systems and turn user feedback into better decisions.
- Evaluation metrics, benchmarks and model capabilitiesConcept
- Tracking model performance across experimentsHands-on
- Logging outcomes and building feedback loopsHands-on
- Designing a fair comparison between two configurationsHands-on
Run an experiment you would defend
Compare two configurations of an assistant, such as two models or two prompts, on a fixed set of at least thirty tasks. Define the metric before running, track every run, and collect simulated user feedback on ten outputs. Decide which configuration to ship and explain whether the difference is large enough to matter.
Knowledge checkpoint with explained answers
18Governance, Guardrails and Deployment Frameworks
Apply responsible-AI principles as concrete checks, add tested guardrails, and choose frameworks and deployment settings on cost, latency and compliance.
- Responsible AI principles: bias, hallucination and explainabilityConcept
- Guardrails: moderation and safety layersHands-on
- Applying an organisation’s responsible-AI principlesConcept
- Frameworks compared: LangChain, LlamaIndex and HaystackConcept
- Deployment considerations: cost, latency and complianceConcept
A launch checklist with teeth
Take the retrieval assistant from module 16 and write its launch checklist: cost per thousand requests, latency budget, moderation settings, data-handling rules and the principles it must meet. Add input and output guardrails and test them with fifteen adversarial prompts and fifteen normal ones. Report missed harms and false refusals separately.
Knowledge checkpoint with explained answers
19Putting It Together: A Generative AI Use Case End to End
Assemble queueing, retrieval, multi-model routing, storage and an API into one deployed service that survives a provider failure.
- Calling Azure OpenAI and Hugging Face APIs, with simple retrieval and no vector databaseHands-on
- Multi-model integration and routing strategiesHands-on
- A complete pipeline: queue, processing, storage and APIHands-on
- Containerising and deploying to Azure App Service or Container InstancesHands-on
- Best practices, a CI/CD overview and next stepsConcept
One use case, deployed
Build a service that takes requests from a queue, retrieves context, calls a model through a router with a fallback provider, stores the result and serves it through an API. Containerise and deploy it to a managed host. Switch off the primary provider during a test run and show the fallback working without losing a request.
Knowledge checkpoint with explained answers
PART 4Agentic AI Systems
20Foundations of Agentic AI
Explain what makes a system agentic, choose between workflow, single-agent and multi-agent designs, and place human approval where it belongs.
- What agentic AI is and how it differs from traditional and generative AIConcept
- Core capabilities: perceive, reason, act and learnConcept
- Single-agent versus multi-agent systemsConcept
- Real-world applications in healthcare, mobility and customer serviceConcept
- Using models for reasoning-heavy, multi-step decisionsConcept
Decide whether it should be an agent
Take three candidate automations from a domain you know. For each, decide whether it should be a fixed workflow, a single agent or several agents, and justify the choice by the number of decisions, the tools needed and the cost of a wrong action. Mark every point where a human must approve before the system acts.
Knowledge checkpoint with explained answers
21Agent Lifecycle and Frameworks
Build agents with memory and tools in LangChain and LangGraph, with explicit state, stop conditions and step budgets.
- The agent lifecycle and planning loopsConcept
- LangChain and LangGraph for agentsConcept
- Building a simple agent with memory and tools in LangChainHands-on
- Building the same agent with Claude through LangChain and LangGraphHands-on
An agent that knows when to stop
Build an agent with a search tool, a calculator tool and short-term memory, using LangGraph for control flow. Add an explicit stop condition and a maximum step budget. Run it on ten test conversations, including one where a tool always fails, and show that it stops cleanly rather than looping. Repeat with a second model provider.
Knowledge checkpoint with explained answers
22Multi-Agent Architectures and Frameworks
Choose a multi-agent coordination pattern from the task structure, place the Model Context Protocol correctly, and build one workflow in a chosen framework.
- Multi-agent coordination patternsConcept
- Where the Model Context Protocol fitsConcept
- Framework survey: a managed agent service, the OpenAI Agents SDK and CrewAIConcept
- Deep dive: building a multi-agent workflow in one frameworkHands-on
Justify a second agent
Split the single agent from module 21 into a supervisor with two specialists in a framework of your choice. Run both versions on the same fifteen tasks and compare success rate, cost and time. Keep the multi-agent version only if the evidence supports it, and explain where the Model Context Protocol would or would not help.
Knowledge checkpoint with explained answers
23Tools, APIs and Middleware Integration
Give agents well-specified tools, durable memory and production middleware, with approval in front of every state-changing action.
- Memory, tool orchestration and agent chainingConcept
- Connecting agents to APIs, databases and external toolsHands-on
- Middleware for agents: Redis, FastAPI and event queuesHands-on
- Provider tool-use patterns versus function callingConcept
- Integrating a Claude-based agent with a backend API and memoryHands-on
Tools with contracts
Design four tools for an order-support agent: look up an order, check stock, create a return and send a message. Write each contract with arguments, return shape, error shape and whether it changes state. Implement them behind FastAPI with Redis memory, gate the two state-changing tools behind approval, and test that state survives a restart.
Knowledge checkpoint with explained answers
24Agent Workflows
Design delegated agent workflows with owners, contracts and acceptance checks, and compare visual and code-first orchestration.
- Agent orchestration with AutoGen Studio and Semantic KernelConcept
- Designing agent workflows and task delegationConcept
- Building a multi-agent system with AutoGen StudioHands-on
Delegation with acceptance checks
Design a three-agent workflow that prepares a weekly status report from tickets, commits and meeting notes. Record every place the output needed a human fix, then adjust the delegation to reduce them.
Knowledge checkpoint with explained answers
25Monitoring and Governance for Agents
Make agents traceable, auditable and guarded, and use feedback to fix failures you can explain from evidence.
- Observability for agents: tracing, logging and feedback loopsConcept
- Governance: safety, guardrails and complianceConcept
- Provider safety layers, prompt-response auditing and complianceConcept
- Adding a feedback loop and guardrails to the agent you builtHands-on
Make an agent auditable
Instrument your agent so every run produces a trace of model calls, tool calls, inputs, outputs, cost and latency. Add input and output guardrails and a feedback control. Replay three failed runs from their traces and explain each failure, then show the guardrail or fix that prevents it. Store an audit record a reviewer could read without you.
Knowledge checkpoint with explained answers
26Building an Agentic AI System
Build and document a small multi-agent system as a team, review each other’s artefacts, and consolidate the agentic phase.
- Building a multi-agent system: researcher, summariser and notifierHands-on
- Documenting architecture, workflows and governance strategyHands-on
- Peer review of team artefactsHands-on
- Recap, doubt clearing and focused questionsConcept
Ship a small agent team with its paperwork
Build a researcher, summariser and notifier system that monitors a synthetic news feed for a chosen topic and sends a daily digest. Document the architecture, workflows, guardrails and escalation path. Swap artefacts with another team, review theirs against a checklist, and apply two improvements from the review you receive.
Knowledge checkpoint with explained answers
PART 5Capstone Build: A Full-Stack Generative AI Application
27Project Setup and Architecture
Charter a team project with a testable success measure, an architecture and a working, least-privilege environment.
- Defining the problem statementHands-on
- Choosing a project type: chatbot, summariser or recommenderConcept
- Drafting the architecture and selecting the stackHands-on
- Team roles, repository, cloud services and documentation structureHands-on
A one-page project charter
Write a one-page charter for your team’s application covering the user, the problem, the success measure, what is out of scope, the project type and an architecture sketch. Set up the repository with branch protection, the cloud resource group and a documentation skeleton, and assign roles with named owners.
Knowledge checkpoint with explained answers
28Backend and AI Integration
Build the backend with a provider-agnostic model wrapper, measured retrieval and tests that cover model failures.
- Setting up the FastAPI backendHands-on
- Integrating model APIsHands-on
- Setting up a vector store and implementing embedding and retrievalHands-on
- Testing API endpointsHands-on
- Model selection strategy: cost, latency and reasoningConcept
A backend you can switch providers on
Build the backend for your capstone with health checks, a model wrapper, retrieval over your documents and endpoint tests. Measure the retrieval hit rate on fifteen known-answer questions. Switch the model provider through configuration alone and re-run the tests to prove nothing else changed.
Knowledge checkpoint with explained answers
29Frontend and Middleware
Put a usable interface in front of the backend, trace a user action end to end, and improve the design from observed use.
- Building the interface in StreamlitHands-on
- Connecting the frontend to the backendHands-on
- Adding middleware for logging and error handlingHands-on
- Implementing the user interaction flowHands-on
- UI testing and a feedback loopHands-on
Watch someone use it
Connect your interface to the backend with loading states, error messages and a flag-this-answer control. Add correlation ids so one user action can be traced end to end. Run a short test with three people outside your team, record where each got stuck, fix the two biggest problems and test again.
Knowledge checkpoint with explained answers
30Deployment and Testing
Deploy through a gated pipeline, find the load limit by measurement, and prove the system can be operated from its runbook.
- Containerising the applicationHands-on
- Deploying to AzureHands-on
- Setting up a CI/CD pipelineHands-on
- Unit, integration and load testingHands-on
- Finalising documentationHands-on
Prove someone else can operate it
Deploy your application through a pipeline that blocks on failed tests and requires approval for production. Run a load test and record the point where latency or cost becomes unacceptable. Ask a teammate who did not build the deployment to redeploy and roll back using only your runbook, then fix every step they stumble on.
Knowledge checkpoint with explained answers
31Demo and Documentation
Package the build as a documentation set, a live demo that survives a failure and a clean final repository.
- Preparing documentation: problem, architecture, demo, runbook and learningsHands-on
- Running a live group demoHands-on
- Peer review and feedbackHands-on
- Submitting the final repositoryHands-on
A demo that survives a failure
Write a five-minute demo script that shows the main journey, one deliberately triggered failure handled gracefully and your quality evidence. Rehearse it twice, record a fallback video and run it for another team. Give that team three specific pieces of feedback, and apply the two most useful comments you receive.
Knowledge checkpoint with explained answers
PART 6Effective Presentations
32Creating a Storyboard
Plan a presentation as a sequence of messages and visuals for a specific audience before building any slide.
- What a storyboard is and why it helpsConcept
- Elements of a good storyboard: structure, visual hierarchy and flowConcept
- Aligning the storyboard with audience needsConcept
- Sketching key slides in CanvaHands-on
- Building, presenting and editing a team storyboardHands-on
Storyboard before slides
For your capstone application, write a storyboard of no more than eight frames covering the audience, the problem, the insight, the solution, the evidence, the risk and the ask. Sketch each frame in a design tool, present it to another group for three minutes and revise it based on their feedback.
Knowledge checkpoint with explained answers
33The Art and Science of Storytelling
Shape technical work into a memorable story with a clear conflict, a core message and honest analogies, and deliver it with control.
- Storytelling in businessConcept
- Story structure: setup, conflict and resolutionConcept
- Finding the core message and the stakeholdersConcept
- Metaphors, analogies and visualsConcept
- From storyboard to slides, with voice, pacing and body languageHands-on
- A three-minute story pitch for your applicationHands-on
Three minutes, one message
Write and rehearse a three-minute pitch for your application using setup, conflict and resolution, with one analogy and no more than five slides. Record yourself, review the recording for one delivery improvement and re-record. Ask two peers to write down the message they remembered, and compare their answers with your intended message.
Knowledge checkpoint with explained answers
34Structuring a Good Presentation
Structure a presentation for its audience and goal, with a strong opening, evidence-backed body, clear call to action and deliberate transitions.
- Why structure matters, and common pitfallsConcept
- Introduction, body and conclusionConcept
- Adapting structure to audience and goalConcept
- The What, So What, Now What modelConcept
- Transitions and restructuring the story deckHands-on
Restructure for two audiences
Restructure your capstone deck twice: once for a leadership audience deciding whether to fund the next phase, and once for engineers who will maintain the system. Use a hook, a clear agenda and a call to action in both, and apply What, So What, Now What to the evidence section. Mark every transition.
Knowledge checkpoint with explained answers
35Peer Review and Feedback
Give specific, respectful feedback with a structured model, and decide deliberately which feedback to act on.
- Why peer feedback matters, and ground rulesConcept
- The Situation, Behaviour, Impact modelConcept
- Dos and don’ts of critique, with empathy and clarityConcept
- Presenting to peers and giving feedback on each presentationHands-on
- Incorporating feedback before the final presentationHands-on
Feedback you would want to receive
Watch two other groups present and write feedback on each using Situation, Behaviour, Impact, with at least one strength and one change per presentation. Then sort the feedback your own group received into act on, consider and decline, and update your deck. Record the reason for anything you decline.
Knowledge checkpoint with explained answers
36Final Demo and Presentation to Leadership
Present the application, its evidence and its limits to a leadership panel, and handle questions with evidence and candour.
- Understanding a leadership audience and the session agendaConcept
- Final presentation and live demo to leadershipHands-on
- Handling questions and agreeing next stepsHands-on
Rehearse the questions, not just the talk
List the ten hardest questions a leadership panel could ask about your application, including cost, risk and what happens when it fails. Draft a short, evidence-based answer to each, run a full rehearsal with a timekeeper, and prepare a one-page leave-behind summarising the problem, the results and the ask.
Knowledge checkpoint with explained answers
Customer-support knowledge assistant for Cobaltline Utilities
Cobaltline Utilities is a fictional regional water and energy supplier whose support team answers billing, outage and service questions from a large, frequently updated policy library. Build a full-stack generative AI assistant that answers from that library with citations, hands off to a person when unsure, and runs a small agent workflow that drafts follow-up actions for human approval. All documents, tickets and customers are synthetic and generated for this course.
Problem charter and architecture — Define the user, the success measure and the architecture before building anything.
Retrieval and model integration — Answer questions from the synthetic policy library with citations and measured retrieval quality.
Follow-up agent with approval — Draft follow-up actions, such as a callback or a billing review, that a person approves before anything happens.
Interface, guardrails and feedback — Put a usable interface in front of the assistant, with guardrails and a way to flag bad answers.
Deployment, testing and runbook — Deploy through a gated pipeline and prove someone else can operate the system.
Leadership presentation — Present the assistant, its evidence and its limits to a leadership panel.
Next course
Tell us about yourself or your team and we’ll let you know how and when you can take this course.