You need a discovery phase when the scope, the users or the technical risks are unclear enough that a fixed estimate would be a guess. You can skip it, or shrink it to a few days, when the problem is familiar, one person decides, and the work looks like something the team has built before. Five questions below sort most projects into one of those two groups.
The short answer
Discovery buys certainty before you spend the build budget. It is worth paying for when the cost of being wrong is larger than the cost of finding out. That is true more often than buyers expect, and less often than some sellers claim.
Estimation research gives a sense of the stakes. Steve McConnell's "cone of uncertainty", built on Barry Boehm's earlier work, puts the error of an estimate made at the initial-concept stage at roughly 0.25x to 4x of the real figure, and describes that as close to the best case, not the worst (Construx). The range narrows only as decisions get made and written down. Discovery is the deliberate, paid version of that narrowing.
The UK government's service manual, which treats discovery as a standard first step for public services, puts a typical discovery at 4 to 8 weeks and notes that a team that already knows the problem well may need less (GOV.UK service manual). Private software projects often run shorter. For a fuller picture of what the phase produces, see discovery phase in software development.
Five questions that decide it
Answer each one honestly. Every "yes" is a reason to run discovery; three or more usually mean a full one.
| Question | A "yes" looks like | Why it matters |
|---|---|---|
| 1. Is the scope unclear? | The brief is a paragraph, a deck or a list of features without priorities | Without an agreed scope, any estimate is a price for a guess |
| 2. Is the domain new to the team? | Regulated industry, unfamiliar workflows, jargon you had to look up | Hidden rules surface late and expensively |
| 3. Are there many stakeholders? | Several departments, a sponsor who is not the day-to-day owner, outside partners | Conflicting needs have to be settled before building, not during |
| 4. Is the budget or date fixed? | A grant, a board-approved figure, a launch tied to an event | A fixed envelope needs a scope that provably fits inside it |
| 5. Are there integrations or data migrations? | An existing CRM, ERP, payment provider, legacy database | Integrations hide most of the technical risk |
A few notes on reading the answers:
- Question 4 cuts both ways. A fixed budget is a reason to run discovery, not to skip it to save money. The point is to find out what fits inside the number.
- Question 5 is the one most often underrated. "We just need to connect to their system" can mean an afternoon or a quarter, depending on whether the other system has a usable interface and an owner who answers emails.
- The answers come from evidence, not optimism. If you are not sure whether the scope is clear, ask two stakeholders to describe the first release separately and compare.
When to skip or shrink the discovery
There are honest cases where a full discovery is overhead:
- A known pattern. A marketing site, a content update, a feature similar to three the team shipped last year on the same codebase.
- One decision maker and a written spec. Someone who can answer questions within a day, plus requirements that already exist and are current.
- A throwaway prototype. If the goal is to learn by building something small and discarding it, the prototype is the discovery.
- A small, time-boxed budget. When the whole build is a few weeks of work, a multi-week discovery is out of proportion; a short brief and a working first slice teach more.
- Continuing work. The next phase of a product the same team built, with the same people deciding.
In each case the risk does not vanish; it is just small enough to absorb in the build. Write down the assumptions anyway, so that when one turns out wrong it is a recorded change, not an argument.
What a 'light' discovery looks like
When the answer is "some discovery, not much", compress it to a few days instead of weeks. A light version that still holds up:
- Read what exists first. Collect the brief, decks, emails and any old specs, and summarize them in a page.
- Run two to four interviews. The decision maker, one or two users, and whoever owns the riskiest integration.
- Write the one-page brief. Problem, goals with a measure each, users, and what is out of scope.
- List the requirements with priorities. Must, Should, Could, Won't is enough at this size.
- Name the risks and open questions. Each with an owner and a date to close it.
- Give a range, not a number. Low and high effort for the first release, with the assumptions behind it.
The discovery phase checklist works as the quality bar for a light discovery: if a section of it does not apply, say so in one line rather than leaving it blank. Its first section is a quick test of whether you have talked to the right people:
Tools can shorten step 1; Discovery Phase AI, for example, drafts the background, stakeholders, goals and requirements from the files you upload, which you then review and correct in the interviews.
What it costs to skip it (the failure patterns)
Skipping discovery rarely fails loudly at the start. It fails in recognisable ways later:
- The estimate was a price for a different project. The team quoted what they imagined; the client meant something larger. The gap turns into change requests and strained trust.
- The late stakeholder. Security, legal or a department nobody interviewed sees the product near launch and blocks it until changes are made.
- The integration surprise. The other system has no usable interface, rate limits, or data in a shape nobody expected, and the work grows after the price is agreed.
- Building the wrong first release. Without agreed goals, the team builds the features that were easiest to describe, not the ones that matter most.
- No shared definition of done. Without acceptance criteria, "finished" becomes a negotiation at the end.
A discovery turns most of these into written items before the build starts. In our example report, made for an invented project called Fieldwise, a missing partner API appears as a blocker and the technicians' distrust of the sync as a risk, each linked to the stage it affects:
None of these is guaranteed, and a short brief prevents some of them. The question is not whether discovery is good in general, but whether this project's unknowns are expensive enough to pay to remove them first. If you answered "yes" to three of the five questions above, they probably are.
Disclosure and a sample
I build Discovery Phase AI, a tool aimed at the writing-and-assembling side of discovery: it drafts the early stages from the decks, documents and call transcripts you already have, and exports one report. Your team still runs the interviews, reviews every draft and makes the decisions.
If you just want to see what a finished discovery looks like, here is a complete sample report for an invented field-service app. No signup needed.
The original of this post is on our blog. Questions or corrections are welcome in the comments.
This post was drafted with AI assistance and edited by a human before publishing.
