Skip to content

Product Discovery Before the First Line of Code

Discovery lowers the risk of efficiently building the wrong thing. I show a continuous track that tests assumptions before they tie up expensive delivery – not a phase before development.

≈ 10 min readSoftwareProduct

The most expensive lines of code I have seen in projects were technically flawless. Cleanly tested, elegantly structured, shipped several times a day in a continuous delivery pipeline. The only problem: they solved a problem nobody had. Half a year of development capacity, a flawless feature, and at the first real contact with users, the underlying assumption collapsed. Clean craftsmanship simply says nothing about whether anyone gets anything out of it in the end. No pipeline asks that question.

This is exactly where product discovery comes in. And I don’t mean an upfront analysis phase in which documents are produced for six weeks before anyone is allowed to touch code. I mean a parallel, continuous track. An assumption is confronted with the cheapest sensible experiment before the team builds it out as a feature. That is what this article is about.

Discovery and delivery are two tracks, not phases#

The most common reasoning error is to see discovery as a preliminary stage. First think, then build. That is waterfall in new clothes. The approach that Marty Cagan and Jeff Patton popularized under the term dual-track agile means something else: two tracks that run side by side permanently. The discovery track clarifies what should be built. The delivery track builds it solidly. Both run in every sprint, not one after the other.

The trick lies in the size of the handoff. Before a team commits a large or hard-to-reverse undertaking to delivery, the riskiest assumption behind it should have been tested. Small technical spikes and thin, reversible slices may go into delivery earlier and generate evidence themselves. Dual track isn’t a hard lock between thinking and building.

flowchart LR
  subgraph Discovery
    A[Idea] --> B[Assumption]
    B --> C[Experiment]
    C --> D[Validated item]
  end
  subgraph Delivery
    E[Build] --> F[Test]
    F --> G[Release]
  end
  D -->|only validated work<br/>enters delivery| E

The arrow in the middle is the real message. It is a filter. Everything that passes through it has passed a test. Everything that fails in the discovery track has never burdened a development team. That is the lever: a discarded experiment costs hours, a discarded feature costs months.

Just as important is who does discovery. It isn’t a task that an upstream analysis department completes and then hands over as a finished specification. Teams that do this well put product management, design, and engineering on the discovery track together – the trio Marty Cagan describes. The developer who assesses feasibility hears in the same user interview why a feature is wanted in the first place. The designer who builds a prototype understands the technical limits firsthand. This shared responsibility is why discovery stays fast: decisions are made where the knowledge sits, without the detour through handoff documents. If you delegate discovery to a single role, you bring back the waterfall dynamic that the dual-track approach is meant to avoid.

The four big risks discovery addresses#

When you ask why a particular feature should be built, the answer in discussions usually covers only a single dimension. In the second edition of INSPIRED, Cagan named four classes of risk that any serious discovery has to probe:

Value risk asks whether users want it at all and whether they will switch or pay for it. Usability risk asks whether they can use it. Feasibility risk asks whether we can build it with our time, our data, and our technology. And viability risk asks whether it fits the business – legally, economically, strategically.

Feasibility attracts attention because it is the question developers most like to answer. “Can we build it?” can almost always be answered with “yes.” But the expensive failures sit in value and viability risk. Discovery forces you to look at all four before the first story is sliced.

Making assumptions visible and prioritizable#

The most practical step is both banal and effective: write down the assumptions. Every product idea is a stack of unspoken bets. “Users want to configure their reports themselves.” “The payment API meets our latency requirement.” “Sales can sell this without training.” As long as these sentences stay in people’s heads, you can’t test them and can’t prioritize them.

With assumptions mapping, David J. Bland established a simple tool: a matrix with two axes. One axis measures how important an assumption is – does the whole undertaking fall apart if it is wrong? The other measures how much evidence we already have. The top-right quadrant, important and barely supported, gets tested first. That is the riskiest assumption, and it deserves the first test.

quadrantChart
  title Assumptions Map
  x-axis Low evidence --> High evidence
  y-axis Low importance --> High importance
  quadrant-1 Test first
  quadrant-2 Keep as leap of faith
  quadrant-3 Ignore for now
  quadrant-4 Already known
  Users self-configure reports: [0.2, 0.9]
  Payment API meets latency SLA: [0.35, 0.85]
  Sales can sell without training: [0.6, 0.4]
  Login flow is usable: [0.8, 0.3]

I store this state versioned in the repository instead of pinning it to a whiteboard. An assumption register next to the code makes the bets part of the project and not part of a forgotten workshop:

# assumptions.yaml — reviewed before any story enters delivery
assumptions:
  - id: A-1
    statement: "Users will self-configure their reports instead of asking support"
    type: desirability
    importance: high
    evidence: low
    test: landing-page
    kill_criterion: "signup-to-config rate below 20% after 200 visitors"
  - id: A-2
    statement: "The payment API stays under our latency budget at peak load"
    type: feasibility
    importance: high
    evidence: low
    test: spike
    kill_criterion: "p95 response time above 200ms in a load test"
  - id: A-3
    statement: "Sales can close the feature without extra training"
    type: viability
    importance: medium
    evidence: low
    test: interview
    kill_criterion: "3 of 5 reps ask for a dedicated enablement session"

For a confirmatory test, kill_criterion is the crucial field. If you only decide after the test what a good result would have been, you easily find an explanation for why your favorite idea won after all. Exploratory discovery may start more openly; as soon as a concrete hypothesis is to be decided, the criterion belongs on record beforehand.

Progress means validated learning, not shipped features#

In The Lean Startup, Eric Ries coined the term I still orient myself by today: validated learning. Progress is measured by assumptions we have settled reliably, not by features in a release. The build-measure-learn loop revolves around exactly this question: what is the fastest way to test a bet?

This is where the biggest misunderstanding around the MVP lurks. A minimum viable product isn’t a cheap, half-finished product. It is the experiment with the greatest learning yield per effort. Very often, it contains no code at all. A landing page that advertises a feature that doesn’t exist yet and counts sign-ups. A concierge approach, in which a human manually does what software is supposed to do later. A demo video that measures the reaction. For assumption A-1 above, the landing page is faster and more honest than any implementation. It answers the value question in days instead of months.

If the result clearly speaks against the assumption, the right reaction isn’t to build anyway. It is the pivot – change direction and go after a different bet. Teams find that hard, because discarded ideas feel like failure. They are the opposite. Every assumption that is knocked over early is capital saved.

Technical assumptions need testing too#

Discovery isn’t purely a product or UX topic. Feasibility risk is often the quietest and most expensive bet. “The payment API meets our latency” is a technical assumption that you can make tangible before a feature builds on it. I phrase assumptions like these as executable tests – a Fitness Function in the sense of Building Evolutionary Architectures. It makes a quality goal measurable and repeatable:

// fitness function — runs the riskiest technical assumption as a test
import { measureP95 } from "./load-harness";

const SLA_MS = 200;

test("checkout endpoint stays under the latency budget at peak load", async () => {
  const p95 = await measureP95({
    endpoint: "/api/checkout",
    concurrentUsers: 500,
    durationSeconds: 60,
  });

  expect(p95).toBeLessThan(SLA_MS);
});

The value of this test shows at the moment it turns red before a feature goes live. Then we know: the technical assumption doesn’t hold. Better now than in production. The same way of thinking applies to failure behavior. If a feature depends on an external service, the assumption “the service is available” is a bet that you defuse with stability patterns such as a circuit breaker from Michael Nygard’s Release It! – and with consumer-driven contract tests that check whether two services still understand each other before the break shows up in production.

Why efficiency alone doesn’t protect you#

The obvious objection is: “But we already ship quickly and reliably.” And yes, that is valuable. The book Accelerate by Nicole Forsgren, Jez Humble, and Gene Kim used four metrics to show how delivery quality can be measured: Deployment Frequency, Lead Time for Changes, Change Failure Rate, and Mean Time to Restore. Teams that are strong here ship often, fast, and with few failures.

But none of these metrics measures whether the right thing is being built. They measure how well the delivery track runs. A team with top scores can ship features nobody needs at a high frequency. Speed at building the wrong thing is still waste – just faster. That is why both tracks belong together: discovery makes sure we work on the right thing, delivery excellence makes sure we build it well. If you only optimize the second half, you end up building yourself the most efficient way to burn money.

That is the economic core. Discovery isn’t an additional process layer that slows down cycles. It shortens the cycle that really counts: from idea to validated insight. A landing page test takes days. A misguided feature takes months and still fails. Discovery trades the expensive, late feedback of the market for cheap, early feedback in an experiment.

What this looks like day to day#

I boil the method down to a few habits that don’t need a heavy framework. Before every larger undertaking, the assumptions are written down and placed on the two-axis matrix. The riskiest assumption gets a suitable experiment; a confirmatory test gets a decision criterion defined in advance. Technical bets are tested as a Fitness Function or a spike, not nodded through on gut feeling. As long as the biggest uncertainty is open, the delivery investment stays small and reversible.

That sounds like more work up front. In practice, it can shorten big detours, but it doesn’t guarantee that. The teams I work with this way argue less about opinions and more about evidence. A landing page with two hundred visitors can deliver a signal if the target group, traffic source, and expected effect fit; it replaces neither proper sample design nor qualitative follow-up questions. What disappears is part of the unproductive friction between opinions without data. The productive friction around the problem remains.

Conclusion#

The first line of production code increases the investment, but it isn’t an irreversible border crossing. Product discovery keeps the riskiest decisions small until there is enough evidence for the next stake. Discovery and delivery run in parallel: one track clarifies what to build, the other delivers small, reliable steps and can itself be part of the experiment.

The common thread is simple: you can do everything right technically and still deliver the wrong thing. Efficiency in delivery is necessary, but it is no substitute for the question of whether we are working on the right thing. If you make assumptions visible, test the riskiest one first, and set a decision criterion for confirmatory tests, you improve your chances of shorter learning cycles and well-founded decisions. Discovery remains work; its value lies in not confusing expensive certainty with unsupported confidence.

Further reading#

  • Marty Cagan: INSPIRED (2nd edition, 2017) and the “four big risks” at svpg.com/four-big-risks
  • Jeff Patton and Marty Cagan on dual-track agile, jpattonassociates.com and svpg.com
  • Eric Ries: The Lean Startup (2011), build-measure-learn and MVP, theleanstartup.com
  • David J. Bland: assumptions mapping, precoil.com and strategyzer.com
  • Nicole Forsgren, Jez Humble, Gene Kim: Accelerate (2018)
  • Neal Ford, Rebecca Parsons, Patrick Kua: Building Evolutionary Architectures (2017)
  • Michael Nygard: Release It! on circuit breakers and stability patterns

Revised and translated from German with the help of AI.