Every product — Spotify, the app on your phone, the one you'll build in this course — travels the same road from a rough idea to something people rely on. Once you can see that road, you'll always know which part of the journey you're standing on, and what your job is there.
Maya, a first-time PM at a small startup, is building a habit-tracking app for busy parents. On her second week she opens a planning doc her founder shared and finds a single line: "Q3: ship the streaks feature." She stares at it. Ship it from where? Has anyone confirmed parents even want streaks? Who's building it, and how will they know it worked? The doc has a finish line but no map of how to get there.
So Maya grabs Sam, an engineer she works with, and they sketch the whole journey on a whiteboard — from "we think parents struggle to stick with habits" all the way to "thousands of parents use this every morning." That sketch is the product lifecycle, and it's the mental model that turns a one-line wish into a plan you can actually run.
The five stages every product moves through
The product lifecycle is the repeating sequence of stages a product passes through as it goes from an unproven idea to a thing people use and pay for. Most teams move through five of them, in order:
- Discovery — find the real problem worth solving.
- Validation — test whether your idea actually solves it, cheaply.
- Development — build the thing for real.
- Launch — get it into users' hands.
- Growth — improve it and reach more people.
Think of it like cooking for guests. Discovery is asking what they're hungry for. Validation is letting one friend taste-test the recipe before you cook for twelve. Development is the actual cooking. Launch is plating and serving. Growth is noticing what got cleaned off the plate, tweaking the seasoning, and inviting more people next time.
For Maya's habit app, that looks concrete: interview parents about why their routines fall apart (Discovery), put a clickable mockup of "streaks" in front of five of them (Validation), build the feature with Sam (Development), roll it out to users (Launch), then watch whether it actually keeps parents coming back and refine it (Growth).
Skipping Discovery and Validation because you're "sure" the idea is good, then jumping straight to Development. This is how teams spend three months building a feature nobody wanted. The cheapest stages to be wrong in are the first two — burn your uncertainty there, not in code.
How the PM's job shifts at each stage
You don't do the same work the whole way through. A PM's focus moves from questions at the start, to specs and decisions in the middle, to metrics and iteration at the end. Same person, very different days.
Here's what Maya is actually doing, stage by stage, on the habit app:
- Discovery — running parent interviews and writing a crisp problem statement. "Busy parents abandon new habits within two weeks because they lose track of their streak." Her main tool is the question.
- Validation — testing the idea before it's built. She makes a clickable mockup and shows it to five parents, watching for confusion. Cheap experiments, not commitments.
- Development — writing the spec (the short doc telling Sam what to build and why), answering his "what should happen if the user misses a day?" questions, and keeping scope tight.
- Launch — coordinating the rollout: who gets it first, what the release note says, and which numbers she'll watch on day one.
- Growth — reading the metrics. Did streaks raise the share of parents who return the next day? If not, why — and what's the next experiment?
Notice the through-line: in early stages Maya is learning; in later stages she's measuring. The job is never "have an opinion and defend it" — it's "reduce uncertainty at whatever stage you're in."
Shipping isn't the finish line — it's the start of learning whether you built the right thing. Treat Launch as the moment your real questions get answered, not the moment the work ends.
Why it's a loop, not a line
The diagram above is drawn as a ring on purpose. A product isn't finished after Growth — what you learn there sends you right back to Discovery for the next thing. The streaks feature shipped, but the data reveals a new problem: parents who travel lose their streak and quit in frustration. That's a fresh Discovery, and the loop turns again.
So the honest picture of PM work is this: most of your time is spent iterating, not launching brand-new products. You cycle the same product through this loop continuously — discover a problem, validate a fix, build it, ship it, learn, repeat. A mature product like Spotify has run this loop thousands of times; that's what all those small weekly improvements are.
This loop is also the spine of the course you're taking. Roughly, the sections map onto the stages: the early sections sharpen Discovery (users, problems, research), the middle sections cover Validation and Development (prototypes, specs, prioritization, working with engineers), and the later sections handle Launch and Growth (releasing, metrics, experimentation). Every lesson you finish moves you one step around the ring.
Pick a product you use daily. Which stage do you think its team spends the most time in right now — and how can you tell from the small changes you notice week to week?
This is the start of your capstone. Choose the product you'll carry through the whole course — your own idea, or borrow Maya's habit-tracking app for busy parents. Then write one sentence for each of the five lifecycle stages describing what you would do at that stage. Keep each line concrete and specific to your product.
Show a strong example
Product: a habit-tracking app for busy parents.
- Discovery: Interview 8 parents about why their morning routines fall apart.
- Validation: Show 5 of them a clickable mockup of "streaks" and watch where they hesitate.
- Development: Write a one-page spec for streaks and build a first version with Sam.
- Launch: Roll streaks out to existing users with a short in-app note; watch next-day return rate.
- Growth: If return rate rises, test reminders next; if a "lost streak" problem appears, loop back to Discovery.
- Products move through five stages: Discovery → Validation → Development → Launch → Growth.
- The PM's focus shifts each stage — from questions and interviews, to specs, to metrics and iteration.
- It's a loop, not a line: Growth feeds the next Discovery, and most PM work is iteration.
- This course's sections map onto the lifecycle, so finishing lessons walks you around the ring.