Product Roadmap Template + AI Prompts: Build One in 15 Minutes

Most roadmaps die the same way. You build one in a planning offsite, it looks great on the slide, and three weeks later it's a feature list nobody connects back to strategy. By mid-quarter it's stale. By the time someone asks "why are we building this?", the answer lives in a meeting that happened two months ago.

The problem isn't that PMs don't know how to build roadmaps. It's that the format itself encourages the failure. Spreadsheets capture features, not outcomes. Roadmap tools capture timelines, not the strategic objective each item serves. Both go stale because keeping them fresh is manual work nobody has time for.

A good template fixes the structure: every item links to an objective, and you measure outcomes, not outputs. AI fixes the labor: drafting, pressure-testing, and refreshing the roadmap take minutes instead of days. This article gives you both. The template, the prompts, and the skill that runs the whole thing against your context.

Spreadsheet vs. Tool vs. Skill

The format you choose shapes whether your roadmap stays connected to strategy or drifts into a backlog with dates attached.

The spreadsheet is free and flexible, which is exactly why it drifts. The tool enforces a format but charges per seat and still leans on you to link work to strategy. The skill reads your goals and personas from your context files, so the strategic linkage is built in. It isn't a field you have to remember to fill.

The Product Roadmap Template

This is an outcome-based Now/Next/Later roadmap. The structure forces two things most roadmaps skip: every initiative links to a strategic objective, and every initiative names the product outcome you'll measure — not just the feature you'll ship.

Copy this into your doc and fill it in.

# [Product] Roadmap — [Quarter / Half / Year]

Strategic Objectives

List the 2-4 business objectives this roadmap serves. Everything below maps to one of these. If an initiative doesn't map, it goes in the Parking Lot.

1. [Objective] — e.g. "Increase NRR to 120%"
2. [Objective] — e.g. "Win the agency vertical"
3. [Objective] — e.g. "Reduce time-to-first-value"

NOW (this quarter — committed)

[Initiative name]

• Objective: [Which strategic objective above this serves]
• Outcome we'll measure: [Leading product metric — e.g. "cut onboarding from 14 days to 3"], not the feature shipped
• Why now: [Business driver — revenue, deal, competitive pressure]
• Dependencies: [What must land first]
• Confidence: [High / Medium / Low]

[Initiative name]

• Objective:
• Outcome we'll measure:
• Why now:
• Dependencies:
• Confidence:

NEXT (next quarter — planned, not committed)

[Initiative name]

• Objective:
• Outcome we'll measure:
• Open question: [What we need to learn before committing]

LATER (directional — themes, not features)

• [Theme] → serves [Objective] — [why it matters, no dates yet]
• [Theme] → serves [Objective] — [why it matters, no dates yet]

Parking Lot (explicitly deferred)

Ideas we're consciously NOT doing, and why. This is the most honest section of any roadmap.

• [Idea] — deferred because [reason]
• [Idea] — deferred because [reason]

The Parking Lot is the section most teams skip and the one executives trust most. It proves you made choices instead of saying yes to everything.

### Prompts to Draft and Pressure-Test It

These four prompts work in Claude.ai or Claude Code. Each one carries the same rule: tie every item to an objective, and flag anything that's an output, not an outcome.

**1. Draft the roadmap**

Here's my strategic context and the initiatives I'm considering this quarter:

Strategic objectives: [paste 2-4 business objectives]

Initiatives under consideration: [list features, projects, bets]

Team capacity / constraints: [team size, known dependencies, hard deadlines]

Build a Now/Next/Later roadmap using this rule: tie every item to one of the objectives above. For each item, name the product OUTCOME we'd measure, not the feature we'd ship. Flag any item that's an output (a thing we build) rather than an outcome (a change we cause). Put anything that doesn't map to an objective in a Parking Lot with the reason it's deferred.

**2. Pressure-test the strategy linkage**

Here's my draft roadmap: [paste roadmap]

Audit it against my objectives: [paste objectives]

For each Now and Next item:

• Which objective does it actually serve? If the link is weak, say so.
• Is the "outcome" really an outcome, or is it a disguised output? Rewrite any output as the outcome it's meant to drive.
• Which item has the weakest justification for being in NOW?

Be direct. I'd rather cut an item now than defend it to my exec team in three weeks.

**3. Sequence and find dependencies**

Here's my Now/Next/Later roadmap: [paste roadmap]

Map the dependencies:

• Which initiatives must land before others can start?
• Where am I over-committing the team in a single quarter?
• What's the riskiest sequencing assumption I'm making?

Then propose a revised order. Keep every item tied to its objective — don't let sequencing quietly drop the strategic link.

**4. Write the executive version**

Turn this roadmap into a 1-page exec summary: [paste roadmap]

For each strategic objective, show the initiatives serving it and the outcome each will move. Lead with the "why," not the feature names. End with the Parking Lot so leadership sees what we chose NOT to do. Flag any item where the outcome is actually an output I should rethink before this goes in front of the board.

---

## Build Your Roadmap in 15 Minutes

Each step here is a discrete move. Run them in order and you'll have a roadmap that survives the "why are we building this?" question.

1. **List your strategic objectives.** Write the 2-4 business objectives this roadmap serves. If you can't name them, stop and align on strategy first. A roadmap can't fix a missing strategy.
2. **Dump every initiative under consideration.** Features, projects, bets, requests. Don't filter yet. You're capturing the raw set so you can make deliberate cuts.
3. **Map each initiative to an objective.** Anything that doesn't map goes straight to the Parking Lot. This is where most of the value is, because the mapping forces the cuts.
4. **Convert features into outcomes.** For each Now item, replace "ship X" with the product metric X will move. If you can't name the metric, you don't yet understand why you're building it.
5. **Sort into Now / Next / Later.** Now is committed. Next is planned but not promised. Later is directional themes, no dates.
6. **Flag dependencies and confidence.** Note what must land first and how sure you are. Low-confidence items in Now are a warning sign.
7. **Run the pressure-test prompt** (prompt #2 above) to catch weak strategy links and disguised outputs before anyone else does.

<div class="callout-example">

**Related** — [Claude Prompts for Product Managers: 30 That Actually Work](/learn/claude-prompts-for-product-managers) includes prompts for OKR drafting and RICE prioritization that feed directly into this roadmap. [AI PM Workflows: Discovery, PRDs, and Roadmaps in Claude](/learn/ai-pm-workflows) shows how roadmapping connects to the rest of your planning cycle.

</div>

---

## From Template to a Roadmap Skill

The template and prompts work today. But you're still doing the setup every time: pasting objectives, restating constraints, reminding Claude what your product does. That setup is the part a skill removes.

`/roadmap-builder` reads your goals and strategic priorities straight from your context files — including `goals.md`, where your current-quarter objectives, revenue targets, and key dates live. It doesn't ask you to restate your strategy because it already has it. It maps every initiative to an objective, converts features into measurable outcomes, sorts into Now/Next/Later, and flags dependencies — the same structure as the template above, generated in about 15 minutes against your real context.

The difference is freshness. When your goals change, you update `goals.md` and re-run the skill. The roadmap stays current because the strategy and the roadmap share one source of truth instead of drifting apart in separate documents.

To set up the context files that make this work, start with [How to Use Claude as a Product Manager](/learn/how-to-use-claude-as-a-product-manager). To see how roadmapping chains into discovery, OKRs, and specs, read [AI PM Workflows](/learn/ai-pm-workflows).

[Download the Roadmap Builder free →](/skills/roadmap-builder)

Once the roadmap is live, `/strategic-roadmap-review` stress-tests it and `/quarterly-planning-template` keeps each planning cycle on rails.

If you want the full system — context files, skills, and workflows running together — mySecond is $39/mo with a 14-day free trial, cancel anytime. [See pricing →](/pricing)

---

## FAQ

**What's the difference between a Now/Next/Later roadmap and a timeline roadmap?**

A timeline roadmap commits to dates for everything, which sets you up to miss them. Now/Next/Later commits to sequence and confidence instead: Now is this quarter and committed, Next is planned but not promised, Later is directional. It's honest about certainty. You're confident about this quarter and fuzzier about six months out, so the format should say so.

**How do I make my roadmap link to strategy instead of being a feature list?**

Add one rule and enforce it: every initiative maps to a named strategic objective, and anything that doesn't map goes in the Parking Lot. The `/roadmap-builder` skill enforces this automatically by reading your objectives from `goals.md`, but you can do it manually with the template above — the template's "Objective" field on every item is what forces the discipline.

**Can I build a product roadmap with AI in one prompt?**

You can draft one in a single prompt, but the strong roadmaps come from two passes: one to draft, one to pressure-test. The draft gets the structure down; the pressure-test catches weak strategy links and features masquerading as outcomes. Use prompts #1 and #2 above as that pair.

**How often should I update my roadmap?**

Review it at least monthly and re-baseline every quarter — roadmaps drift the moment strategy shifts or a major initiative changes scope. The advantage of a skill-generated roadmap is that re-running it takes minutes: update your goals, regenerate, and the roadmap reflects the new reality instead of slowly going stale.

---

## About the Author

Ron Yang is the founder of mySecond — he builds and manages PM Operating Systems for product teams. Prior to mySecond, he led product at Aha! and is a product advisor to 25+ companies.

[Browse the skills directory →](/skills)

[Set up Claude Code for PM work →](/learn/claude-code-for-pms-setup-guide)