Course detail
Course detail
Each card is the public outline. In-house versions keep the modules and change the process under study. Fees and inclusions are at the bottom of this page.
Literacy · L1 · 14 contact hours · 4 lab hours · Evening / In-house
AI Foundations for Operating Teams
For people who already run a service, a roster, a report cycle or a customer queue and now have a language model in that work. The course builds a shared vocabulary, a five-minute check, and a first brief that a colleague could run. It is the default entry point for 2026 evening intakes.
Modules
- How language models produce text — tokens, context windows and why fluency is a weak signal of truth.
- Where they fail — invention, omission, outdated facts, and confident answers to underspecified jobs.
- Writing a usable task brief — audience, input, output, constraints, and a definition of done.
- Checking an answer in five minutes — a short method using a source the participant brought.
- Cost, latency and limits — how those constraints change the shape of a real task.
- Bringing a work task to the model — the first scored artefact of the course.
On completion you can
- Write a one-page brief for a recurring task in your role.
- Run a five-minute factual check and record the result.
- Name one failure mode that applies to that task and a way to see it.
- Place your own work on the L1 cells of the coverage matrix.
Prerequisite: a placement check. No prior programming is assumed.
Practice · L2 · 21 contact hours · 6 lab hours · Evening cohort
Prompt Systems and Output Evaluation
For people who already brief a model and need the work to survive a colleague taking over. The course turns ad hoc chat into templates with variables, a twenty-case test set, and a library with version notes. Scoring is done on the published rubric, in the room.
Modules
- Task decomposition — splitting a job so each step can be scored.
- Context and reference material — what to attach, what to summarise, what to keep out.
- Prompt templates with variables — a format another person can fill.
- Building a 20-case test set — sampling from real work, including ugly cases.
- Scoring and regression checks — rerunning the set after a change.
- Keeping a prompt library — naming, owners, and retirement of dead versions.
On completion you can
- Ship a versioned template with a test set of at least twenty cases.
- Score output on the five criteria and defend the band with evidence.
- Show that a colleague can rerun the template and land in the same band.
- Hand over a library note that names the owner and the next review date.
Prerequisite: AI Foundations, or a placement check at L2.
Practice · L2 · 18 contact hours · 5 lab hours · In-house
Working Data for AI Projects
For teams whose bottleneck is the files, not the prompt. The course is in-house because the documents are internal. Participants leave with a data-readiness note for one project: what the model can read, what was redacted, and what is still unfit.
Modules
- What a model can read — formats, structure, and the difference between stored and useful.
- Cleaning and structuring source documents — headings, tables, and duplicate versions.
- Retrieval over internal files — a small, inspectable setup on the team’s own folder.
- Sensitive fields and redaction — a pass before anything leaves the building.
- A data-readiness note for a project — the scored artefact, written for an internal owner.
On completion you can
- Classify the sources for one project and mark which may enter a model.
- Run a redaction pass and record what was removed.
- Stand up retrieval over a bounded document set and show a missed-hit and a false hit.
- Write a data-readiness note another workstream can act on.
Prerequisite: AI Foundations. Run on the employer’s process after a scoping interview.
Systems · L3 · 28 contact hours · 8 lab hours · Evening cohort
Applied Automation with Model APIs
For people who will connect a model to a sheet, a form or a queue. Practice must already be closed: you bring a scored template and a test set. The course adds calls, chains, retries, logs, and a written hand-off for internal IT.
Modules
- Calling a model API — authentication, payloads, and reading errors.
- Chaining steps with checks between them — stop conditions written down before they are coded.
- Handling errors and retries — timeouts, rate limits, and a fallback the team can run by hand.
- Connecting a sheet, a form and a queue — one narrow process, not a platform rewrite.
- Logging every run — who, when, input class, output band, and a pointer to the file.
- Hand-off to IT — a note that names owners, secrets, and what must not be changed without a test.
On completion you can
- Run a three-step chain with a check between calls on your own process.
- Show a log of runs that a colleague can read without the author present.
- Describe the fallback when the model is down, in writing.
- Deliver a hand-off note that internal IT can file.
Prerequisite: Prompt Systems and Output Evaluation.
Governance · L2 · 16 contact hours · 4 lab hours · In-house / Remote
AI Governance and Risk Practice
For people who will write the local rules and sit with the build. The course produces an acceptable-use note staff can read, a record-keeping pattern, named human review points, and a risk register filled for one use case. It does not certify the organisation against a statute.
Modules
- Acceptable-use policy that staff read — short, local, and tied to tools people actually open.
- Consent and third-party content — what may be pasted, what must be licensed, what stays out.
- Record keeping and audit trail — what to store, for how long, and who may open it.
- Human review points — where a person signs, and what they are looking at.
- Filling a risk register for one use case — the scored artefact of the course.
On completion you can
- Draft an acceptable-use note of a length staff will finish.
- Mark review points on a process map and say what evidence the reviewer sees.
- Complete a risk register for one live use case, including a fallback.
- Describe what the training does not cover, so counsel and audit are not misled.
Prerequisite: AI Foundations. Usually delivered in-house or as a live remote group for one employer.
Systems · L4 · 35 contact hours · 10 lab hours · Cohort + clinic
Capstone: Internal Assistant Build
A supervised build of a small internal assistant on a bounded document set or a narrow queue. Entry is L3. The weeks include clinics. The output is a prototype with an evaluation set, thresholds, logging, documentation and a named owner inside the organisation.
Modules
- Scoping an internal assistant — job, users, out-of-scope, and a kill criterion.
- Source selection — the files it may see, and the files it must never see.
- Build weeks with clinics — working time with scheduled review, not a demo day at the end.
- Evaluation set and thresholds — pass bands agreed before polish.
- Documentation and handover — how to run it, how to change it, who owns it next month.
On completion you can
- Show a running prototype on the agreed scope with a log of runs.
- Present an evaluation set and the bands it currently hits.
- Hand over documentation an internal owner can follow.
- Name what would be required to widen the scope, in writing.
Prerequisite: Applied Automation, or equivalent L3 evidence reviewed in placement.