Product Management · Product Loop · Development Phases · PTOS

From Discover to Iterate: A Complete Guide to the 6 Phases of the Product Loop

A deep dive into each of the six phases of the Product Loop (Discover, Validate, Build, Launch, Evaluate, Iterate) with descriptions of goals, DoD, typical mistakes, and evidence of importance.

From Discover to Iterate: A Complete Guide to the 6 Phases of the Product Loop

A product lives not by releases, but by learning cycles. The Product Loop is not a "waterfall," but an operating system that transforms reality (user behavior) into decisions (product changes). Each skipped phase of this cycle inevitably returns as a problem, only costing more.

Let's break down each of the six phases, their goals, completion criteria (Definition of Done), and typical mistakes.

1. Discovery (Research)

• Goal: To understand what pain is real, for whom, in what context, and what "success" in user behavior looks like. At this stage, we ground the problem in observable reality (data, complaints, churn).
• DoD (Done if):
  • One primary segment is chosen.
  • A symptom in the data is recorded (e.g., drop-off at a specific step).
  • Context is described: when/where/why the pain occurs.
  • Outcome is formulated as a change in behavior.
  • There are at least 3 hypotheses of causes (not solutions!).
• Typical mistake: Immediately drawing a solution—"let's add a button/screen."

2. Validate (Validation)

• Goal: To check if the chosen approach will change user behavior, and if that change will be sufficient. This is the filter between "the idea sounds reasonable" and "the idea withstands contact with reality."
• DoD (Done if):
  • Hypothesis is written in the format: "If we do A, segment S will do B, metric M will change by Δ."
  • Success criterion is set before the test.
  • Validation method is chosen (A/B, fake-door, prototype test, pilot).
  • A decision is made: Go / No-go / Reframe.
• Typical mistake: Validating opinions ("like/dislike") rather than behavior.

3. Build (Construction)

• Goal: To assemble a solution sufficient for initiating learning, but without committing quality suicide or taking excessive risks.
• DoD (Done if):
  • MVP boundaries are defined: what we are doing and what we are consciously not doing.
  • Analytics and instrumentation are ready before release.
  • There is a feature flag / phased rollout / rollback plan.
  • Operational readiness is ensured (support, FAQ).
• Typical mistake: Believing "done" = "all tasks in the task tracker are closed."

4. Launch (Deployment)

• Goal: To bring the change to actual use so that the right people perform the right action. Launch is a controlled experiment, not just a blog post.
• DoD (Done if):
  • The initial segment and channel are defined.
  • The first valuable action (value-event) is defined.
  • There is a communication/activation scenario (enablement).
  • Monitoring of key metrics and errors is enabled.
  • Roles are assigned: who decides to "expand / stop / roll back."
• Typical mistake: Launch = "deployed to production" + a post in a channel.

5. Evaluate (Assessment)

• Goal: To answer one question: did behavior change (and why), and what does it mean for the product and business.
• DoD (Done if):
  • There is a comparison of baseline (before) and result (after) by segments.
  • The outcome-metric promised in Validate is measured.
  • Guardrail metrics (side effects) are checked.
  • An explanation of the mechanism is formulated: why it worked/didn't work.
  • A decision is made: Scale / Fix / Kill / Learn-more.
• Typical mistake: "The metric grew—so it's a success," without analyzing side effects and the mechanism of growth.

6. Iterate (Iteration)

• Goal: To transform Evaluate findings into the next verifiable step: improve the solution or change course.
• DoD (Done if):
  • An explicit choice is made: improve the current solution or return to Discover.
  • 1–3 new hypotheses are formulated.
  • One next move is chosen.
  • There is a stop-doing list: what we stop doing to maintain focus.
• Typical mistake: Iteration = "let's add more features."

The Product Loop is not dogma, but a flexible system. If your team can answer, at any moment, what phase it is in and what it considers "done" for that phase, then you have not a mirage, but a truly working operating system for creating successful products.