The first fortnight of a new machine learning project is often lost to small questions. Where does the data come from? Who can approve compute? Which notebook is the current one? A team that answers these in advance moves faster, and the simplest way to answer them is a project starter kit checklist: a short list of ready-made essentials that a new member, or a brand-new project, can pick up on day one. This article gives a working checklist you can adopt, with notes on how to verify each line is really in place.
How to use this checklist
Treat it as a pre-flight routine rather than a one-time audit. Before a project kicks off, or before a new person joins, walk down the list and mark each line as present, partly present or missing. Wherever a line falls short, give it an owner and a due date. Perfection is beside the point. What matters is a kit complete enough to begin with, not one built to last forever.
Each section below ends with a verification step, a quick test that proves the item works for someone who did not build it.
Section 1: Purpose and boundaries
- A two-sentence statement of what the project is meant to achieve and for whom.
- A list of what is explicitly out of scope for the first phase.
- The name of the person who decides when the scope changes.
Verify: have a newcomer say back what the project is for. A mismatch with your version means the statement needs sharper wording.
Section 2: Data essentials
- A catalogue entry for each dataset, giving its source, owner, refresh pattern and known quirks.
- Read access already granted, or a clear request path with typical turnaround.
- A small, safe sample dataset that anyone can load in minutes for experimentation.
- Notes on sensitive fields and any handling rules.
Verify: have someone load the sample and run a basic summary without asking anyone a question.
Section 3: Environment and tooling
- A pinned environment definition so results can be reproduced.
- A single command that sets up the workspace.
- Access to the compute the project needs, with any quotas noted.
- A starter notebook or script that trains a trivial baseline model end to end.
Verify: run the setup command on a clean machine and confirm the baseline trains.
The baseline matters more than its accuracy. It proves that data loading, training and evaluation all work together, so every later experiment can be compared against something real. Background on why this discipline matters in production settings is available in a piece about the part operational practice plays in machine learning outcomes.
Section 4: Working agreements
- How experiments are named and recorded.
- Where code lives and how changes are reviewed.
- What a model must show before it is considered for release.
- How and where results are shared with stakeholders.
Verify: check that a past experiment can be located and understood by someone outside the team in under ten minutes.
Section 5: People and access
- A short who-to-ask list: data owner, platform contact, reviewer, product contact.
- A table of systems with approvers and usual waiting times.
- A first task with a defined finish line and a suggested first-week plan.
Verify: ask the newcomer on day two which requests they are still waiting on. If the list is long, requests went out too late.
Section 5b: Guardrails for data and results
- A note on which datasets may leave the secure workspace, and which may not.
- A rule for what goes into shared reports, so that a stray screenshot never exposes raw records.
- A named contact for privacy questions, even if that person is simply the data owner.
Verify: ask the newcomer where they would save an intermediate file containing sensitive columns. The right answer should be obvious from the kit.
Section 6: Learning pointers
A kit should say where to read further without pretending to hold everything. Keep this section to a handful of links: an internal architecture overview, a glossary, and outside material for specialised areas. A roadmap-style resource such as a staged guide that takes data and engineering teams from experiments toward production works well in a list like this. Some teams also point to external training sites, for instance QuantumOpsSchool, a website that presents training and certification options for QuantumOps alongside consulting and a blog; including such a link is a convenience, not an endorsement.
Verify: confirm that every link opens and that the list has fewer than eight entries.
A filled-in example
To make the checklist concrete, imagine a team starting a demand-forecasting project. Under purpose they write: “Forecast weekly demand per product family so planners can reorder earlier.” Under out of scope: “Real-time forecasts and new product launches.” Under data they list a sales history table, a calendar of promotions and a sample covering one product family. Under environment they note the pinned image, the setup command and a baseline that predicts last week’s figure forward.
That naive baseline is a good example of the principle. It is almost embarrassingly simple, yet every later model must beat it to justify its complexity. Under working agreements they record that experiments are named by date and idea, reviews happen in pull requests, and a model needs to beat the baseline on a held-out period before anyone discusses release. Under people they list four contacts and three access approvals. The whole kit fits on two pages, and a new analyst can start on it before lunch.
Day-by-day use in the first week
- Day one: open the kit, run the setup command, train the baseline, read the working agreements.
- Day two: confirm all access requests are in motion and start the named first task.
- Day three: record the first experiment using the naming rule.
- Day four: request a review and note any kit gaps found along the way.
- Day five: hold a ten-minute review of the kit with the newcomer and fix what they found confusing.
Scoring the checklist without turning it into a project
A simple three-state mark is enough. Present means a newcomer used it successfully. Partial means it exists but failed a verification step. Missing means it does not exist yet. Resist weighting or averaging; the goal is to close gaps, not to produce a number. Every missing or partial line receives a named person and a due date, and the checklist is reviewed again on the second day of the project.
Who should own the checklist
Ownership decides whether the checklist survives. Pick whoever welcomes newcomers most often, perhaps a tech lead or a project coordinator, because they feel the cost of every gap directly. Give them authority to remove items as well as add them, and ask them to run the walk-through personally for the first two projects. After that, delegate it to whoever last joined, which keeps the wording fresh and the perspective honest.
Avoid making the checklist the responsibility of a committee. A committee adds items cheerfully and removes them reluctantly, and within a quarter the kit is no longer small.
Frequent gaps worth watching
- Undocumented data caveats. A column that quietly changed meaning last year can ruin a baseline.
- Environments that only exist on one laptop. If setup relies on someone’s personal machine, treat it as missing.
- Unclear release criteria. Without agreed thresholds, every model review turns into a debate.
- Orphaned access requests. A request sitting in someone’s queue for a week is the most common reason newcomers stall.
A compact version for small teams
If the full list feels heavy, keep one line from each section: the purpose statement, the dataset catalogue entry, the setup command, the experiment naming rule, the who-to-ask list and the reading list. Six lines, one page, and you still cover the failure points that hurt most. Expand only when you notice a repeated question that the short version cannot answer.
Whatever size you pick, store the checklist next to the code so it is updated by the same people who change the project, and revisit it at the end of every first month. A kit that stays current quietly pays back its small cost with every person who joins.