Product Discovery Before the Build: What the First Two Weeks Should Actually Produce
What a two-week software discovery phase should produce before any build starts: problem framing, user evidence, scope, risks, architecture and a priced plan.

Most expensive software mistakes are made before anyone writes code. A team builds the wrong thing well, underestimates an integration, or learns in month three about a constraint that was knowable in week one. A short, structured discovery phase prevents most of that, and it costs a small fraction of the build.
This guide covers what the first two weeks should actually produce, regardless of who builds the product. For what happens after discovery, week by week through to launch, see discovery to launch in 12 weeks.
Why two weeks
Discovery needs enough time to talk to real users, test assumptions and investigate technical risks. It also needs a hard stop. Two weeks is enough for most focused products or major features. Larger programmes may need three or four, but when discovery runs longer than that, it has usually turned into design or build without anyone saying so.
The deadline keeps decisions moving. The aim is not certainty. It is enough evidence to commit budget sensibly.
The eight outputs
A discovery phase should leave you with these, as documents you own.
1. A problem statement and success metrics
One page: who has the problem, what it costs them today, what changes if it is solved, and the two or three numbers that will show whether the product worked. Without this, every later decision is an opinion.
2. User evidence
Interviews with five to eight people per key user group, plus whatever data already exists: support tickets, analytics, sales notes. The output is a short summary of needs, behaviours and objections, with quotes. It often changes the priorities more than anything else in discovery.
3. User flows
The key journeys mapped end to end, including the unhappy paths: errors, cancellations, missing data. Flows expose scope that a feature list hides.
4. A prioritised scope with a clear first release
Everything that came up, sorted into must-have for the first release, next, and later. The first release should be the smallest thing that delivers the core value to real users. Most first-release scopes shrink by a third in this step.
5. A clickable prototype of the riskiest flow
Not the whole product. The one flow where being wrong would hurt most, prototyped and put in front of a few users. Cheap to change now, expensive later.
6. Technical spikes and an architecture note
Short experiments that answer the questions that could sink the build. Can the old ERP's API handle this load? Does the model perform well enough on our data? Will the payment provider support this flow? Then a short architecture note covering the stack, the main components, integrations, hosting and data handling, with the reasoning behind each choice.
7. A risk register
The risks that remain, each with likelihood, impact, owner and mitigation. Regulatory constraints belong here, such as data residency in the UAE, the DPDP Act in India, HIPAA in US healthcare or UK GDPR. So do dependencies on other teams and vendors.
8. An estimate and plan
A priced plan for the first release, with milestones, team shape and assumptions written down. The assumptions matter as much as the number: they are what to revisit when scope changes.
Who needs to be in the room
From your side:
- A decision-maker who owns the outcome and can make trade-offs quickly.
- People who know the users, or are users.
- Someone who knows the existing systems and their quirks.
Two to four hours a week from each is usually enough. Discovery fails when the people who can answer questions are never available to answer them.
A typical two weeks
Days 1-2. Kick-off, problem framing, success metrics, and scheduling interviews. Review existing data.
Days 3-6. User and stakeholder interviews. Map current journeys. Start technical spikes on the biggest unknowns.
Days 7-8. Draft flows and scope. Build the prototype of the riskiest flow.
Days 9-10. Test the prototype with users. Finish spikes. Write the architecture note, risk register and estimate. Present the findings and the recommended first release.
Signs of a weak discovery phase
- It produces a long feature list but no prioritised first release.
- No users were interviewed, only stakeholders.
- No technical risk was investigated; the estimate rests on assumptions about systems nobody looked at.
- The documents only make sense to the vendor that wrote them.
- It ends in a proposal for the maximum scope rather than the smallest useful release.
When discovery says "don't build"
Sometimes the evidence shows that the problem is smaller than thought, that an existing product already solves it, or that a constraint makes the idea impractical. That is a successful discovery. Finding out in two weeks saves months and most of a budget.
Discovery across markets
The structure is the same everywhere; the constraints differ. Buyers in the US and UK often need security review and a data processing agreement before user research can touch production data. UAE government-linked projects may need in-country hosting confirmed before architecture. Indian products often need language scope and payment flows settled early. A good discovery phase surfaces these in week one.
We run discovery for clients across India, the United States, the United Kingdom, the UAE and Canada; see Blurbee's research and discovery services. For choosing the partner who runs it, see how to vet a software development partner.
Questions to ask before hiring someone to run discovery
- Will we talk to real users, not just stakeholders?
- Which technical risks will you investigate, and how?
- What exactly will we receive, and can we use it with another vendor?
- Is the price fixed and the duration capped?
- Will you tell us if the answer is not to build?
A vendor who hesitates on the last question is selling the build, not the discovery.
Start with two weeks
If you are about to commit budget to a build, spend two weeks on discovery first. You will either build with more confidence, build less, or not build at all, and each of those is worth more than the discovery costs.
Discovery, in numbers
Blurbee delivery practice, indicative split for a two-week discovery on a new product or major feature.
Why teams start with discovery at Blurbee
Our discovery phase is fixed in length and price and produces documents you own, whether or not you build with us. It is the cheapest insurance a software project can buy.
- Fixed-scope first projectTwo to four weeks, priced as a number rather than an estimate, so you have evidence before a longer commitment.
- One delivery lead, namedYou always know who to ask. No account manager relaying questions to a team you never meet.
- Code and IP are yoursAssigned in writing, handed over with repositories, infrastructure definitions and documentation whether or not you continue with us.
- Performance budgets in CICore Web Vitals and bundle size gate the build. Slow does not ship.
- Accessibility to WCAG 2.2 AAReviewed with automated and manual passes, not claimed on a slide.
- Written overlap disciplineStanding calls inside your working window, everything else asynchronous with a decision log.