Now live

Ship a Machine Learning Product

From Jordan's four-sentence ask and Sam's departed notebook to a service in production: requirements, a reproduced baseline, a tested package, traceable predictions, a composed Docker system, a deployment promoted by digest, and the operating loop that follows.

Instructor Sarah Floris · Lead ML Engineer

9 Lessons

1 Build

Start Course

Included with Pro

Become a founding member Preview first lesson

The booking scorer notebook, inherited as Sam left it
A worked requirements.md — promises, owners, hypotheses
A tested package with versioned models, saved predictions, and a one-command retrain
The whole system under Docker, then deployed to a production URL
An assignment every lesson, and a project in week ten

Requires Working Python · shipped something to production

What you will learn

What you will build

A requirements.md a stakeholder can sign — before any code, with the model-at-all call made and every open question owned
A tested package extracted from the notebook — the feature path written exactly once, pinned against a reproduced baseline
Saved predictions and versioned models — every score traceable to the artifact that produced it, retraining as a compare-before-promote decision
A composed Docker system — image, database, and scorer running locally with one command
A service running in production — promoted from staging by digest, load-tested against a budget, with the operating loop for the day the model ages

Chapter list

9 chapters

9 lessons · Founding Member

01	First Step: the Requirements Before the code: screen whether the request actually needs machine learning, then write docs/requirements.md — the goal, ownership, requirements, and the out-of-scope list that keeps the project contained.
	Readmission Requirements Practice Write the readmission scorer's requirements from the manager's thread — the same framework, a clinical stakeholder map, and a governance rule that is not a preference.
02	Review the Notebook The anatomy of a working ML notebook — the project, the data, exploration, cleaning, feature selection, model fitting, evaluation, results, and the two sections that say what it does not cover and what happens next — walked through the one Sam left behind, so you can recognise the same parts in a notebook you have never opened.
	Baseline the Notebook Practice Sam built this one for another client. Work out which parts of it the system actually needs to run — and which ones did their job the day she ran them.
03	The System Design The technical counterpart to requirements.md: background, functional and non-functional requirements, three architectures drawn so you can see why two of them fail, and the decision you got signed off.
	Open the System Design Practice Open the readmission scorer's docs/system-design.md — the same six sections, a Background built from your own parked receipts, a batch-shaped technical floor, and a first entry of your own.
04	Package Structure Decide where ML code lives before moving any of it: how many repositories, the src layout, and a destination for every notebook cell.
	Outline the Project Practice The same skeleton and the same cell-by-cell walk — with the readmission notebook's frictions arguing for the structure, her limitations moved to the risk list, and the answers pinned before anything moves.
05	From Notebook to Package Extract the notebook into the package: functions that do one thing, the feature path shared by training and prediction written exactly once, and unit tests that pin the pinned baseline.
	Extract and Attack Practice The whole move on your own project: extract the feature package with its pins, run the consistency pass, and build the attack suite from the readmission data's measured habits.
06	Make Predictions Traceable A score is worthless as a record unless you can say later what produced it: the ledger that keeps every prediction with its features, the artifact that carries its own papers, and the endpoint that names the model in every answer.
	Make It Traceable Practice Give the readmission scorer a memory, papers, and an endpoint that names its model — and decide what a service returning patient-level risk is allowed to expose.
07	Run the Whole System Locally Stop saying "works on my machine": pin what Python needs, freeze the layer beneath it into an image, and describe the whole system — service and database — in one file a stranger can run.
	Run It Practice Pin what the readmission scorer needs, freeze it into an image, and describe the whole stack in a file another engineer can run from a fresh clone.
08	Deployment Take the served application off your machine and all the way to production: push the image by digest, declare it as a Deployment on a Kubernetes cluster against managed Postgres, load-test it — then promote the exact bytes staging proved, by pointing at a digest and never by rebuild.
	Deploy It Practice Take the readmission scorer off your machine and all the way to production — and decide, in writing, who may call a URL that returns patient-level risk.
09	What Happens Now? The system is live and the world keeps moving: how you find out the data aged, how to tell a real win from noise, and when the answer is a new model rather than a new conversation.
	Retrain, Compare, and Decide Practice Run one full retraining cycle on the readmission scorer: a candidate with papers, a holdout comparison that holds the calendar still, a recorded verdict, and a rehearsed rollback.
	Ship It End to End Practice The module's closing build: take the readmission notebook through the entire journey the lessons ran on the booking scorer — requirements to a served system running in production, graded by pass/fail acceptance specs.
	Your Own Machine Learning Product Capstone The last piece, and the only one nobody scoped for you: pick a problem, decide whether it is even machine learning, and take it the whole distance — graded on the argument rather than the artifact.

Ship a Machine Learning Product

What you will build

Working Python, something shipped

9 chapters

Ready to start?