A product roadmap is a plan that shows what a team intends to build, in roughly what order, and why, organized around themes and time rather than a flat list of tasks. It's the document a team points to when someone asks "what are we working on, and what's next."
Key takeaways
What is a product roadmap?
A product roadmap is a visual plan that lays out a product's direction over time: the themes a team is investing in, the status of each initiative, how it's prioritized, who owns it, and roughly when it will happen. Aha!'s roadmapping guide (opens another site) frames it as the document that keeps a team aligned on what's being built and why. A simple example: a software team might have one roadmap item called "Referral program," tagged under the Growth theme, in the Idea status, prioritized Now, owned by one person, running from December 1 to December 20.
Why does a roadmap matter, and who owns it?
A roadmap gets everyone looking at the same plan. Engineers, designers, sales, and support all need to know what's coming and in what order, and a roadmap is the shared reference that keeps those groups aligned instead of guessing from separate conversations. It also forces prioritization: putting an item on a roadmap means saying which problems come first, and which wait.
Product managers typically own and build the roadmap, since they sit closest to both the strategy and the day-to-day decisions about what ships next. But a roadmap isn't written in isolation: engineering leads weigh in on feasibility and sequencing, design weighs in on scope, and leadership weighs in on strategic fit. Sales and support often read the roadmap without building it, since they need to know what's coming to set customer expectations.
How is a roadmap different from a project plan or a backlog?
These three get confused constantly, but they answer different questions, as Pragmatic Institute (opens another site) and Tempo's planning guide (opens another site) both lay out.
| Document | Answers | Grain | Audience |
|---|---|---|---|
| Roadmap | What are we building and why, roughly when | Themes and initiatives | Whole team, stakeholders |
| Project plan | How will this specific thing get built | Tasks and dependencies | The team doing the work |
| Backlog | What's next to pick up | Individual tickets | Engineers and the PM |
A roadmap sits above both: once an item moves from idea to in-progress on the roadmap, it typically spawns a project plan (for how) and a set of backlog tickets (for what's next in the queue).
What types and formats of roadmaps are there?
By focus, roadmaps tend to fall into a few kinds, as described by Product School (opens another site):
Most teams end up blending these: a roadmap grouped by theme (closer to strategy) but showing status and dates (closer to release).
The same underlying data can also be displayed differently depending on who's looking:
None of these is "the" roadmap format. The same set of items, filtered and grouped differently, serves each one.
What fields go on a roadmap item?
At minimum, every roadmap item needs:
Skip any one of these and the roadmap stops answering a question someone will ask: skip owner, and nobody knows who to follow up with; skip status, and the board view has nothing to group by.
How do status and priority work on a roadmap?
A typical status progression runs: Idea (not yet validated or scoped) → Planned (scoped, scheduled) → In progress (actively being built) → Shipped (live). Keeping this short, four stages rather than ten, keeps the board readable and keeps the team updating it, since a status field nobody bothers to change is worse than no status field.
A simple three-level priority (Now, Next, Later) avoids the trap of ranking forty items 1 through 40, a ranking that's stale within a week. Now means active or about to start; Next means queued, roughly understood; Later means on the radar but not scoped in detail yet.
What does a filled-in roadmap template look like?
Here's a filled-in example, the kind of thing a new roadmap should have six to a dozen rows of before it's useful:
| Item | Theme | Status | Priority | Owner | Start date | Target date |
|---|---|---|---|---|---|---|
| Referral program | Growth | Idea | Now | (name) | Dec 1, 2026 | Dec 20, 2026 |
| Onboarding flow redesign | Growth | Planned | Next | (name) | Jan 5, 2027 | Feb 10, 2027 |
| Automated regression suite | Quality | In progress | Now | (name) | Dec 10, 2026 | Jan 15, 2027 |
| Bug backlog cleanup | Quality | Shipped | Later | (name) | Dec 1, 2026 | Dec 31, 2026 |
| API rate limiting | Platform | Planned | Next | (name) | Feb 1, 2027 | Mar 1, 2027 |
| Multi-region infrastructure | Platform | Idea | Later | (name) | Feb 15, 2027 | Mar 31, 2027 |
Copy this structure, swap in your own items, and you have a working roadmap.
How do you build a roadmap?
How do you keep a roadmap current?
A roadmap that reflects last quarter's priorities is worse than no roadmap, since people make decisions assuming it's accurate. Statuses should move as work moves (idea to planned to in progress to shipped), and dates should get adjusted as estimates firm up. Treat it the same way you'd treat a shared calendar: not a document you write once, but one you open and correct regularly.
Where does it stop working?
A roadmap stops working when it's used as a commitment schedule instead of a direction. Target dates on items in the Idea or Planned stage are estimates, not promises, and a roadmap that gets read as a delivery contract tends to create more conflict than it prevents. It's also not a replacement for a backlog: a roadmap item like "Onboarding flow redesign" still needs to be broken into individual tickets before anyone starts building.
Questions people ask
What goes on a product roadmap?
At minimum, a theme, a status, a priority, an owner, a start date, and a target date for each item, laid out in a view like a table, a board by status, or a timeline by date.
Product roadmap vs backlog: what's the difference?
A roadmap shows the plan and priorities at the initiative level; a backlog is the queue of individual tickets a team pulls from day to day. A roadmap item becomes several backlog tickets once it moves into active work.
How do you build a product roadmap?
Start by listing your themes, set the fields (theme, status, priority, owner, dates), add items with at least rough dates, then build a table, a board by status, and a timeline view so different conversations can use the view that fits them.
How often should a roadmap be updated?
Regularly, not just at planning time: status should change as items move, and dates should shift as estimates become clearer. A roadmap that isn't updated stops being useful within a quarter.
Do it on Probe
Here's what that looks like built in one pass. On Work Studio, a request like "A product roadmap. Each item has a theme (growth, quality, platform), a status (idea, planned, in progress, shipped), a priority (now, next, later), an owner, a start date and a target date. I want a timeline by start and target date called Timeline, a board by status called By status, and a table of every item called All items" produces a proposal card. Clicking Apply creates the database in one step: the fields, plus all three views.

That step cost 26 credits. A second request, asking to add six example roadmap items spanning December 2026 to March 2027 across the themes and statuses, each with a start and target date, filled the database with six rows, each dated and tagged. That step cost 40 credits. Building the database and populating it with six example items came to 66 credits total.

The timeline view plots each item by start and target date, making overlap visible at a glance.

