Modules
252 modules to choose from
Every module is a quarter of a teaching day, so four make a day. Every one can go in your course, in any order, alongside any other. Add one to the builder from here, or open the builder.
AI
AI foundations
How generative AI works, and how to use it with judgement.
- Power Automate
Quarter day · Foundation
What generative AI is, and is not
- Language, image, speech and code models, and what each is good for.
- Where generative AI fits next to search, analytics and conventional software.
- Chat assistants, copilots, APIs and agents: the same models behind different products.
- Common claims, and how to tell a demonstration from a dependable capability.
Quarter day · Foundation
LLM fundamentals
- How an LLM actually produces text, at a practical level.
- Tokens, context windows, and what the model can and cannot see.
- Prompting, system instructions and structured outputs.
- Hallucination and reliability: why it happens and what reduces it.
- Known limits: arithmetic, recency, long documents and confident errors.
Quarter day · Foundation
Retrieval, tools and agents explained
- Why a model alone does not know your organisation’s information.
- Retrieval-augmented generation: answers grounded in your own documents.
- Tools: letting a model look things up and take actions.
- Agents: what the word means, and when a fixed workflow is better.
Quarter day · Foundation
AI risk and policy in an organisation
- Data protection, confidentiality and what providers retain.
- Accuracy, bias and accountability for AI-assisted decisions.
- Approved tools, acceptable use and a policy people will follow.
- Regulation in outline, including the EU AI Act.
Quarter day · Foundation
A working method for AI at work
- Choosing a tool your organisation allows for the task in hand.
- Give context, ask, check, refine: a loop that produces work you can sign off.
- Projects, saved instructions and reusable prompts.
- Exercise: a real task from your role, start to finish.
In Practical Generative AI at Work
Add to a course +Quarter day · Foundation
Research, reading and summaries with AI
- Summarising long documents without losing what matters.
- Comparing sources, and asking for the evidence behind a claim.
- Web search in assistants, and checking citations.
- Exercise: brief yourself on an unfamiliar topic and verify the brief.
In Practical Generative AI at Work
Add to a course +Quarter day · Foundation
Writing and analysis with AI
- Drafting, editing and changing tone without losing your own voice.
- Tables, extraction and structured output from messy text.
- Spreadsheets and data analysis with an assistant.
- Exercise: turn a set of notes into a document and a table.
In Practical Generative AI at Work
Add to a course +Quarter day · Foundation
Checking AI output, and when not to use it
- Spotting fabricated facts, references and figures.
- Proportionate checking: how much review a task deserves.
- Personal and confidential data: what can go into which tool.
- Tasks where AI is the wrong choice.
In Practical Generative AI at Work
Add to a course +Quarter day · Intermediate
Getting more from AI assistants
- Long, structured instructions and examples that get consistent results.
- Working with files, images and long documents.
- Reasoning modes, research modes and when they are worth the wait.
- Exercise: rebuild a prompt you use often so others can reuse it.
Quarter day · Intermediate
Building your own assistants without code
- Projects, custom GPTs and Gems: instructions plus your own documents.
- Skills and saved workflows for tasks you repeat.
- Sharing an assistant with your team, and keeping it accurate.
- Exercise: build an assistant for one of your team’s tasks.
Quarter day · Intermediate
Automating everyday tasks with AI
- Connectors to email, calendars, documents and team tools.
- No-code automation with Power Automate, Zapier or similar.
- Where a person must stay in the loop.
- Exercise: automate a weekly task end to end.
Quarter day · Intermediate
AI for spreadsheets and data
- Formulas, cleaning and reshaping with an assistant.
- Analysis and charts from a question in plain English.
- Checking the numbers before anyone relies on them.
- Exercise: analyse a real spreadsheet from your work.
Quarter day · Intermediate
Tokens, embeddings and next-token prediction
- Tokenisers, vocabularies and why token counts matter.
- Embeddings: meaning as position in a vector space.
- Next-token prediction as the whole of the job.
- Demonstration: inspect tokens and embeddings for real text.
In How Large Language Models Work
Add to a course +Quarter day · Intermediate
Attention and the transformer
- Attention without the maths first, then with a little of it.
- Layers, heads and what the model builds up inside.
- Context length, and why long contexts cost more.
- Demonstration: visualise attention on a short passage.
In How Large Language Models Work
Add to a course +Quarter day · Intermediate
How models are trained and aligned
- Pretraining on large corpora: what the model learns and what it does not.
- Instruction tuning and preference training.
- Reasoning models and extra compute at answer time.
- Fine-tuning versus prompting versus retrieval.
In How Large Language Models Work
Add to a course +Quarter day · Intermediate
Inference, sampling and practical limits
- Temperature, top-p and why the same prompt gives different answers.
- Latency, throughput and what drives cost per request.
- Knowledge cut-offs, hallucination and calibration.
- Demonstration: the same question at different settings.
In How Large Language Models Work
Add to a course +
AI
AI for every role
Sales, HR, finance, legal and customer service teams using AI in their own work.
Quarter day · Foundation
AI for sales and marketing
- Account research and meeting preparation.
- Drafting outreach, proposals and campaign copy in your own voice.
- Summarising calls and keeping the CRM up to date.
- Brand, accuracy and what customers should know about AI-written content.
Quarter day · Foundation
AI for HR and people teams
- Job descriptions, policies and internal communications.
- Answering employee questions from your own handbook.
- Recruitment: where AI helps, and where it creates legal and fairness risk.
- Personal data and what must never go into a public tool.
Quarter day · Foundation
AI for finance teams
- Reading contracts, invoices and statements.
- Variance commentary and management reporting.
- Spreadsheet analysis, and checking every number before it is used.
- Controls, audit trails and confidential figures.
Quarter day · Foundation
AI for legal teams
- Contract review, comparison and clause extraction.
- Research with sources you can verify.
- Privilege, confidentiality and client data.
- Professional duties when AI drafts the first version.
Quarter day · Foundation
AI for customer service
- Suggested replies, summaries and knowledge search for agents.
- Chatbots and voice agents: what to automate and what to hand over.
- Measuring quality, resolution and customer satisfaction.
- Keeping answers accurate as products and policies change.
AI
AI for leaders
Architectural, commercial and organisational decisions about AI.
Quarter day · Foundation
Current AI: a working picture for leaders
- What today’s models can reliably do, and where they still fail.
- The vendor landscape: frontier labs, open models and cloud platforms.
- Assistants, RAG and agents in plain terms.
- Signals worth watching over the next year, and noise to ignore.
Quarter day · Intermediate
Use-case selection and architecture
- Where AI provides real business value, rather than AI for its own sake.
- LLM vs RAG vs agent vs traditional software.
- Designing the right architecture for a given problem.
- Build vs buy.
Quarter day · Intermediate
Production risk and operating cost
- What changes between a pilot and a production service.
- Security, privacy and the failure modes that reach customers.
- Running cost: tokens, hosting, people and evaluation.
- Questions to ask a team before approving a launch.
Quarter day · Intermediate
From pilot to platform
- Why pilots stall, and what gets them out of the lab.
- Shared services: model access, retrieval, evaluation and policy.
- Teams, skills and ownership.
- A first-year plan the organisation can fund.
Quarter day · Foundation
What AI can do in a business
- Patterns that work: drafting, search, triage, extraction and assistance.
- Examples from customer service, operations, finance and sales.
- What still needs people, and why.
- Reading vendor claims critically.
Quarter day · Foundation
Value, risk and the organisation
- Measuring value: time, quality, revenue and risk avoided.
- Responsible use, regulation and reputational risk.
- Change management, skills and how roles shift.
- Governance that enables work rather than stopping it.
Quarter day · Intermediate
AI investment choices
- Off-the-shelf tools, platforms, partners or your own build.
- Enterprise licences against direct API access.
- Total cost of ownership and lock-in.
- Contracts, data terms and exit plans.
Quarter day · Foundation
Prioritising use cases into a first roadmap
- Scoring candidates on value, feasibility, data and risk.
- Quick wins against strategic bets.
- Sequencing, owners and success measures.
- Exercise: a ranked list and a first-quarter plan.
Quarter day · Foundation
Leading a team through AI adoption
- Setting expectations: what AI should and should not change in your team.
- Pilots, champions and sharing what works.
- Worries about jobs, skills and quality, and how to talk about them.
- Exercise: an adoption plan for your own team.
Quarter day · Intermediate
Managing AI-assisted teams
- Measuring productivity and quality when AI does part of the work.
- Review, accountability and who signs off AI-assisted output.
- Skills, hiring and career paths as roles change.
- Policy in practice: approved tools, data and spend.
Quarter day · Intermediate
The EU AI Act in practice
- Risk categories, and where your systems fall.
- Obligations for providers and deployers, and their deadlines.
- General-purpose AI models and transparency duties.
- Exercise: classify your own AI uses and list the obligations.
Quarter day · Intermediate
AI and data protection law
- GDPR and UK GDPR applied to AI: lawful basis, purpose and minimisation.
- Automated decisions and the right to an explanation.
- Data protection impact assessments for AI.
- Providers, transfers and retention.
Quarter day · Intermediate
AI risk assessment
- A repeatable assessment for each AI use case.
- Harms, likelihood, controls and residual risk.
- Who signs off, and when to reassess.
- Exercise: assess one of your own use cases.
Quarter day · Intermediate
AI management systems and ISO 42001
- What an AI management system is.
- ISO/IEC 42001 and how it fits with ISO 27001.
- Policies, roles, inventories and audits.
- A realistic path to certification, or to its benefits without it.
AI
AI for product and delivery
Product, programme and project managers using AI and shipping AI features.
Quarter day · Intermediate
AI-native programme management with Claude
- From AI-assisted to AI-native programme management.
- Claude as a work platform: projects, connectors and skills.
- Custom connectors with MCP for your own systems.
- High-value programme workflows: status, risks, RAID logs and reporting.
- Permissions, cost and keeping people accountable for decisions.
In AI-Native Programme Management with Claude
Add to a course +Quarter day · Foundation
Requirements, user stories and acceptance criteria with AI
- Turning interviews, notes and tickets into requirements.
- User stories and acceptance criteria a team can build and test against.
- Finding gaps, contradictions and edge cases.
- Exercise: draft and challenge the stories for a real feature.
Quarter day · Foundation
Planning, estimation and scheduling with AI
- Breaking work down into plans and work packages.
- Estimates with ranges and stated assumptions.
- Dependencies, critical paths and what-if scenarios.
- Exercise: plan a real piece of work and check the AI’s reasoning.
Quarter day · Foundation
Status reports, RAID logs and stakeholder updates with AI
- Status reports drafted from tickets, notes and plans.
- Risks, assumptions, issues and dependencies kept current.
- One set of facts, written for different audiences.
- Exercise: produce a week’s reporting from raw project data.
Quarter day · Foundation
Meetings, minutes and actions with AI
- Agendas and pre-reads.
- Transcripts, minutes and decision logs.
- Actions with owners and dates, followed up.
- Privacy and consent when meetings are recorded.
Quarter day · Intermediate
Connecting Jira, Confluence and other tools to AI
- Connectors and MCP: letting an assistant read and update your tools.
- Automations: triage, summaries and ticket updates.
- Permissions and what an assistant should never change on its own.
- Exercise: design one automation for your team’s workflow.
Quarter day · Intermediate
Running an AI project
- Why AI projects are less predictable than ordinary software.
- Milestones built around evaluation results, not features.
- Data, security and legal dependencies to plan for early.
- Go, no-go and when to stop.
Quarter day · Foundation
Finding AI product opportunities
- User problems that AI is well suited to, and ones it is not.
- Assistive, automated and generative features.
- Competitive features against features users will pay for.
- Exercise: a shortlist of opportunities for your product.
Quarter day · Intermediate
Designing AI features people trust
- Setting expectations about what the feature can do.
- Showing sources, uncertainty and ways to correct the output.
- Errors, refusals and handing over to a person.
- Collecting feedback that improves the feature.
Quarter day · Foundation
Prototyping with AI tools
- Clickable prototypes and small apps from a description.
- Testing an AI feature idea with real examples before building it.
- Where a prototype stops and engineering starts.
- Exercise: prototype a feature and test it on colleagues.
Quarter day · Intermediate
Metrics, evaluation and cost for AI features
- Quality metrics a product manager can own.
- Golden test sets written with the people who know the domain.
- Cost per use, margins and pricing AI features.
- Launch criteria and monitoring after release.
AI
AI engineering
Build, test, secure and operate applications on language models.
- OpenAI
Quarter day · Intermediate
Working with LLM APIs
- API keys and authentication.
- Sending and receiving requests, structured JSON and streaming.
- Managing context and conversation state.
- Cost and token management.
- Enough Python to understand and change the examples. All code is supplied, with starting points and worked solutions.
In AI Engineering for Software Developers, Building Applications with Generative AI, From Chatbot to Agent
Add to a course +Quarter day · Intermediate
Choosing the right LLM and provider
- OpenAI, Anthropic, Gemini, open-weight models and small language models.
- Choosing on capability, cost, latency, security and use case.
- Enterprise plans vs direct API access.
- Self-hosted and local models as an option for confidential data.
Quarter day · Intermediate
Architecture of an LLM application
- Where the model sits: service boundaries, gateways and the rest of the stack.
- Synchronous, streaming and background patterns.
- Model access through providers, cloud platforms or self-hosting.
- Failure handling: timeouts, retries, fallbacks and degraded modes.
In Building Applications with Generative AI
Add to a course +Quarter day · Intermediate
Prompts and schemas as tested interfaces
- Prompts as code: instructions, examples, constraints and versioning.
- Structured outputs and JSON Schema: a request, not a guarantee.
- Separating trusted instructions from untrusted input.
- Lab: write a prompt with tests, then break it with realistic inputs.
In AI Engineering for Software Developers, Building Applications with Generative AI
Add to a course +Quarter day · Intermediate
Context engineering and memory
- What goes into context, what is retrieved and what is left out.
- Long conversations: truncation, summaries and their failure modes.
- Short-term and long-term memory, and when to forget.
- Prompt caching and its effect on cost and latency.
In AI Engineering for Software Developers, Building Applications with Generative AI, Building AI Agents
Add to a course +Quarter day · Intermediate
Security and commercial deployment
- Protecting proprietary and customer data.
- Data retention and privacy.
- Authentication, permissions and access control.
- Customer-facing versus internal AI.
- Guardrails and human decision boundaries.
In Building Applications with Generative AI, Building Enterprise AI Assistants
Add to a course +Quarter day · Advanced
The LLM threat model
- Why a model is neither a trusted component nor a simple input.
- Assets, trust boundaries and attackers for an LLM-backed system.
- The OWASP Top 10 for LLM applications.
- Exercise: threat-model a real feature.
In Securing Generative AI Applications
Add to a course +Quarter day · Advanced
Prompt injection and poisoned context
- Direct and indirect prompt injection.
- Poisoned documents, retrieval and tool results.
- Mitigations that help, and the ones that only look as if they do.
- Lab: attack a RAG assistant, then defend it.
In AI Engineering for Software Developers, Securing Generative AI Applications
Add to a course +Quarter day · Advanced
Tools, excessive agency and unsafe output
- Least privilege for tools, and confirmation before side effects.
- Data exfiltration through links, images and tool calls.
- Treating model output as untrusted: rendering, code and SQL.
- Lab: close the exfiltration paths in an agent.
In Securing Generative AI Applications
Add to a course +Quarter day · Advanced
Securing the AI platform and supply chain
- Secrets, keys and gateways between applications and providers.
- Model and package supply chain, including open-weight models.
- Logging, retention and audit without leaking what you protect.
- Red-teaming and incident response for AI features.
In Securing Generative AI Applications
Add to a course +Quarter day · Intermediate
Evaluation and production
- How to test objectively whether an AI solution works, using golden test sets and LLM-assisted scoring.
- Measuring accuracy and reliability.
- Logging, observability and human-in-the-loop.
- Cost and performance monitoring.
- Knowing when something is safe enough for production or customer use.
In Building Applications with Generative AI, Building Enterprise AI Assistants
Add to a course +Quarter day · Intermediate
What “correct” means for an LLM system
- Non-determinism, and why one good answer proves little.
- Turning product requirements into criteria you can score.
- Exact checks, semantic checks and human judgement.
- Exercise: write the acceptance criteria for a real feature.
In Evaluating and Testing LLM Applications
Add to a course +Quarter day · Intermediate
Golden datasets and evaluators
- Building a golden set from real traffic and expert input.
- Code-based evaluators and LLM-as-judge.
- Calibrating a judge against human labels.
- Lab: build a golden set and score two prompt versions.
In AI Engineering for Software Developers, Evaluating and Testing LLM Applications
Add to a course +Quarter day · Advanced
Evaluating agents and multi-step systems
- Scoring the outcome against scoring the path taken.
- Tool-call accuracy, step counts and recovery from errors.
- Simulated users and environments.
- Lab: evaluate an agent on a task set and find its weakest step.
In Evaluating and Testing LLM Applications, Building AI Agents, Agentic RAG Systems
Add to a course +Quarter day · Intermediate
Evaluation in CI and in production
- Regression suites that run when a prompt or model changes.
- Online evaluation, sampling and user feedback.
- Drift, alerts and the dashboard someone actually reads.
- Lab: wire evaluations into a pipeline.
In Evaluating and Testing LLM Applications
Add to a course +Quarter day · Intermediate
Observability for LLM systems
- Traces for prompts, retrieval, tool calls and responses.
- Prompt and model versions, token counts and latency.
- OpenTelemetry and LLM tracing tools.
- Lab: trace a request end to end and find the slow step.
In AI Engineering for Software Developers
Add to a course +Quarter day · Intermediate
Cost, latency and caching
- Where the tokens go, and how to measure cost per task.
- Model routing: small models first, large models when needed.
- Prompt caching, response caching and batch APIs.
- Streaming and perceived latency.
In AI Engineering for Software Developers, Production AI Architecture
Add to a course +Quarter day · Intermediate
Synthetic data for testing and training
- Generating test questions, conversations and edge cases with an LLM.
- Seeding generation from real data so it stays realistic.
- Checking diversity, duplication and leakage into your test sets.
- Lab: build a synthetic evaluation set and check it against real traffic.
Quarter day · Intermediate
Human evaluation and annotation
- When people must judge, and which judgements to ask for.
- Labelling guides that two people apply the same way.
- Agreement between raters, and resolving disagreements.
- Exercise: write a guide, label a sample and measure agreement.
Quarter day · Advanced
Red-teaming and safety evaluation
- Planning a red-team exercise: scope, threats and rules.
- Jailbreaks, harmful content, data leakage and misuse of tools.
- Automated attack generation and safety benchmarks.
- Lab: red-team an assistant and write up the findings.
Quarter day · Intermediate
Lab: eval-driven development
- Write the evaluation before changing the system.
- Improve prompts, retrieval or models one change at a time.
- Keep a record of what moved the score and what did not.
- Finish with a regression suite the team keeps running.
Quarter day · Intermediate
Document understanding: PDFs, tables and forms
- Layout-aware parsing, OCR and vision models for documents.
- Tables, forms and handwriting.
- Extracting fields into a schema, with confidence and review.
- Lab: turn a pile of scanned forms into validated records.
Quarter day · Intermediate
Working with vision models
- What multimodal models can see, and how reliably.
- Images, screenshots, charts and diagrams as input.
- Inspection, classification and description tasks.
- Lab: build and evaluate an image-checking step.
Quarter day · Advanced
Voice agents
- Speech-to-text, text-to-speech and speech-to-speech models.
- Latency, interruptions and turn-taking.
- Telephony, and handing over to a person.
- Lab: build a voice agent for a simple phone task.
AI
RAG and agents
Retrieval you can measure and agents you can bound.
- OpenAI
Quarter day · Intermediate
RAG and proprietary knowledge
- Using your specifications, documentation and knowledge bases with an LLM.
- Embeddings, vector databases and hybrid search.
- Turning documentation into FAQs to improve retrieval.
- Citations and source grounding.
- Updating knowledge without retraining a model, and reducing hallucination.
In Building Applications with Generative AI, Building Enterprise AI Assistants, From Chatbot to Agent
Add to a course +Quarter day · Intermediate
RAG as an architecture
- The stages: ingest, index, retrieve, assemble, generate and cite.
- Where RAG fits, and where fine-tuning or plain search fits better.
- The failure modes of each stage.
- Choosing a vector store and a framework, or neither.
In RAG: From Fundamentals to Production, Agentic RAG Systems, Production AI Architecture
Add to a course +Quarter day · Intermediate
Ingestion and chunking
- Parsing PDFs, HTML, Office documents and tables.
- Chunking strategies, overlap and structure-aware splitting.
- Metadata worth keeping for filtering and citations.
- Lab: ingest a corpus and inspect the worst chunks.
In RAG: From Fundamentals to Production, RAG in a Day
Add to a course +Quarter day · Intermediate
Embeddings and vector search
- Embedding models: choosing, comparing and versioning.
- Vector indexes, similarity and approximate search.
- Filters and namespaces.
- Lab: index a corpus and run a question set against it.
In AI Engineering for Software Developers, RAG: From Fundamentals to Production, RAG in a Day
Add to a course +Quarter day · Advanced
Hybrid search and reranking
- Keyword search and where vectors lose to it.
- Hybrid retrieval and score fusion.
- Rerankers, query rewriting and generated FAQs.
- Lab: improve recall on the questions vector search misses.
In RAG: From Fundamentals to Production, Agentic RAG Systems
Add to a course +Quarter day · Intermediate
Measuring retrieval
- A question set with known good sources.
- Recall, precision and ranking metrics.
- Faithfulness and answer relevance.
- Lab: compare two retrieval configurations with numbers, not impressions.
In AI Engineering for Software Developers, RAG: From Fundamentals to Production, RAG in a Day
Add to a course +Quarter day · Intermediate
Grounded answers and citations
- Assembling a grounded prompt from retrieved chunks.
- Citations a reader can follow back to the source.
- Refusing when retrieval is empty or sources conflict.
- Lab: complete the RAG path and test it on held-out questions.
In AI Engineering for Software Developers, RAG: From Fundamentals to Production, RAG in a Day
Add to a course +Quarter day · Advanced
Retrieval with permissions
- Document-level access control carried into the index.
- Tenant isolation and per-user filtering.
- Keeping permissions in sync with the source systems.
- Testing that one user cannot see another’s documents.
In RAG: From Fundamentals to Production, Building Enterprise AI Assistants
Add to a course +Quarter day · Advanced
Running RAG in production
- Keeping the index fresh: incremental updates and deletions.
- Re-embedding and migrating without downtime.
- Monitoring retrieval quality and answer quality.
- Cost and latency at scale.
In RAG: From Fundamentals to Production, Agentic RAG Systems
Add to a course +Quarter day · Advanced
Agentic retrieval
- Where single-shot RAG stops working.
- Query planning, decomposition and iterative retrieval.
- Knowing when to stop searching.
- Lab: turn a fixed RAG pipeline into a retrieval agent.
Quarter day · Advanced
Retrieval over mixed sources
- Documents, databases and APIs behind one question.
- Text-to-SQL, and the guardrails it needs.
- Routing questions to the right source.
- Combining results into one grounded answer.
Quarter day · Advanced
Knowledge graphs and structured retrieval
- When relationships matter more than similarity.
- Extracting entities and relations with an LLM.
- GraphRAG and its costs.
- Lab: answer multi-hop questions over a small graph.
Quarter day · Intermediate
Agents and tool calling
- What an agent actually is, and when we need one.
- Function and tool calling.
- Letting an LLM work with your existing APIs and software.
- ReAct and Reflection concepts where useful.
- "Agentic first turns": the assistant opens the conversation with relevant context.
- When a conventional workflow is better than an autonomous agent.
In Building Applications with Generative AI, From Chatbot to Agent
Add to a course +Quarter day · Intermediate
Workflows versus agents
- The spectrum from a single call to an autonomous agent.
- Chaining, routing, parallel calls and evaluator loops.
- Choosing the least autonomy that does the job.
- Exercise: redesign an over-agentic system as a workflow.
In Building AI Agents, Production AI Architecture
Add to a course +Quarter day · Intermediate
Designing tools for models
- Tool names, descriptions and schemas a model uses correctly.
- Validating arguments before any side effect.
- Errors the model can recover from.
- Lab: wrap an existing API as a set of tools.
In AI Engineering for Software Developers, Building AI Agents, Agentic RAG Systems, Building Enterprise AI Assistants, Build an AI Agent in a Day
Add to a course +Quarter day · Intermediate
Agent loops, planning and state
- The agent loop, step by step.
- Planning, ReAct and reflection.
- State, memory and stopping conditions.
- Lab: build a loop without a framework, then compare one.
In AI Engineering for Software Developers, Building AI Agents, Build an AI Agent in a Day
Add to a course +Quarter day · Advanced
Agent failures, permissions and human approval
- How agents fail: loops, drift and confident wrong actions.
- Permission boundaries and scoped credentials.
- Human approval at the decisions that matter.
- Lab: add approvals and limits to a working agent.
In Building AI Agents, Build an AI Agent in a Day, From Chatbot to Agent
Add to a course +Quarter day · Advanced
Orchestration and multi-agent systems
- Orchestrator and worker patterns.
- Hand-offs, shared state and context isolation.
- Frameworks compared, and the cost of adopting one.
- When several agents are worse than one.
Quarter day · Intermediate
Agent memory
- Short-term, long-term and episodic memory, and what each is for.
- Writing memories: what to keep, summarise or discard.
- Recalling the right memory at the right time.
- Privacy, consent and letting users see and delete what is remembered.
Quarter day · Intermediate
Structured facts from conversations and documents
- Extracting entities, facts and relationships into a store.
- Facts versus chunks: when structure beats retrieval.
- Keeping facts current, and resolving contradictions.
- Lab: build a fact store an agent can query.
Quarter day · Intermediate
Lab: an agent that remembers
- Add memory to a working agent.
- Recall across sessions and across topics.
- Test what it remembers, forgets and gets wrong.
- Measure whether memory actually improves the answers.
Quarter day · Intermediate
Vector databases compared
- pgvector, OpenSearch, Qdrant, Pinecone, S3 Vectors and others.
- Index types: HNSW, IVF and flat, and their trade-offs.
- Quantisation, filtering and hybrid search support.
- Cost, operations and choosing one for your workload.
Quarter day · Advanced
Running a vector database at scale
- Sharding, replicas and capacity planning.
- Multi-tenancy and per-customer isolation.
- Re-indexing, re-embedding and migrations without downtime.
- Backups, monitoring and recall drift.
Quarter day · Intermediate
Agent frameworks and SDKs compared
- Claude Agent SDK, OpenAI Agents SDK, LangGraph and others.
- What a framework gives you, and what it hides.
- Portability, observability and testing in each.
- Exercise: build the same small agent in two frameworks.
Quarter day · Advanced
Browser and computer-use agents
- Agents that operate a browser or a desktop.
- Where they beat an API, and where they are fragile.
- Sandboxing, permissions and approvals.
- Lab: automate a web task and make it fail safely.
AI
AI architecture
Integration, platforms, assistants, security boundaries and operations.
- Microsoft Teams
- Slack
Quarter day · Intermediate
MCP and integration architecture
- What MCP gives us in practical terms.
- Exposing existing company functionality and tools to an LLM. Example: finding the best-fit test script from a library using set criteria.
- How this could sit alongside your existing APIs and products.
- Lab: build a small MCP server over an existing API.
In Building Enterprise AI Assistants
Add to a course +Quarter day · Advanced
Reference architectures for AI systems
- Assistant, RAG, agent, batch and embedded-feature patterns.
- Components and boundaries in each.
- Choosing between them for a given problem.
- Exercise: map an existing system onto a reference architecture.
Quarter day · Advanced
Event-driven and batch AI workloads
- Queues, events and background agents.
- Batch processing of documents and records.
- Idempotency, retries and dead letters with a non-deterministic step.
- Exercise: design a document-processing pipeline.
Quarter day · Advanced
The AI gateway and control plane
- One point of access to every model provider.
- Keys, quotas, routing and fallbacks.
- Logging, redaction and policy at the gateway.
- Build or buy: open-source and managed gateways.
In Production AI Architecture, Architecting Enterprise Generative AI, AI Platform Engineering
Add to a course +Quarter day · Advanced
Identity, security and governance for AI
- Acting on behalf of a user: identity through to tools and data.
- Data classification and what may reach which model.
- Audit, retention and regulatory obligations.
- Governance that teams can follow without a committee.
In Production AI Architecture, Architecting Enterprise Generative AI
Add to a course +Quarter day · Advanced
Releasing and operating AI systems
- Versioning prompts, models and indexes together.
- Canary releases, shadow traffic and rollback.
- SLOs for quality as well as uptime.
- Model deprecations and provider incidents.
In Production AI Architecture, Architecting Enterprise Generative AI
Add to a course +Quarter day · Advanced
Enterprise assistant architecture
- Conversation, knowledge, tools and policy as separate parts.
- Single assistant or several specialised ones.
- Identity and permissions carried through every call.
- Exercise: design an assistant for one department.
In Building Enterprise AI Assistants
Add to a course +Quarter day · Intermediate
Assistants in Teams, Slack and the browser
- Meeting people where they already work.
- Bots, extensions and embedded assistants.
- Feedback capture and hand-off to a person.
- Adoption: what makes people come back.
In Building Enterprise AI Assistants
Add to a course +Quarter day · Advanced
From projects to an AI platform
- The shared services every AI project rebuilds.
- Platform scope: what to centralise and what to leave to teams.
- Funding, ownership and a roadmap.
- Exercise: list what your current projects duplicate.
In Architecting Enterprise Generative AI
Add to a course +Quarter day · Advanced
Vendors, contracts and lock-in
- Frontier providers, cloud platforms and open-weight models.
- Data terms, residency and retention in contracts.
- Portability: abstractions that help and ones that only add cost.
- A multi-provider strategy that stays manageable.
In Architecting Enterprise Generative AI
Add to a course +Quarter day · Advanced
Enablement and the AI operating model
- Centre of excellence, platform team or federated model.
- Templates, guidance and reviews that speed teams up.
- Skills and training across roles.
- Measuring adoption and value.
In Architecting Enterprise Generative AI
Add to a course +Quarter day · Advanced
Workshop: a target architecture
- Current state: systems, data and AI projects already running.
- Target state: platform services, boundaries and owners.
- Gaps, risks and sequencing.
- Output: a target architecture diagram and a first-year plan.
In Architecting Enterprise Generative AI
Add to a course +Quarter day · Advanced
Building MCP servers in depth
- Tools, resources and prompts, and when to use each.
- Local and remote transports.
- Authentication with OAuth, and acting on behalf of a user.
- Lab: build and deploy a remote MCP server with sign-in.
Quarter day · Advanced
MCP security
- Tool poisoning, rug pulls and malicious servers.
- Scoping permissions and approving tool calls.
- Vetting third-party servers and keeping an allow-list.
- Logging and audit for MCP traffic.
AI
Models and ML
How models work, how they are adapted, and how to run them.
- OpenAI
- AWS
Quarter day · Intermediate
LLMs for data work
- Extraction, classification and labelling at scale with structured outputs.
- Batch APIs, cost and throughput for large datasets.
- Checking LLM labels against a human-labelled sample.
- Lab: classify and extract from a real dataset in a notebook.
Quarter day · Intermediate
LLMs versus classical machine learning
- When a trained model beats a prompted one, and when it does not.
- Embeddings as features for classical models.
- Using an LLM to bootstrap labels, then training something cheaper.
- Exercise: choose an approach for three of your own problems.
Quarter day · Advanced
Tokenisation and embeddings from scratch
- Byte-pair encoding, implemented.
- Embedding tables and positional information.
- What the representation makes easy and hard.
- Lab: build and train a tokeniser.
In Transformers from First Principles, Training Your Own Language Model
Add to a course +Quarter day · Advanced
Self-attention from scratch
- Queries, keys and values as matrix operations.
- Scaled dot-product attention and causal masking.
- Multi-head attention.
- Lab: implement attention in PyTorch and check it by hand.
In Transformers from First Principles, Training Your Own Language Model
Add to a course +Quarter day · Advanced
The transformer block
- Residual connections, normalisation and feed-forward layers.
- Stacking blocks into a decoder-only model.
- Modern variants: RoPE, grouped-query attention and mixture of experts.
- Lab: assemble a small GPT.
In Transformers from First Principles, Training Your Own Language Model
Add to a course +Quarter day · Advanced
The pretraining objective and training loop
- Cross-entropy on the next token.
- Optimisers, learning-rate schedules and batching.
- Watching loss curves and catching problems early.
- Lab: train the small GPT on a real corpus.
In Transformers from First Principles, Training Your Own Language Model
Add to a course +Quarter day · Advanced
Scale, compute and scaling laws
- Parameters, data and compute, and how they trade off.
- Scaling laws and what they predict.
- Why frontier training is a different engineering problem.
- Small models that punch above their size.
In Transformers from First Principles, Training Your Own Language Model
Add to a course +Quarter day · Advanced
Inference, the KV cache and decoding
- The KV cache and why generation is memory-bound.
- Greedy, sampling and speculative decoding.
- Batching and throughput on a GPU.
- Lab: add a KV cache and measure the speed-up.
In Transformers from First Principles, Training Your Own Language Model
Add to a course +Quarter day · Advanced
Lab: a small language model, end to end
- Put the pieces together: tokeniser, model, training and sampling.
- Train on a domain corpus.
- Compare outputs at different stages of training.
- Write up what the model learned, and what it did not.
In Transformers from First Principles, Training Your Own Language Model
Add to a course +Quarter day · Advanced
Building a training corpus
- Sources, licences and provenance.
- Cleaning, deduplication and quality filtering.
- Mixtures and domain weighting.
- Lab: build and profile a small corpus.
In Training Your Own Language Model
Add to a course +Quarter day · Advanced
Training at scale
- Mixed precision and memory budgets.
- Data, tensor and pipeline parallelism.
- Checkpointing and restarts.
- Estimating cost and time before you start.
In Training Your Own Language Model
Add to a course +Quarter day · Advanced
Diagnosing a training run
- Loss spikes, divergence and dead runs.
- Gradient norms, learning rates and other signals.
- Ablations that answer one question at a time.
- Lab: find the fault in a broken run.
In Training Your Own Language Model
Add to a course +Quarter day · Advanced
Evaluating a base model
- Perplexity and its limits.
- Benchmarks, contamination and what they really measure.
- Task-specific evaluation for your own domain.
- Lab: evaluate checkpoints and pick one.
In Transformers from First Principles, Training Your Own Language Model
Add to a course +Quarter day · Advanced
Whether to fine-tune
- What fine-tuning changes, and what it cannot fix.
- Prompting, retrieval and fine-tuning compared on real problems.
- Cost, data and maintenance.
- Exercise: decide for three candidate use cases.
In Fine-Tuning Language Models, Training Your Own Language Model
Add to a course +Quarter day · Advanced
Data for fine-tuning
- Instruction, chat and preference formats.
- How much data, and of what quality.
- Synthetic data and its traps.
- Lab: build and check a fine-tuning dataset.
In Fine-Tuning Language Models
Add to a course +Quarter day · Advanced
LoRA and parameter-efficient fine-tuning
- Full fine-tuning against LoRA and QLoRA.
- Ranks, targets and hyperparameters that matter.
- Hardware and managed fine-tuning services.
- Lab: fine-tune a small open model with LoRA.
In Fine-Tuning Language Models
Add to a course +Quarter day · Advanced
Preference tuning: DPO and RLHF
- Reward models and RLHF in outline.
- DPO and related methods.
- Collecting preference data.
- Lab: apply DPO to the fine-tuned model.
In Fine-Tuning Language Models
Add to a course +Quarter day · Advanced
Evaluating a fine-tuned model
- Held-out sets and the base model as a baseline.
- Regression on general ability and safety.
- Overfitting and catastrophic forgetting.
- Lab: decide whether the fine-tune earned its place.
In Fine-Tuning Language Models
Add to a course +Quarter day · Advanced
Distillation and small language models
- Distilling a large model’s behaviour into a small one.
- Small language models for narrow, high-volume tasks.
- Running them on CPUs and edge devices.
- Lab: distil a classification task into a small model.
In Fine-Tuning Language Models
Add to a course +Quarter day · Advanced
Serving and maintaining a fine-tuned model
- Merging adapters and serving many adapters at once.
- Managed hosting against your own GPUs.
- Retraining when the base model or data changes.
- Monitoring quality after release.
In Fine-Tuning Language Models
Add to a course +Quarter day · Intermediate
Open models, formats and hardware
- The open-weight model landscape and licences.
- Quantisation and formats: GGUF, AWQ and others.
- Sizing hardware: memory, GPUs and Apple silicon.
- Lab: run the same model at different quantisation levels.
Quarter day · Intermediate
Serving local models
- Ollama and llama.cpp on a laptop or workstation.
- vLLM and other servers for shared use.
- OpenAI-compatible APIs, so applications do not change.
- Lab: serve a model and call it from an application.
Quarter day · Intermediate
Local models for confidential data
- When data cannot leave your network.
- Private RAG on local models.
- Where local models fall short, and hybrid patterns.
- Security for a self-hosted model service.
In Fine-Tuning Language Models, Running LLMs Locally
Add to a course +Quarter day · Intermediate
Benchmarking and deploying local models
- Measuring quality on your own tasks.
- Throughput, latency and cost per request.
- Packaging and deployment on servers or Kubernetes.
- Lab: benchmark two models and recommend one.
Quarter day · Intermediate
Fine-tuning hosted models
- Fine-tuning services from OpenAI, Amazon Bedrock and Google Vertex AI.
- Preparing and uploading data in the formats they expect.
- Cost, limits and what you can and cannot take away.
- Lab: fine-tune a hosted model and compare it with prompting.
Quarter day · Advanced
Fine-tuning embedding models and rerankers
- Why general embeddings miss your domain’s meaning.
- Training pairs from your own documents and queries.
- Contrastive training and hard negatives.
- Lab: fine-tune an embedding model and measure retrieval gains.
Quarter day · Advanced
Reinforcement fine-tuning
- Reinforcement learning with verifiable rewards.
- Writing graders and reward functions.
- Reward hacking and how to spot it.
- Lab: improve a model on a task with a checkable answer.
AI
NLP and the maths behind models
Classical NLP through transformers in Python, and the linear algebra, probability and statistics underneath.
Quarter day · Foundation
NLP: Python for text and preprocessing
- Strings, Unicode, regular expressions and reading text at scale.
- Tokenisation, normalisation, stemming and lemmatisation.
- Stop words, and when removing them hurts.
- Lab: clean and tokenise a real corpus.
Quarter day · Foundation
NLP: features, bag of words and TF-IDF
- Bag of words, n-grams and vocabularies.
- TF-IDF and what it rewards.
- Sparse matrices and similarity between documents.
- Lab: find similar documents with TF-IDF.
Quarter day · Intermediate
NLP: text classification
- Naive Bayes, logistic regression and linear SVMs on text.
- Imbalanced classes, precision, recall and thresholds.
- Error analysis: reading the mistakes.
- Lab: build and evaluate a classifier for a real labelling task.
Quarter day · Intermediate
NLP: topic modelling
- LDA and NMF.
- Embedding-based topics with BERTopic.
- Choosing the number of topics and judging coherence.
- Lab: find the themes in a set of customer comments.
Quarter day · Intermediate
NLP: word and sentence embeddings
- Word2vec and GloVe: meaning from context.
- Analogies, bias and the limits of static vectors.
- Sentence embeddings and semantic search.
- Lab: compare TF-IDF and embeddings on the same search task.
Quarter day · Intermediate
NLP: linguistic structure with spaCy
- Part-of-speech tagging and dependency parsing.
- Named entity recognition, and training a custom entity.
- Rule-based matching alongside models.
- Lab: extract structured records from free text.
Quarter day · Intermediate
NLP: transformers with Hugging Face
- Pretrained encoders and the Hugging Face ecosystem.
- Fine-tuning a small transformer for classification or NER.
- When a small fine-tuned model beats an LLM, on cost and accuracy.
- Lab: fine-tune and compare against the classical baseline.
Quarter day · Intermediate
NLP: capstone pipeline
- Put the pieces together: clean, extract, classify and search.
- Choosing classical, transformer or LLM for each step.
- Packaging the pipeline and evaluating it end to end.
- Present the pipeline and its numbers to the group.
Quarter day · Intermediate
Maths: linear algebra for embeddings and attention
- Vectors, dot products, norms and cosine similarity.
- Matrices as transformations; matrix multiplication by hand and in NumPy.
- Projections and dimensionality reduction: PCA and what it keeps.
- Attention written as matrix operations.
Quarter day · Intermediate
Maths: probability and information theory
- Distributions, conditional probability and Bayes’ rule.
- Softmax, temperature and sampling.
- Entropy, cross-entropy, KL divergence and perplexity.
- Exercise: compute a model’s loss on a sentence by hand.
Quarter day · Intermediate
Maths: gradients and optimisation
- Derivatives, the chain rule and backpropagation.
- Gradient descent, momentum and Adam.
- Learning rates, overfitting and regularisation.
- Lab: train a tiny model with gradients you wrote yourself.
Quarter day · Intermediate
Statistics for evaluating AI systems
- Sampling error and how big a test set needs to be.
- Confidence intervals and bootstrapping for accuracy and judge scores.
- Paired comparisons: is version B really better than version A?
- Exercise: decide whether a reported improvement is real.
AI
AI on the cloud
AWS, Azure and the internal platform around them.
- AWS
- Azure
- OpenAI
Quarter day · Intermediate
AI services on AWS
- Bedrock, SageMaker and the managed AI services, and when each fits.
- Accounts, regions and model availability.
- Reference architecture for an AI application on AWS.
- Cost model and quotas.
Quarter day · Intermediate
Amazon Bedrock in practice
- The Converse API, streaming and tool use.
- Model access, inference profiles and prompt caching.
- Bedrock Guardrails.
- Lab: call several models through one interface.
Quarter day · Intermediate
RAG on AWS
- Bedrock Knowledge Bases: what they do and what they hide.
- OpenSearch, Aurora pgvector and S3 Vectors.
- Ingestion from S3 and other sources.
- Lab: build a knowledge base and query it with citations.
Quarter day · Advanced
Agents on AWS
- Bedrock Agents and AgentCore.
- Tools as Lambda functions and APIs.
- Memory, identity and observability in AgentCore.
- Lab: deploy an agent with two tools.
Quarter day · Intermediate
Serverless AI applications on AWS
- Lambda, API Gateway and streaming responses.
- Step Functions for multi-step AI workflows.
- EventBridge and SQS for background work.
- Lab: deploy an AI API with infrastructure as code.
Quarter day · Advanced
Securing AI workloads on AWS
- IAM for model access and tools.
- VPC endpoints, KMS and private networking.
- Logging model invocations without leaking data.
- Data residency and service availability by region.
Quarter day · Advanced
Operating AI on AWS
- CloudWatch metrics, logs and traces for AI calls.
- Quotas, throttling and provisioned throughput.
- Cost allocation and budgets.
- Evaluation jobs in Bedrock.
Quarter day · Advanced
Lab: an AI application on AWS, end to end
- Put the pieces together: API, model, knowledge base and agent.
- Deploy with CDK or Terraform.
- Add guardrails, logging and an evaluation run.
- Review the design against the Well-Architected generative AI lens.
Quarter day · Intermediate
AI services on Azure
- Azure AI Foundry, Azure OpenAI and the wider AI services.
- Subscriptions, regions, deployments and quotas.
- Reference architecture for an AI application on Azure.
- Cost model: pay-as-you-go and provisioned throughput.
Quarter day · Intermediate
Azure OpenAI in practice
- Deployments, model versions and API versions.
- Chat, structured outputs and tool calling.
- The Foundry model catalogue beyond OpenAI.
- Lab: call and compare deployed models.
Quarter day · Intermediate
RAG on Azure
- Azure AI Search: indexes, vectors and semantic ranking.
- Indexers, skillsets and document parsing.
- Security trimming for per-user results.
- Lab: build an index and a grounded chat over it.
Quarter day · Advanced
Agents on Azure
- Foundry Agent Service.
- Tools, connections and Logic Apps.
- Semantic Kernel and other frameworks.
- Lab: deploy an agent with tools.
Quarter day · Intermediate
AI APIs on Azure
- API Management as an AI gateway.
- Functions and Container Apps for AI services.
- Token limits, load balancing and semantic caching.
- Lab: put a gateway in front of two deployments.
Quarter day · Advanced
Identity, networking and content safety on Azure
- Entra ID and managed identities instead of keys.
- Private endpoints and network isolation.
- Azure AI Content Safety and prompt shields.
- Data residency and abuse monitoring settings.
Quarter day · Advanced
Operating AI on Azure
- Monitoring and tracing in Foundry and Application Insights.
- Evaluations in Foundry.
- Quotas, throttling and capacity planning.
- Cost management and chargeback.
Quarter day · Advanced
Lab: an AI application on Azure, end to end
- Put the pieces together: API, model, search index and agent.
- Deploy with Bicep or Terraform.
- Add content safety, tracing and an evaluation run.
- Review the design against the Azure Well-Architected guidance.
Quarter day · Advanced
Model catalogue and access policy
- An approved model catalogue, and how models get onto it.
- Access by team, data class and environment.
- Deprecations and migrations across many consumers.
- Exercise: write the access policy for your organisation.
Quarter day · Advanced
Retrieval as a platform service
- Shared ingestion, indexes and connectors.
- Permissions enforced by the platform, not each app.
- Self-service for teams with guardrails.
- Running cost and who pays it.
Quarter day · Advanced
Policy, data controls and audit
- Redaction, classification and policy enforcement.
- Central logging and retention.
- Evidence for auditors and regulators.
- Policy as code.
Quarter day · Advanced
Evaluation as a platform service
- Shared evaluation tooling and datasets.
- Release gates teams can use without ceremony.
- Comparing models for many teams at once.
- Production monitoring as a service.
Quarter day · Advanced
Developer experience for AI platforms
- Templates, SDKs and golden paths.
- Local development against platform services.
- Documentation and support that scale.
- Measuring time to a first production feature.
Quarter day · Advanced
Cost allocation and FinOps for AI
- Tagging and attributing every model call.
- Budgets, alerts and showback.
- Commitments, provisioned capacity and discounts.
- Cost per outcome, not cost per token.
In Architecting Enterprise Generative AI, AI Platform Engineering
Add to a course +Quarter day · Advanced
Running the AI platform
- SLOs for the platform and for its providers.
- Incidents: provider outages, bad releases and abuse.
- Capacity, quotas and fairness between teams.
- A platform roadmap driven by its users.
AI
Labs and working sessions
Hands-on builds and facilitated sessions on a problem your team actually has.
Quarter day · Intermediate
Practical exercise: a grounded assistant
- A scenario resembling your business.
- Take technical documentation and specifications.
- Build a grounded assistant around them.
- Ask technical questions and get answers with sources.
Quarter day · Intermediate
Practical exercise: tools, evaluation and a demo
- Give the assistant access to an example API or tool.
- Evaluate whether its responses are reliable.
- Connect it to a simple front end.
- Demonstrate it to the group.
Quarter day · Intermediate
Lab: build a working agent
- A task from your own work, chosen at the start.
- Tools, a loop and a stopping condition.
- Limits, approvals and a small evaluation set.
- Demonstrate it, then list what production would still need.
In Building AI Agents, Build an AI Agent in a Day
Add to a course +Quarter day · Advanced
Workshop: frame the problem
- The problem, the users and what success looks like.
- Data, systems and constraints.
- Risks and non-negotiables.
- Output: a one-page problem statement.
Quarter day · Advanced
Workshop: suitability and options
- Is AI the right tool here?
- Options: LLM, RAG, agent, conventional software or a mix.
- Trade-offs on cost, risk, effort and value.
- Output: a short list of options with reasons.
Quarter day · Advanced
Workshop: sketch the architecture
- Components, data flows and boundaries for the chosen option.
- Security, evaluation and operations designed in.
- Build, buy or partner for each part.
- Output: an architecture sketch the team can review.
Quarter day · Advanced
Workshop: recommendation and roadmap
- The recommendation and the evidence for it.
- A first increment small enough to learn from.
- Owners, milestones and decision points.
- Output: a recommendation the team can take to sponsors.
Quarter day · Foundation
Discovery: map the work
- Walk through the work of each team.
- Find repetitive, document-heavy and judgement-heavy tasks.
- Capture volumes, pain and data available.
- Output: a long list of candidates.
In AI Use-Case Discovery Workshop
Add to a course +Quarter day · Foundation
Discovery: score the candidates
- A scoring framework: value, feasibility, data, risk.
- Score as a group, and argue about the outliers.
- Spot dependencies and shared foundations.
- Output: a scored list.
In AI Use-Case Discovery Workshop
Add to a course +Quarter day · Foundation
Discovery: test the top candidates
- Try the top ideas with real examples and a capable assistant.
- What worked, what did not, and why.
- Rough cost and effort for each.
- Output: evidence beside each score.
In AI Use-Case Discovery Workshop
Add to a course +Quarter day · Foundation
Discovery: rank and commission
- A ranked shortlist.
- A brief for each: problem, users, measures and owner.
- What to stop or not start.
- Output: work ready to commission.
In AI Use-Case Discovery Workshop
Add to a course +
Technology
Web and TypeScript
TypeScript, React, Svelte, Angular, Node and the web platform.
Quarter day · Foundation
TypeScript: types and narrowing
- Primitive, object, array and function types.
- Inference, and when to write a type yourself.
- Unions, literal types and narrowing.
- Lab: type a small untyped module.
Quarter day · Foundation
TypeScript: interfaces, generics and strict mode
- Interfaces, type aliases and when each fits.
- Generics and the utility types you will actually use.
- Strict mode, and adopting it in an existing codebase.
- Lab: make a module pass under strict mode.
Quarter day · Advanced
Advanced TypeScript: type-level programming
- Conditional and mapped types.
- Template literal types and infer.
- Keeping advanced types readable.
- Lab: type a function whose result depends on its input.
Quarter day · Advanced
Advanced TypeScript: schemas and runtime validation
- Types that disappear at runtime, and data that does not.
- Validating at the edges with Zod or Valibot.
- Deriving types for an API from one schema.
- Lab: share one schema between server and client.
Quarter day · Foundation
Modern JavaScript: the language
- Modules, destructuring and spread.
- Closures, classes and iterators.
- Array and object methods that replace loops.
- Lab: rewrite an old script in modern style.
Quarter day · Foundation
Modern JavaScript: async and the platform
- Promises, async/await and the event loop.
- Fetch, streams and abort signals.
- APIs that browsers and Node share.
- Lab: replace callbacks with async code that handles errors.
Quarter day · Foundation
React: components, props and rendering
- JSX and components.
- Props, children and composition.
- How React renders, and when it renders again.
- Lab: build a page from small components.
Quarter day · Foundation
React: state and events
- useState, events and updates.
- Lifting state up and passing it down.
- Lists, keys and conditional rendering.
- Lab: make the page interactive.
Quarter day · Foundation
React: effects and data
- useEffect, and when not to use it.
- Fetching data and handling loading and errors.
- Custom hooks.
- Lab: load and display data from an API.
Quarter day · Foundation
React: forms and a small app
- Controlled and uncontrolled inputs.
- Validation and submission.
- Testing components with Testing Library.
- Lab: finish a small data-driven app from a design.
Quarter day · Intermediate
React application architecture
- Server and client components, routing and data loading.
- State: local, shared, server cache and URL.
- Folder structure that follows the UI.
- Lab: restructure a tangled app around data flow.
Quarter day · Intermediate
React performance
- What re-renders, and how to see it.
- Memoisation and the React Compiler.
- Suspense, transitions and streaming.
- Lab: profile a slow screen and fix it.
Quarter day · Intermediate
Svelte: components and runes
- Components, markup and scoped styles.
- Runes: $state, $derived and $effect.
- Props, events and snippets.
- Lab: build an interactive component.
Quarter day · Intermediate
Svelte: shared state and patterns
- Shared state in .svelte.ts modules.
- Context and stores.
- Transitions and animation.
- Lab: share state across a small app.
Quarter day · Intermediate
SvelteKit: routing and data loading
- File-based routing and layouts.
- Load functions on the server and in the browser.
- Form actions and progressive enhancement.
- Lab: build pages that load and save data.
Quarter day · Intermediate
SvelteKit: rendering and deployment
- Server rendering, prerendering and client-only pages.
- Hooks, errors and authentication.
- Adapters and deployment targets.
- Lab: deploy the app.
Quarter day · Intermediate
Angular: standalone components and signals
- Standalone components.
- Signals, computed and effects.
- The new control flow.
- Lab: build a component with signals.
Quarter day · Intermediate
Angular: services, DI and HTTP
- Dependency injection and the inject function.
- Services and shared state.
- HttpClient, interceptors and RxJS where it still helps.
- Lab: load data through a service.
Quarter day · Intermediate
Angular: forms and routing
- Reactive and signal-based forms.
- Routing, guards and lazy loading.
- Resolvers and route data.
- Lab: add an edit form behind a guarded route.
Quarter day · Intermediate
Angular: migrating an existing app
- From NgModules to standalone.
- From observables to signals where it makes sense.
- Schematics and incremental migration.
- Lab: migrate a module-based feature.
Quarter day · Intermediate
Node.js: HTTP APIs
- HTTP servers, routing and middleware.
- Validation, errors and consistent responses.
- Structuring a service as it grows.
- Lab: build a small REST API.
Quarter day · Intermediate
Node.js: authentication and testing
- Sessions, tokens and OAuth.
- Authorisation checks in the right place.
- Testing an API with the built-in test runner.
- Lab: secure and test the API.
Quarter day · Intermediate
Accessibility: semantics and keyboard
- Semantic HTML, landmarks and headings.
- Keyboard access and focus management.
- ARIA, and when not to use it.
- Lab: make a custom widget keyboard accessible.
Quarter day · Intermediate
Accessibility: WCAG and testing
- WCAG 2.2 in practice.
- Screen readers: a working session.
- Automated checks and their limits.
- Lab: audit and fix a real page.
Quarter day · Advanced
Web performance: loading
- Core Web Vitals and what moves them.
- Bundles, code splitting and caching.
- Images and fonts.
- Lab: cut the load time of a slow page.
Quarter day · Advanced
Web performance: runtime
- Long tasks and interaction latency.
- Layout, paint and animation.
- Memory leaks.
- Lab: profile and fix a janky interaction.
Technology
Python and data
Python, SQL, pandas, pipelines and classical machine learning.
- Excel
Quarter day · Foundation
Python: syntax and data structures
- Variables, types and control flow.
- Lists, dictionaries, sets and tuples.
- Comprehensions.
- Exercises: small problems with real data.
Quarter day · Foundation
Python: functions, modules and packages
- Functions, arguments and return values.
- Modules, imports and packages.
- Virtual environments and installing libraries.
- Lab: split a script into functions and a module.
Quarter day · Foundation
Python: files, errors and the standard library
- Reading and writing files, CSV and JSON.
- Exceptions and error handling.
- Useful standard library modules.
- Lab: process a folder of files.
Quarter day · Foundation
Python: automating a real task
- Calling web APIs with HTTP.
- Command-line scripts and arguments.
- Scheduling and logging.
- Lab: automate a task from your team.
Quarter day · Intermediate
Python for engineers: types and design
- Type hints and checking with mypy or pyright.
- Dataclasses and Protocols.
- Packaging with uv, linting and formatting with Ruff.
- Lab: turn a script into a typed, tested package.
Quarter day · Intermediate
Python for engineers: asyncio
- Coroutines, tasks and the event loop.
- Queues, timeouts and cancellation.
- Async HTTP clients and concurrency limits.
- Lab: make a slow sequential job concurrent.
Quarter day · Foundation
pandas: loading and cleaning data
- DataFrames, Series and indexes.
- Loading from CSV, Excel and databases.
- Missing values, types and reshaping.
- Lab: clean a messy real-world dataset.
Quarter day · Foundation
pandas: analysis and charts
- Grouping, joining and pivoting.
- Time series.
- Charts that answer a question.
- Lab: answer business questions from the cleaned data.
Quarter day · Foundation
SQL: querying and joining
- Selecting and filtering.
- Joins and what goes wrong with them.
- Grouping and aggregation.
- Lab: answer questions from a sample database.
Quarter day · Intermediate
SQL: window functions and query plans
- Common table expressions.
- Window functions for ranking and running totals.
- Reading a query plan and adding the right index.
- Lab: answer business questions from a warehouse.
Quarter day · Intermediate
Data pipelines: design
- Batch and streaming, and when each fits.
- Idempotency and safe re-runs.
- Backfills and late data.
- Exercise: design a pipeline for a real feed.
Quarter day · Intermediate
Data pipelines: orchestration and quality
- Orchestration with Airflow, Dagster or Prefect.
- Data quality checks and contracts.
- Alerting and lineage.
- Lab: build a small pipeline that can be re-run safely.
Quarter day · Intermediate
Machine learning: framing and metrics
- Turning a business question into a prediction problem.
- Choosing a metric that matches the cost of errors.
- Train, validation and test sets.
- Exercise: frame three candidate problems.
Quarter day · Intermediate
Machine learning: features and pipelines
- Feature engineering for tabular data.
- scikit-learn pipelines and transformers.
- Avoiding leakage.
- Lab: build a preprocessing pipeline.
Quarter day · Intermediate
Machine learning: models and validation
- Linear models, trees and gradient boosting.
- Cross-validation and hyperparameter search.
- Classification and regression compared.
- Lab: train and compare models.
Quarter day · Intermediate
Machine learning: explaining and shipping a model
- Feature importance and SHAP.
- Calibration and thresholds.
- Saving, serving and monitoring a model.
- Lab: explain the model to a business audience.
Technology
Cloud and DevOps
Containers, Kubernetes, Terraform, AWS, CI/CD and observability.
- AWS
Quarter day · Foundation
Docker: images and containers
- Images, layers and containers.
- Writing small, secure Dockerfiles.
- Multi-stage builds.
- Lab: containerise an existing service.
Quarter day · Foundation
Docker: Compose and local development
- Compose for a service and its dependencies.
- Volumes, networks and environment.
- Image scanning and registries.
- Lab: run a full stack locally with one command.
Quarter day · Intermediate
Kubernetes: pods and deployments
- The cluster, the API and kubectl.
- Pods, deployments and replica sets.
- Labels and selectors.
- Lab: deploy a service.
Quarter day · Intermediate
Kubernetes: services and ingress
- Services and DNS.
- Ingress and the Gateway API.
- Network policies.
- Lab: expose the service to users.
Quarter day · Intermediate
Kubernetes: configuration, secrets and storage
- ConfigMaps and Secrets.
- Persistent volumes and stateful sets.
- Helm and Kustomize.
- Lab: configure the service for two environments.
Quarter day · Intermediate
Kubernetes: health, scaling and rollouts
- Readiness and liveness probes.
- Resource requests, limits and autoscaling.
- Rolling updates and rollbacks.
- Lab: release a new version without downtime.
Quarter day · Intermediate
Terraform: resources, state and plans
- Providers, resources and data sources.
- State, and where to keep it.
- Plan and apply.
- Lab: describe a small stack.
Quarter day · Intermediate
Terraform: modules and safe change
- Modules and environments.
- Drift, imports and moved blocks.
- Reviewing plans in CI.
- Lab: change the stack safely.
Quarter day · Foundation
AWS: accounts, IAM and security
- Accounts, regions and the shared responsibility model.
- IAM users, roles and policies.
- Least privilege in practice.
- Lab: set up a role for an application.
Quarter day · Foundation
AWS: compute
- EC2 and when you still need it.
- Containers on ECS and Fargate.
- Lambda and serverless.
- Lab: run the same service two ways.
Quarter day · Foundation
AWS: storage, databases and networking
- S3 and its security settings.
- RDS, Aurora and DynamoDB.
- VPCs, subnets and security groups.
- Lab: connect a service to a database privately.
Quarter day · Foundation
AWS: a serverless application
- API Gateway, Lambda and DynamoDB together.
- Infrastructure as code with CDK or SAM.
- Logs, metrics and cost.
- Lab: deploy a small serverless application.
Quarter day · Intermediate
CI/CD: pipelines as code
- Pipelines with GitHub Actions or GitLab CI.
- Tests, caches and artefacts.
- Secrets and supply-chain safety in CI.
- Lab: build and test on every push.
Quarter day · Intermediate
CI/CD: environments and releases
- Environments and promotion.
- Blue/green, canary and feature flags.
- Rollback and release notes.
- Lab: take a repository from commit to deployment.
Quarter day · Intermediate
Observability: logs, metrics and traces
- What logs, metrics and traces each answer.
- OpenTelemetry instrumentation.
- Structured logging.
- Lab: instrument a service.
Quarter day · Intermediate
Observability: SLOs, alerts and debugging
- SLOs and error budgets.
- Alerts people will not ignore.
- Debugging from telemetry.
- Lab: find a planted fault from the dashboards.
Technology
Software craft
Git, testing, refactoring, security, design and AI-assisted coding.
Quarter day · Foundation
Git: commits, branches and history
- The model behind Git: commits, trees and refs.
- Branches and merging.
- Reading and searching history.
- Lab: recover from the mistakes people actually make.
Quarter day · Foundation
Git: rebasing, conflicts and pull requests
- Rebasing and when not to.
- Resolving conflicts calmly.
- Pull requests and review that helps.
- Lab: work through a conflict-heavy team exercise.
Quarter day · Intermediate
Automated testing strategy
- Unit, integration and end-to-end tests, and the balance between them.
- Tests that describe behaviour, not implementation.
- Test doubles without testing the mocks.
- Lab: test a feature at the right levels.
Quarter day · Intermediate
Testing legacy code
- Finding seams in code that was not built for tests.
- Characterisation tests.
- Breaking dependencies safely.
- Lab: put a harness around old code.
Quarter day · Intermediate
Refactoring in small steps
- Code smells and the refactorings that fix them.
- Small safe steps under test.
- IDE refactoring tools.
- Lab: refactor a real tangle in pairs.
Quarter day · Intermediate
Clean code and design
- Naming, functions and boundaries.
- Coupling, cohesion and dependencies.
- Structure that follows the domain and the UI.
- Lab: review and improve a module together.
Quarter day · Intermediate
Secure coding: the OWASP Top 10
- Injection, broken access control and the rest of the Top 10.
- How each shows up in your stack.
- Secure defaults in your frameworks.
- Lab: find and fix vulnerabilities in a sample app.
Quarter day · Intermediate
Secure coding: secrets, dependencies and threat modelling
- Secrets management.
- Dependencies and supply-chain attacks.
- Threat modelling a feature in thirty minutes.
- Lab: threat-model a feature from your backlog.
Quarter day · Advanced
System design: requirements and building blocks
- Requirements, constraints and back-of-envelope sums.
- Caching, queues and databases.
- Consistency and failure.
- Exercise: estimate load for a real system.
Quarter day · Advanced
System design: design and defend
- Writing a design document others can review.
- Trade-offs, and saying them out loud.
- Reviewing someone else’s design.
- Lab: design a service and defend it to the room.
Quarter day · Intermediate
AI-assisted software development
- AI coding tools compared: Cursor, Claude Code and others.
- Plan mode: plan, review, then implement.
- Reviewing AI-generated code properly rather than "vibe coding".
- Reusable skills for repeated tasks.
- Agentic workflows: reviewing PRs, checking build pipelines, writing test plans and plain-English change summaries, and updating Jira tickets.
Quarter day · Intermediate
Coding agents in practice
- Project instructions, context and conventions an agent follows.
- Tests and guardrails that keep agents honest.
- Running several agents in parallel without collisions.
- Lab: ship a feature with an agent, and review its work.