Start typing to search this publication.
techcirkle
Open menu

Subscribe to techcirkle

Get new posts delivered straight to your inbox.

Discovery Should End in Artefacts, Not a Slide Deck

What a product discovery phase must produce for engineers to act on it: domain model, integration map, risk register and an explicit exclusion list.

techcirkle
6 min read
Cover image for Discovery Should End in Artefacts, Not a Slide Deck
Team working through a product discovery session
Team working through a product discovery session

Engineers are right to be sceptical of discovery. Most of what is sold under that name is four weeks of workshops that produce a deck, a persona nobody references again, and an estimate that was decided in week one anyway.

But the underlying activity is not the problem. The output format is. Discovery done properly produces things a team can build against, and the difference between a good and bad discovery phase is entirely visible in what lands in the repository at the end of it.

Here is the artefact set worth paying for.

1. A problem statement with evidence attached

Not users want better reporting. Something closer to: eleven of fourteen interviewed operations managers export to a spreadsheet weekly because they cannot filter by two dimensions at once, taking roughly forty minutes each time.

The test is whether the statement could be wrong. If it cannot be falsified, it is a slogan, and slogans cannot be designed against. Every claim should trace to something observed — an interview, a support ticket volume, an analytics query, a recorded session.

2. A domain model that names things properly

The single most valuable output. A diagram or a document that establishes the entities, their relationships, their lifecycle, and — critically — the vocabulary.

Getting the language right early prevents a specific and expensive class of bug: the one where account means three different things in three parts of the system, and the mismatch is only discovered during integration testing. If the business says matter and the code says case, decide which wins before there are forty files using both.

Include the states each entity can be in and the legal transitions between them. Most business logic bugs are illegal state transitions nobody wrote down.

3. A system context map with owners

Every external system the product touches, drawn once, with four annotations per integration:

  • What data crosses, in which direction.

  • Who owns that system inside the client organisation, by name.

  • Whether a sandbox exists and whether anyone has actually authenticated against it.

  • What the documented rate limits and failure modes are.

This map is where estimates go wrong, and always in the same way. The integration nobody could name an owner for is the one that adds six weeks, because it turns out access requires a procurement conversation with a third party.

Structured planning blocks representing prioritisation
Structured planning blocks representing prioritisation

4. A risk register that names the unknowns

Three columns: what we do not know, what it would cost us if we are wrong, and how we plan to find out. Ordered by the second column.

The value is not the document, it is the forced conversation. Teams that maintain one make a habit of buying information early — a spike, a prototype, a call with the vendor whose API you depend on — rather than discovering the problem in month five when the cost of being wrong has multiplied.

5. A first-cut architecture with reversibility marked

Not a full design. A sketch, plus an explicit list of which decisions are expensive to reverse: tenancy and identity, the source of truth for each entity, data residency and what leaves your compliance boundary, the public API contract, and auditability.

Marking reversibility is what keeps the phase from becoming architecture astronautics. Cheap decisions get deferred deliberately. Expensive ones get senior attention now, while changing them still costs a conversation rather than a migration.

6. An explicit exclusion list

The most under-produced artefact in the industry, and the one that saves the most money.

A written list of what is deliberately not in version one, with one line of reasoning each. Not a backlog — a decision record. Backlogs are where features go to wait; exclusion lists are where they go to be argued about honestly.

This document is what you point at in month three when a stakeholder asks why something is missing. Without it, the answer becomes a negotiation every time, and the scope creeps back a few percent per fortnight until the launch date is a rumour.

7. A testable release plan

A first release defined by the user outcome it enables, not the feature count it contains. Plus acceptance criteria specific enough to argue about, and the hypotheses the release is designed to test.

That last part matters more than it sounds. Writing down we believe operations managers will use this weekly instead of exporting, and we will know within a month by measuring export volume converts launch from a finish line into an experiment with a result. Teams that skip it end up debating whether the release went well based on vibes.

What this changes about the estimate

An estimate produced from a brief is a guess with a confident tone. An estimate produced from these artefacts is still uncertain, but it is uncertain about known things, which is a completely different commercial position.

This is also why fixed-price discovery followed by an informed estimate beats a confident estimate produced from a brief. You pay a small, bounded amount to convert unknown unknowns into known ones, and then price the rest with information.

The AI angle worth naming

Assistants have made two parts of this cheaper and one part more necessary.

Cheaper: synthesising interview notes into themes, generating a first-pass domain model from existing documentation and schemas, drafting integration inventories from a codebase, and building throwaway prototypes fast enough that testing three concepts costs less than arguing about one.

More necessary: because implementation is now fast, the temptation is to skip straight to building. A team that can produce a plausible v1 in two weeks can produce a plausible wrong v1 in two weeks, at scale, with generated tests that assert the wrong behaviour confidently. The discovery artefacts above are what keeps that speed pointed in a useful direction.


This is one part of a longer buyer-side guide covering engagement models, budgets, contract clauses and evaluation questions: Product Development Services: A 2026 Buyer's Guide for CTOs. More on how we run custom software development engagements.

Frequently Asked Questions

What should a product discovery phase actually deliver?

Seven artefacts: an evidence-backed problem statement, a domain model with vocabulary and state transitions, a system context map with named integration owners, a risk register ordered by cost of being wrong, a first-cut architecture marking irreversible decisions, an explicit exclusion list for version one, and a testable release plan with hypotheses.

How long should discovery take?

Two to four weeks for most mid-sized products. Longer than that usually means the phase has become a project of its own; shorter usually means the integration inventory and risk register were skipped, which is where estimates most often go wrong.

Why is an exclusion list so important?

Because it converts scope decisions into a written record rather than a recurring negotiation. When a stakeholder asks in month three why something is missing, the exclusion list answers with the original reasoning, which is what stops scope creeping back a few percent every fortnight.

What makes a domain model useful rather than decorative?

Naming and state. Establishing shared vocabulary prevents the class of bug where one word means three things in three subsystems, and documenting legal state transitions catches most business logic errors before they are implemented.

Should discovery produce an estimate?

It should produce an informed one. Estimates derived from a brief are guesses with a confident tone; estimates derived from a domain model, integration map and risk register are uncertain about known things, which is a far better commercial position for both sides.

How does AI change product discovery?

It compresses synthesis — interview notes into themes, schemas into a first-pass domain model, codebases into integration inventories — and makes cheap prototyping realistic enough to test three concepts instead of arguing about one. It also raises the stakes, because a team can now build the wrong thing convincingly fast.

Subscribe to techcirkle