Healthcare Engineering Academy

Curriculum

6 parts · 20 chapters · 105 lessons

Each lesson covers one idea in 5 to 8 minutes, followed by a short quiz. Every chapter ends with a chapter quiz. Total running time is about 11 h 05 min.

CodeLessons with a hands-on code demonstration you can run yourself.

Part I

Why Healthcare AI Needs Engineering

4 chapters · 19 lessons · about 2 h 00 min

Chapter 1The AI Engineering Imperative in Healthcare3 lessons

  1. Lesson 1.1: The Healthcare AI Paradox

    Explain why clinical AI stalls between validation and adoption, and why deterministic IT methods do not fit probabilistic systems.

  2. Lesson 1.2: The Sepsis Alert That Clinicians Turned Off

    Show that a clinical AI system is the model plus threshold, interface, workflow, recipient, escalation and monitoring, and that any one of them can sink it.

  3. Lesson 1.3: The Delivery Triad: AI Engineering, PMI and ADKAR

    Explain why technical excellence is necessary but not enough, and how project governance and change management complete delivery.

Chapter 2Welcome to AI Engineering5 lessons

  1. Lesson 2.1: What AI Engineering Actually Is

    Define AI engineering as designing, building, testing, deploying and governing AI-powered systems that solve real problems.

  2. Lesson 2.2: AI, ML, Deep Learning, LLMs, and Who Does What

    Distinguish AI, ML, deep learning, LLMs and AI engineering, and the roles around them.

  3. Lesson 2.3: The Real Job and the Demo Monster

    Explain why a demo is not a production system and what the engineer's real responsibilities are.

  4. Lesson 2.4: The Nine-Stage AI Engineering Lifecycle

    Walk the nine stages from problem definition to monitoring, and apply the Lifecycle Map.

  5. Lesson 2.5: Anatomy of an AI System: The Clinical Policy Assistant

    Name the ten components of an AI-powered system and show how each one controls risk.

Chapter 3Thinking Like an AI Engineer6 lessons

  1. Lesson 3.1: "Can It Answer?" vs "Can It Operate?"

    Distinguish an AI feature from a system that delivers, controls, evaluates and monitors it.

  2. Lesson 3.2: The Mental Model: From Input to Feedback

    Apply Input → Processing → AI Capability → Output → Human Use → Feedback to design inputs and outputs deliberately.

  3. Lesson 3.3: Beyond the Prompt: Pipelines and APIs

    Explain why prompt-level controls are not system-level controls, and how pipelines and APIs fail silently.

  4. Lesson 3.4: Workflows, Feedback Loops and Human Oversight

    Place AI inside a real workflow, design explicit and implicit feedback, and choose in-, on- or over-the-loop oversight.

  5. Lesson 3.5: Reliability and the Ten Failure Modes

    Define reliability as dependable behaviour with graceful failure, and recognise the ten common failure modes.

  6. Lesson 3.6: Error vs Harm: Matching Engineering to Risk

    Distinguish technical error from human harm, and scale controls to context.

Chapter 4The Responsible AI Mindset5 lessons

  1. Lesson 4.1: Responsible AI Is Engineering, Not PR

    Explain why responsible AI is designed in from the start and why disclaimers do not replace controls.

  2. Lesson 4.2: Accountability and Fairness

    Assign clear ownership of an AI system and test for unfair outcomes, including proxy variables.

  3. Lesson 4.3: Transparency vs Explainability

    Distinguish openness about AI use from reasons for a specific output, and design both at the right depth.

  4. Lesson 4.4: Privacy by Design and Data Minimization

    Decide what data an AI system should collect, send, store and log.

  5. Lesson 4.5: Safety, Meaningful Oversight and Risk-Based Controls

    Set safety boundaries and escalation, make human review meaningful, and scale controls by risk.

Part II

Hands-On Foundations

3 chapters · 16 lessons · about 1 h 41 min

Chapter 5Python Without Panic5 lessons

  1. Lesson 5.1: Why Python, Variables, and Data Types

    Explain why Python matters in AI engineering, and use comments, variables and the basic data types.

    Code

  2. Lesson 5.2: Working with Text, Lists, and Dictionaries

    Work with text, store collections in lists, and store structured records in dictionaries.

    Code

  3. Lesson 5.3: Conditions and Loops

    Make programs choose with if / elif / else and logical operators, and repeat work with loops.

    Code

  4. Lesson 5.4: Functions, Imports, and Reading Error Messages

    Package reusable logic in functions, borrow code with imports, and read error messages as clues.

    Code

  5. Lesson 5.5: Putting It Together: The Vital-Signs Flagger

    Combine variables, dictionaries, conditions, loops and functions into a vital-signs flagger, and state what it cannot do.

    Code
Chapter 6Working with Files, Data, and APIs6 lessons

  1. Lesson 6.1: Files and Paths: Reading and Writing Text

    Read, search and write text files safely, using relative paths and the correct file mode.

    Code

  2. Lesson 6.2: Structured Data and CSV

    Tell structured, semi-structured and unstructured data apart, then read, convert, classify and write CSV.

    Code

  3. Lesson 6.3: JSON: The Shape Systems Speak

    Map JSON to Python dictionaries, read and write it, and explain why structured AI output must be validated.

    Code

  4. Lesson 6.4: APIs: Requests, Responses, and Status Codes

    Describe how one system calls another (endpoint, method, payload, status code) and plan a call before coding it.

  5. Lesson 6.5: Failing Safely: Secrets, Errors, and Validation

    Keep keys out of code, handle file, JSON and API failures, and validate data before using it.

    Code

  6. Lesson 6.6: Putting It Together: FHIR Bundle to Vitals CSV

    Read a FHIR Observation and Bundle, filter by status and LOINC code, validate, and export to CSV.

    Code
Chapter 7Developer Tools for AI Engineering5 lessons

  1. Lesson 7.1: Your Workspace: Editor, Terminal, Scripts vs Notebooks

    Name the parts of an AI engineering workspace and choose between a notebook and a script.

  2. Lesson 7.2: Project Folders, Virtual Environments, and pip

    Structure a project, isolate its packages in .venv, and record them in requirements.txt.

  3. Lesson 7.3: Secrets and Version Control: .env, Git, GitHub, .gitignore

    Keep secrets and patient data out of the repository and use commits, branches and remotes.

    Code

  4. Lesson 7.4: Debugging and Testing

    Debug calmly using print(), type() and breakpoints, and write simple pytest tests.

    Code

  5. Lesson 7.5: Putting It Together: The Reproducible AI Risk Reviewer

    Package the Ch6 classifier as a documented, version-controlled, reproducible project.

    Code

Part III

How AI Works

3 chapters · 17 lessons · about 1 h 48 min

Chapter 8Machine Learning in Plain English6 lessons

  1. Lesson 8.1: What Machine Learning Is (and Isn't)

    Contrast rule-based programming with learning from examples, and separate algorithm from model.

  2. Lesson 8.2: Data, Features, and Labels

    Identify features and labels, and recognise weak, risky and proxy features.

  3. Lesson 8.3: Training, Testing, and Inference

    Explain the model lifecycle and why testing must use unseen data.

  4. Lesson 8.4: Kinds of Learning

    Match a problem to classification, regression, clustering or reinforcement learning.

  5. Lesson 8.5: Measuring Performance: Accuracy, Precision, Recall, and the Confusion Matrix

    Choose metrics that fit the consequences of each kind of error.

    Code

  6. Lesson 8.6: How Models Fool Us: Overfitting, Underfitting, Leakage, Bias

    Recognise the failure modes that create false confidence or unfair outcomes.

Chapter 9Neural Networks and Deep Learning5 lessons

  1. Lesson 9.1: From ML to Deep Learning: Neurons and Layers

    Describe a neural network as layers of mathematical neurons, and what "deep" means.

    Code

  2. Lesson 9.2: Inside the Forward Pass: Weights and Activations

    Explain how weights and nonlinear activations turn inputs into a prediction.

    Code

  3. Lesson 9.3: How Networks Learn: Loss, Gradient Descent, Backpropagation

    Describe the training loop and what epochs, batches and learning rate do.

    Code

  4. Lesson 9.4: Why Deep Learning Took Off, and Where It Works

    Explain the drivers of deep learning's rise and match CNNs, RNNs and transformers to images, sequences and language.

  5. Lesson 9.5: Limits and Responsibility: Black Boxes, Shortcuts, Oversight

    Identify deep learning's limitations and the controls clinical settings need.

Chapter 10Large Language Models6 lessons

  1. Lesson 10.1: An LLM Is a Prediction Engine

    Explain an LLM as pattern-based next-token generation, not understanding.

  2. Lesson 10.2: Tokens and Context Windows

    Explain how tokens drive limits and cost, and why a bigger window still needs engineering.

  3. Lesson 10.3: How LLMs Are Trained

    Tell pretraining, fine-tuning, instruction tuning and RLHF apart, and know when fine-tuning is unnecessary.

  4. Lesson 10.4: Hallucination and Grounding

    Explain why LLMs hallucinate and how grounding reduces, but does not remove, it.

  5. Lesson 10.5: Bias, Privacy and Prompt Injection

    Name the three system-level LLM risks and their controls.

  6. Lesson 10.6: Should This Be an LLM? Summarizing a Clinical Note Safely

    Decide when to use an LLM, require structured and validated output, and apply the checklist.

    Code

Part IV

Building AI Applications

4 chapters · 21 lessons · about 2 h 13 min

Chapter 11Prompt Engineering for Grown-Ups5 lessons

  1. Lesson 11.1: Prompts Are Specifications, Not Spells

    Treat a prompt as structured instruction design and name its components.

  2. Lesson 11.2: Role, Task, Context, and Input Boundaries

    Write role, task and context that add clarity without false authority, and fence input off from instructions.

  3. Lesson 11.3: Constraints, Formats, Examples, and Useful Refusals

    Use constraints, output formats, few-shot examples, evaluation criteria and refusals, and ask for rationale rather than chain-of-thought.

  4. Lesson 11.4: A Prompt Pattern Library

    Adapt the reusable patterns and know each one's typical risk.

  5. Lesson 11.5: Test, Version and Defend Your Prompts

    Test prompts on edge and adversarial cases, version them, and treat prompts as one control, not security.

Chapter 12Building Your First AI Application6 lessons

  1. Lesson 12.1: A Prompt Is Not an Application

    Tell a prompt experiment from an app and trace the seven-step app flow.

  2. Lesson 12.2: Input Validation and Prompt Assembly

    Validate input before it enters the system and build prompts with a reusable function.

    Code

  3. Lesson 12.3: Calling the Model: Keys, Temperature, Cost

    Explain API calls, keeping keys in environment variables, temperature choice and cost drivers.

  4. Lesson 12.4: Structured Responses You Can Trust

    Ask for JSON, parse it, and validate required fields and types in code.

    Code

  5. Lesson 12.5: Failing Safely: Errors, Logging, UX

    Handle specific errors kindly, log what you need but never PHI, and design actionable output.

    Code

  6. Lesson 12.6: Human Review and Workflow Boundaries

    Build draft → review → act, add feedback into an app, and keep decisions human.

    Code
Chapter 13Embeddings and Vector Search5 lessons

  1. Lesson 13.1: Meaning as Numbers

    Explain embeddings, vectors, meaning space and embedding models.

    Code

  2. Lesson 13.2: Semantic Similarity and Search

    Compare keyword and semantic search, read similarity scores, and set thresholds and no-match behaviour.

    Code

  3. Lesson 13.3: From Documents to Chunks

    Extract clean text and choose a chunking strategy with overlap.

  4. Lesson 13.4: Metadata, Vector Databases, Top-K and Permissions

    Use metadata for freshness, citation and access control, choose K, and filter before the LLM.

  5. Lesson 13.5: Using and Testing Vector Search

    Apply embeddings to recommendation, clustering, deduplication and RAG, evaluate with expected sources, and spot failure modes.

Chapter 14Retrieval-Augmented Generation5 lessons

  1. Lesson 14.1: RAG: Look It Up Before Answering

    Explain RAG as retrieval plus generation and why it reduces, but does not remove, hallucination.

  2. Lesson 14.2: The Indexing Pipeline

    Prepare governed sources through extraction, chunking, metadata, embeddings and retrieval choices.

  3. Lesson 14.3: Answering with Evidence

    Assemble a grounded prompt, generate, cite from source IDs, and validate before returning.

    Code

  4. Lesson 14.4: How RAG Fails

    Recognise the RAG failure modes and their controls.

  5. Lesson 14.5: Evaluating and Designing a RAG System

    Test retrieval and answers separately, pick metrics, choose RAG vs fine-tuning, and fill in the design canvas.

Part V

Making AI Trustworthy in Production

4 chapters · 24 lessons · about 2 h 32 min

Chapter 15Evaluation: Because Vibes Are Not Metrics6 lessons

  1. Lesson 15.1: A Demo Is Not Evaluation

    Explain why "it answered" is not "it can be trusted", and how evaluation differs from testing.

  2. Lesson 15.2: Success Criteria and the Evaluation Dataset

    Write criteria you can actually test and build a test set that includes hard cases.

  3. Lesson 15.3: Judging Outputs: Reviewers, Rubrics, Pass/Fail

    Score outputs consistently with the right reviewers, rubrics, pass/fail lines and automation.

    Code

  4. Lesson 15.4: Hallucination, Grounding and Partial Truth

    Detect unsupported claims, citations that do not support the answer, and dangerous omissions.

  5. Lesson 15.5: Testing the Hard Cases

    Test safety, refusal, prompt injection, privacy, bias and human-review triggers.

  6. Lesson 15.6: Counting What Matters: Sensitivity, Thresholds, Re-evaluation

    Explain why accuracy misleads in triage and why evaluation continues after launch.

    Code
Chapter 16Privacy, Security, and AI Risk6 lessons

  1. Lesson 16.1: "We Trust the Model" Is Not a Control

    Tell privacy, security and AI risk apart, and personal data from sensitive data.

  2. Lesson 16.2: Minimize, Limit Purpose, Be Transparent, Retain Deliberately

    Send only what is needed, use it only for the approved purpose, and keep it only as long as necessary.

  3. Lesson 16.3: Access Control Before Retrieval

    Apply authentication, authorization, RBAC, least privilege and tenant isolation, and filter before retrieval.

  4. Lesson 16.4: Secrets, Logs and Leakage

    Keep secrets out of code, make logs observable without hoarding data, and recognise leakage paths.

    Code

  5. Lesson 16.5: Prompt Injection and Agents With Tools

    Explain direct and indirect injection and why tool access raises the stakes.

  6. Lesson 16.6: Vendors, Data Location, and Classifying Risk

    Assess third-party AI and data residency, run a PIA or threat model, and classify risk.

Chapter 17AI Governance Without Boring Everyone to Death6 lessons

  1. Lesson 17.1: Governance Is Not Bureaucracy

    Tell governance, compliance and bureaucracy apart, and describe governance as an operating model.

  2. Lesson 17.2: Policies, Inventory and Intake

    Make AI use visible through policies, an inventory and a light intake process.

  3. Lesson 17.3: Risk Tiers, Review Gates and Approvals

    Match review depth to risk and record approvals properly.

  4. Lesson 17.4: Roles, RACI and Human Oversight

    Assign ownership and choose in-, on- or over-the-loop oversight.

  5. Lesson 17.5: Evidence: System Cards, Impact Assessments, Audit Trails

    Produce the documentation that makes AI decisions reconstructable.

  6. Lesson 17.6: Governance After Launch

    Set review cadence, change control, incident response and training.

Chapter 18Deployment and LLMOps6 lessons

  1. Lesson 18.1: Launch Is the Start of Operations

    Explain why AI deployment differs, and how dev, staging, production and configuration protect users.

  2. Lesson 18.2: Version Everything: Prompt Changes Are Deployments

    Set up CI/CD with AI checks, versioning, and prompt and model management.

  3. Lesson 18.3: Observability: Monitoring Quality, Safety and Retrieval

    Instrument what matters without over-logging.

  4. Lesson 18.4: Cost and Latency

    Track and control spend and speed.

  5. Lesson 18.5: Drift, Feedback and Human Review as Instrumentation

    Detect decline through edit rate and feedback, and run human review as an operation.

  6. Lesson 18.6: Rollback, Incidents and Gradual Release

    Plan the kill switch, incident evidence, staged rollout and go / no-go.

Part VI

People and Delivery

2 chapters · 8 lessons · about 51 min

Chapter 19Human-Centered Design for AI Engineering4 lessons

  1. Lesson 19.1: Why Accurate AI Still Fails People

    Define human-centred design and the socio-technical view.

  2. Lesson 19.2: Making Uncertainty Usable and Outputs Traceable

    Replace bare confidence scores with evidence, and link outputs back to their sources.

  3. Lesson 19.3: Designing the Handoff Without Losing Context

    Design when a handoff happens, how it shows, and what the receiver gets.

  4. Lesson 19.4: Measure Decision Change, Not Model Score

    Use the eight-field Design Canvas and measure whether decisions improved.

Chapter 20Project Management for AI Engineering4 lessons

  1. Lesson 20.1: The Adoption Crisis

    Explain why AI projects differ from traditional ones, and why delivering a model is not delivering change.

  2. Lesson 20.2: Phases That End in Decisions

    Structure uncertainty with iterative phases, funded gates and stopping rules agreed in advance.

  3. Lesson 20.3: People-First Adoption and Human Review as Scope

    Plan task-oriented adoption, and budget review, override and recording as real scope.

  4. Lesson 20.4: Where Healthcare AI Projects Actually Stall

    Scope integration first and treat scale-up as a new project.