
How to Build a Product Roadmap for a Startup: Real Examples, Template, and Mistakes to Avoid
How we build a startup product roadmap at the end of discovery: seven steps, a RICE example with a free calculator, four real roadmaps from Empat projects, a free template and the mistakes to avoid.
A product roadmap is a short document that outlines which problems your product will solve, in what order, and what evidence might change those priorities. That last part is often overlooked by founders. A roadmap isn't a software development backlog or a release schedule. It's a strategic guide that connects business goals, user needs, and product development.
In this article, we explain how to build a product roadmap during discovery, with practical steps, a RICE prioritization example, four roadmap examples, and a template to use at the end of the process.
Many startups come to their first discovery call with a feature list and deadlines rather than a clear product strategy. The problem isn't the planning tool. It's the lack of validated assumptions and priorities.
Skipping discovery can be costly. According to CB Insights' analysis of 111 startup post-mortems, 35% of founders cited a lack of market need as a reason for failure. This is why a product roadmap should start with validated problems, not a wish list of features.
Short answers, if you're in a hurry
- How long does a first roadmap take? About a week or two, if you've already talked to users. Most of that week goes into deciding what you won't build.
- How far ahead should it go? Six to eight weeks in detail, the next quarter in outline, everything after that as one-line themes.
- Which format for a pre-seed startup? Now / Next / Later. Dates can wait until you have a team and a release rhythm worth protecting.
What a product development roadmap actually is (and isn't)
A product development roadmap is a record of the bets you're making and the conditions under which you'd stop making them. In a young company, the trouble usually isn't a bad roadmap. It's one document quietly doing four different jobs, so it does none of them well.
Keep these four apart, even in a five-person team:
| Artifact | Question it answers | Horizon | Unit of work | Who owns it early on | How often it changes |
|---|---|---|---|---|---|
| Product roadmap | What problems do we solve next, and why? | 3–12 months | Outcome or theme | Founder (CEO or a product-minded CTO) | Monthly |
| Product backlog | What exactly do we build this sprint? | 1–4 weeks | User story, task, bug | Whoever runs the sprints | Daily |
| Release plan | What ships when, and to whom? | 1–3 months | Release, version | Tech lead | Per release |
| Gantt chart / project plan | Who does what, by when, for how much? | Length of the project | Task with dependencies | Project manager | Weekly |
A simple test helps. If an item fits inside one sprint, it's backlog. If it has a date but no reason, it's a release plan. If it has an assignee, a dependency and a cost line, you're writing a project plan. That's a useful document too, and our software development project plan guide covers it, but it's a different one.
The official Scrum Guide draws the same line from the other side. It defines the product backlog as an emergent, ordered list of what is needed to improve the product. That is a list of work. A roadmap is a list of bets, and the two should not be merged.
A good roadmap is one a founder could defend in front of a skeptical investor. For that it needs five things:
- One goal for the period, phrased as a business result. “20 paying clinics” works. “Launch v2” doesn't, because v2 is a means.
- One North Star metric and the two or three input metrics that actually move it.
- Problems or themes, grouped by horizon. Features come later, in the backlog.
- A confidence level on every item. People should know which parts are evidence and which are hunches.
- Kill criteria. The signal that makes you drop a bet. Without it, nothing ever leaves the roadmap.
The 4 types of roadmaps and when a startup needs each
This is one place where a firm rule beats nuance. Before product-market fit, use Now / Next / Later and nothing else. Add outcomes once you have analytics you trust. Add dates last, and only where the outside world forces them on you.
The format matters more than it seems, because it decides what your team argues about. Hand people a feature list and they'll argue about features. Hand them outcomes and they'll argue about results, which is the argument you want.
| Type | What a row looks like | Best for | Main risk | When to use it |
|---|---|---|---|---|
| Now / Next / Later | “Now: people drop off in the first session. Next: payments. Later: team accounts.” | Pre-MVP and MVP, teams under ~8 people | Turns into a wish list if nobody attaches metrics | Default until product-market fit |
| Outcome-based | “Q1: lift week-4 retention from 18% to 30%” | After launch, once analytics are reliable | Harder for clients and investors who expect a list of features | Layer it on top of Now / Next / Later after launch |
| Timeline-based | “March: Android. May: Stripe Connect.” | Hard external dates: a fundraise, a regulator, a pilot contract | Every date turns into a promise someone screenshots | Only for the one or two items that really have a deadline |
| Feature-based | “Chat, push notifications, referral program” | Enterprise sales, partner integrations | Measures output, not impact | Almost never as the main roadmap in a startup |
What to use before and after the MVP
Before the MVP. One Now / Next / Later board, and “Now” holds only what you need to test your riskiest assumption. That's usually three or four things, and founders are always surprised how short it is. If you're not sure whether you need a prototype or a real MVP for that test, read PoC vs prototype vs MVP before you plan anything.
After the MVP. Keep the same board, but rewrite each “Now” item as an outcome with a number attached. Add a thin timeline layer for the dates that really exist. Investors will ask about it, and it's one of the things that comes up in technical due diligence.
This is what Marty Cagan of SVPG calls an outcome-based roadmap: you state the result you're after, not the feature you assume will deliver it. Cagan also notes that a set of OKRs maps almost one to one onto such a roadmap, so a team already using OKRs is halfway there.
Series A and beyond. By now one roadmap can't serve every audience. Split it three ways: outcomes for the team, themes for customers, dates for the board. They should tell the same story at different resolutions.
How to build a product roadmap in 7 steps
This is the sequence we follow at the end of a product discovery phase. Each step ends with something you can point at. If you can't produce it, don't move on. The roadmap will still look finished, but it'll be sitting on guesses, and you'll find that out in month two, which is the most expensive time to find out.
Step 1. Write one goal for the next three months
Finish this sentence: “In three months we'll know this works if…”. One answer, not three.
This sounds trivial. In practice it's often the longest conversation of the whole discovery, because it's where co-founders find out they want different companies. One wants revenue, the other wants usage, and the investor wants a story. Better to have that argument now, over one sentence, than later over a backlog of 200 tickets.
You're done when you have a sentence with a number and a date, like “15 clinics book at least 40 appointments a week through the app by June 30.”
Step 2. Pick one North Star metric and 2–3 input metrics
Choose the number that moves when users get value, not when you ship code. Then list the levers that move it. If you can't name the levers, the metric is too abstract.
You're done when you have a small metric tree and today's baseline for each number. For the clinic example: North Star is weekly booked appointments. Inputs are clinics activated, the share of patients who finish booking, and repeat bookings within 30 days.
The baseline matters more than people expect. Without it, you can't tell in three months whether anything worked.
Step 3. Turn ideas into hypotheses
Rewrite every feature request in this form: “We believe [feature] for [user] will change [input metric] by [amount], because [evidence].”
The “because” is where most ideas die, and that's the point. A request with no evidence behind it doesn't get deleted. It moves to a separate list called “unvalidated”, which keeps the peace with whoever suggested it.
You're done when a long list of raw ideas has become a much shorter list of hypotheses.
“In our experience, product discovery can help turn 30–60 initial ideas into 10–20 validated hypotheses and a focused MVP scope. The key is to identify what delivers real business value, validate assumptions, and assess technical feasibility before development begins. This helps teams avoid unnecessary features, reduce delivery risks, and make better use of engineering resources”.
— Igor Repeta, CEO at Empat
Step 4. Prioritize with RICE, and show your math
RICE is a prioritization framework that scores each feature or hypothesis by the impact it delivers per unit of effort. The higher the score, the earlier the item goes on the roadmap.
RICE formula:
RICE score = (Reach × Impact × Confidence) ÷ Effort
How to calculate a RICE score:
- Reach: how many users it touches per quarter.
- Impact: 3 = massive, 2 = high, 1 = medium, 0.5 = low, 0.25 = minimal.
- Confidence: 100% if you have data, 80% if you have interviews, 50% if it's a gut feeling. Be honest here; this is the column people inflate.
- Effort: person-weeks, estimated by the person who will write the code. Founders estimate in hope.
The method was developed by Sean McBride at Intercom, and Intercom's original guide is still the best reference for the scales. One adjustment for startups: Intercom measures effort in person-months, which is too coarse for a team planning six to eight weeks ahead. Person-weeks work better.
A worked RICE example. A self-serve onboarding checklist reaches 1,200 users a quarter, has medium impact (1), 80% confidence and takes 2 person-weeks. Its score is 1,200 × 1 × 0.8 ÷ 2 = 480.
RICE Calculator for Prioritizing Product Features
Use our free online RICE calculator to score and compare product ideas based on Reach, Impact, Confidence, and Effort. It helps founders and product teams identify which feature hypotheses deserve priority, what should go into the Now / Next / Later roadmap, and which ideas need further validation before development.
RICE score calculator
RICE = Reach × Impact × Confidence ÷ Effort. Edit any value or add your own features — scores and ranking update as you type.
| Feature | Reach / quarter | Impact | Confidence | Effort, weeks | RICE | Remove |
|---|
Ranking: what goes into “Now” first
The calculator holds an illustrative backlog for a B2B scheduling SaaS with about 1,500 active users. Replace the rows with your own features.
How to read the result
A low score has one of two causes, and each calls for a different move.
- High effort: the item waits. The native app scores 25 because it costs twelve person-weeks and rests on a hunch.
- Low confidence: the item needs a test, not a delay. AI summaries score 83 only because confidence is 50%. A week of summaries prepared by hand for ten customers will either raise confidence to 80% or take the feature off the list.
When to override the ranking
RICE orders the list; it doesn't make the decision. Override it in two cases only:
- A hard dependency. AI summaries can't read calendars that aren't synced yet, so sync goes first whatever its score.
- A fixed deadline, such as a regulatory date or a signed pilot contract.
You're done when every hypothesis has a score, and the team agrees with the inputs even if not everyone likes the result.
Step 5. Place items on Now / Next / Later
Fill “Now” from the top of the ranking until six to eight weeks of the team's real capacity is used up. Use real capacity, not ideal capacity: people get sick, a payment provider changes its API, and someone has to answer support. “Next” covers the following six to twelve weeks. “Later” holds themes, not features.
Here is how the backlog from Step 4 lands, for a team of two engineers:
- Capacity: 2 engineers × 6 weeks = 12 person-weeks on paper. After support, bug fixes and meetings, about 8 are real.
- Now (6 person-weeks): onboarding checklist (2), Google Calendar sync (3) and a one-week test of AI summaries (1). The remaining 2 weeks are a buffer, not room for one more feature.
- Next: admin roles for teams, plus the full AI feature only if the test passes.
- Later: a native mobile app, as a theme with no date.
You're done when every item in “Now” has an outcome, an owner, a confidence level and a kill criterion.
Step 6. Pressure-test it with the people who will build it
Book an hour with your tech lead and designer and ask three questions. What did we underestimate? What's missing? What would we cut first if we lost two weeks?
The second question is the important one. The founder's draft lists what users will see. It almost never includes analytics, security, infrastructure, admin tools or the time to fix what the first release breaks. All of that is cheap to plan for now and painful to add later.
You're done when you have a revised roadmap and a short list of technical prerequisites that now sit in “Now” next to the features.
Step 7. Set a review rhythm before you share it
Put two recurring meetings in the calendar before the roadmap goes out: a 30-minute weekly metrics check, and a monthly review where items move, get promoted or get killed.
Add a changelog at the bottom: the date, what changed and why. It feels like admin. Six months later it's the most useful page you own, because it shows investors, and you, how the company learns.
You're done when both meetings are in the calendar and the changelog has its first line.
4 real product roadmap examples from Empat discovery phases
Frameworks are easy to agree with and often hard to apply. So here are four roadmaps from products we've worked on, with the identifying details taken out. They were chosen because each one forced a different call about what goes first. For each you'll see the context, the roadmap as it left discovery, and what we had to change about three months into the build. That last part is the honest bit, because no roadmap survives contact with real users unchanged.
Product roadmap example 1: Fintech payout platform for niche marketplaces
Context: An API-first platform designed to automate seller payouts and commission calculations for niche marketplaces. Its asynchronous payout infrastructure runs on Celery, Redis, and AWS.
Why it's instructive: In fintech, technical dependencies often determine development priorities. Before adding dashboards or advanced integrations, the platform needs a reliable financial foundation: accurate commission calculations, transaction tracking, and predictable payout processing. These capabilities are prerequisites for everything built on top of them.
| Horizon | Priority | Expected outcome | Validation / decision criteria |
|---|---|---|---|
| Now | Commission calculation and business rules | Seller commissions are calculated consistently according to marketplace rules | Test cases confirm accurate calculations across supported commission scenarios |
| Now | Double-entry ledger and transaction reconciliation | Every payout can be traced and reconciled against financial records | No unresolved discrepancies in test transactions before pilot launch |
| Now | Asynchronous payout processing | Scheduled payouts are executed reliably without blocking other operations | Failed or delayed jobs are detected and handled without losing transactions |
| Now | Core API integration | Marketplaces can initiate payouts and retrieve transaction statuses programmatically | End-to-end integration works in the pilot environment |
| Next | Operational payout dashboard | Marketplace teams can monitor transactions and investigate payout issues | Validate whether the dashboard reduces manual operational work |
| Next | Automated failure handling and notifications | Teams can identify and resolve failed payouts faster | Measure failure resolution time and recurring support issues |
| Later | Additional payout provider integrations | The platform can support more payment infrastructure options | Prioritize when customer requirements or provider limitations justify the investment |
| Later | Self-service marketplace onboarding | New marketplaces can connect with less custom development | Validate demand for self-service integration and identify repeatable onboarding steps |
After ~3 months: The core payout infrastructure is operational, with commission calculations, transaction reconciliation, and asynchronous processing validated through pilot transactions. The operational dashboard and failure notifications have been introduced to improve payout monitoring and issue resolution. Additional provider integrations and self-service onboarding remain postponed until customer demand and operational data justify further investment.
Product roadmap example 2: Healthcare booking platform (US)
Context: patients book doctor consultations, lab tests and prescriptions. The product has three surfaces: a mobile app, a website and an admin panel for managers and doctors, built on Flutter, Laravel, AWS and Firebase.
Why it's instructive: founders plan the patient app and forget the admin panel. Clinics don't leave because a patient found booking awkward. They leave because the receptionist hates the schedule screen. A product with three surfaces needs a roadmap row for each, or one of them quietly starves.
| Horizon | Patient app | Web | Admin panel |
|---|---|---|---|
| Now | Book a doctor consultation in a few taps; metric: share of started bookings that finish | Doctor profiles and sign-up, so patients can find the service | Doctor schedules and slot management; metric: staff run a full day without phone bookings |
| Next | Lab test booking and results in the app | Booking from the website, same flow as the app | Prescription requests and doctor approval |
| Later | Reminders and repeat bookings | Health content for search traffic | Reports for clinic managers |
After ~3 months: The patient app and website support the core consultation booking flow, while the admin panel has been prioritized to improve schedule management and reduce manual phone bookings. Lab test booking and prescription requests remain in the next phase, with reminders and management reports postponed until the core workflow is validated.
Product roadmap example 3: Consumer social app, early stage
Context: a relationship app that connects partners and family at a distance. It passed 10 million downloads on iOS and Android and reached #1 in the US App Store, ahead of Tinder, Pinterest and Netflix.
Why it's instructive: before launch, a consumer roadmap has one job: protect the core loop. Nothing else matters until people open the app again on day two. And if growth comes suddenly, the roadmap flips overnight, from new features to keeping the servers up and the new users around.
| Horizon | Item | Outcome / metric | Kill criterion |
|---|---|---|---|
| Now | Pair two people and send the first gesture in one session | Day-2 return rate (the North Star before launch) | Most pairs never send a second gesture: rework onboarding before adding anything |
| Now | Push notification when the partner reacts | Reactions answered within a day | Notifications disabled by most users: cut frequency, test copy |
| Now | Analytics and crash reporting on every core-loop event | Nothing launches without the funnel being visible | No launch without it |
| Next | Infrastructure ready for traffic spikes | App stays up at many times the usual daily load | — |
| Next | Invites and sharing | New pairs created per active user | Invites rarely accepted: fix the invite flow before more growth work |
| Later | Groups for family (more than two people) | Theme only | — |
After ~3 months: The core pairing and reaction loop has been validated, with onboarding and notifications refined based on early retention data. Following rapid download growth, infrastructure reliability and invite flows have become higher priorities. Group features for families remain postponed until the two-person experience and retention are stable.
Product roadmap example 4: AI analytics product for sales teams
Context: a platform that tracks sales team performance. It pulls data from several CRMs, analyzes sales managers’ conversations with AI and ranks the strongest managers. The stack is Python and React.
Why it's instructive: on an AI roadmap the model is rarely the first item. Data access is. If the CRM integrations are flaky, the AI has nothing reliable to analyze, and a demo that looks great on sample data falls apart on the first real customer.
| Horizon | Item | Outcome / metric | Kill criterion |
|---|---|---|---|
| Now | Integrations with the two CRMs the pilot teams use | Data syncs daily with no manual exports | Sync breaks more than once a week: stop and fix before any AI work |
| Now | Core dashboard: pipeline and activity per manager | Sales heads open it every week | Not opened weekly after a month: talk to users, simplify |
| Now | Call recording import and transcription for one pilot team | Enough real conversations to train and test scoring | — |
| Next | AI conversation scoring and manager ranking | Sales heads agree with the ranking in a blind review | They disagree on most managers: the model is not ready to ship |
| Next | Alerts on deals at risk | Fewer deals lost without warning | Alerts ignored by most users: tune or remove |
| Later | Custom reports and more CRM integrations | Theme only | — |
After ~3 months: The two CRM integrations and core dashboard have been validated with pilot teams, providing reliable sales activity data. Call transcription is operational, and AI scoring is being tested against sales managers’ feedback before wider release. Automated deal alerts and additional CRM integrations remain in the next phase, pending validation of the scoring model and user demand.
Startup product roadmap template (free download)
This is the Google Sheet we hand clients at the end of discovery. It's deliberately plain. Fancy roadmap tools are great at making a plan look good and not much better at making it good.
It opens with a short “How to use” tab, followed by four working tabs, one for each stage of the process above:
| Tab | What you fill in | Time it takes |
|---|---|---|
| 1. Goal & metrics | One goal sentence, the North Star metric, 2–3 input metrics with today's baseline | 30 minutes, plus however long the co-founder debate runs |
| 2. Hypotheses & RICE | Each idea written as a hypothesis, scored on Reach, Impact, Confidence and Effort; the score calculates itself | 1–2 hours |
| 3. Now / Next / Later | The top-ranked items with outcome, owner, confidence and kill criterion | 1 hour |
| 4. Changelog | Date, what changed, why | 5 minutes a month |
Two rules are built in. Tab 3 warns you when “Now” has more than five items, and it counts every “Now” item that has no kill criterion. Both rules are annoying in week one. By month three you’ll be glad they were there.
If your team lives in Miro, ProductPlan or Atlassian, their roadmap templates are perfectly good. Use whatever you'll actually open. The thinking in tabs 1 and 2 is what matters; the format matters far less.
7 roadmap mistakes we see in discovery
Roadmaps go wrong in a surprisingly small number of ways. Smart, experienced founders make every one of them, which is exactly why they're worth naming.
- The roadmap is a feature list. Twenty features and no goal. The quickest fix: go row by row and ask which metric each one moves. If the room goes quiet, the row goes.
- No metrics, so no way to be wrong. A roadmap without baselines can't be reviewed. It can only grow. Write today's number next to every metric before you plan a single feature.
- Twelve months of detail. At pre-seed, a detailed plan for month nine is fiction. You'll learn more in the six weeks after launch than in the whole of discovery. Plan the first quarter properly and leave the rest as themes.
- No kill criteria. Features almost never get killed. They linger, eat maintenance time and confuse users. Decide up front: “If fewer than 10% of active users try this within 30 days, it comes out.” Then actually take it out.
- Engineering work is invisible. The founder's draft lists what users can see. Monitoring, security, analytics and paying down shortcuts aren't on it, and they don't do themselves. Reserve a fixed share of every sprint for them from the start.
- Every stakeholder gets a row. The lead investor, the biggest pilot customer and the co-founder each add “just one thing”, and the roadmap stops having a strategy. Put every request through the same RICE table, out loud, with the person who asked for it in the room.
- It's written once and never looked at again. A roadmap that hasn't changed in three months means either perfect foresight or that nobody reads it. It's always the second one. Book the monthly review before you share the first version.
“A roadmap isn't a promise to build everything on the list. It's a record of what you've learned and what you're willing to prioritize. If, three months later, nothing has changed, you're probably following assumptions instead of learning from your users.”
— Igor Repeta, CEO at Empat
How Empat Builds Roadmaps During AI-Driven Discovery
Empat’s discovery phase typically takes one to two weeks, with projects starting at $5,000. By the end, you receive three practical deliverables that can guide development with any team, including ours:
- A Now / Next / Later roadmap with RICE prioritization scores and clearly defined criteria for deciding when to drop or reconsider a feature.
- An estimate for the first release, based on the agreed scope and technical requirements.
- A technical architecture outlining how the product will be built and how its core components will work together.
A senior tech lead is involved from the first discovery call, ensuring that product decisions are evaluated against technical feasibility from the outset. This matters because a roadmap built without engineering input can overlook implementation complexity, dependencies, and resource constraints, leading to unrealistic timelines and estimates.
AI helps accelerate the research and preparation work that traditionally takes up much of the discovery process. It can organize interview notes, identify recurring patterns, group user feedback into potential product hypotheses, and support the creation of initial feature estimates and prototypes. However, AI-generated insights and recommendations are starting points, not final decisions. Our team, together with the client, validates the findings, evaluates trade-offs, and determines what should make it into the roadmap.
Once the roadmap is defined, the next step is understanding the investment required to bring it to life. Our MVP development cost guide explains the key factors that influence the budget. If you're ready to move forward, explore our startup development services and product validation services.
Ready to turn your idea into a roadmap? Book a discovery call. In 30 minutes we'll tell you honestly whether you need a full discovery phase or whether a single working session will do.
FAQ
What is the difference between a product roadmap and a product backlog?
A roadmap says which problems you'll solve next and why, over three to twelve months. A backlog lists the stories and tasks for the next few sprints. Roadmap items are outcomes; backlog items are pieces of work. One roadmap item usually turns into anywhere from five to thirty backlog items.
How far ahead should a startup product roadmap go?
Before product-market fit, plan six to eight weeks in detail, the next quarter in outline, and anything beyond that as one-line themes. After product-market fit you can stretch the outline to six or twelve months. Anything planned in detail more than three months ahead almost always changes before you get there.
How often should you update a product roadmap?
Check the metrics weekly and review the roadmap monthly. Review it straight away after any big event: a launch, a funding round, losing a key customer or a pivot. Log every change with the date and the reason.
Who owns the product roadmap in an early-stage startup without a product manager?
Usually the CEO, because a roadmap is a strategy document. The CTO or tech lead co-owns the effort estimates and the technical prerequisites. Hire a dedicated product manager once the founder can no longer make the weekly metrics review, which tends to happen somewhere around 10–15 people.



