Open Source Roadmap: Template, Tools and How to Present It

9 min read ยท 2026-10-31

An open source roadmap is a public plan for an open source project. It shows the themes, features and releases the maintainers intend to work on, and it usually sits on GitHub next to the code. Some people use the same term for open source software you can host yourself to plan a roadmap, such as OpenProject or Redmine.

This guide covers both meanings, because most teams need a plan and a place to keep it. First comes a six phase template that takes a project from a pile of issues to a published roadmap. After that, a comparison of the tools, a rule for dates, and a five slide format for managers or clients who never open GitHub.

The roadmap at a glance

Goal: Publish an open source roadmap that contributors can act on and leadership can understand, and keep it current. Duration: 8 weeks to publish, then ongoing reviews

  1. Audit and Scope (Weeks 1 to 2)

    Get a clear picture of what the project is and what it has already promised.

    • Write a short scope statement that says what the project does and what it will not do.
    • Export the open issues, pull requests and milestones, and tag anything that was promised publicly.
    • Name one roadmap owner who handles updates, even if decisions stay shared.
    • Pick the roadmap type: features, releases, technology, or work that isn't code, like docs and community.

    Milestone: The maintainers approve a one page scope statement and a single list of open commitments.

  2. Gather Input (Weeks 2 to 4)

    Collect demand from users, contributors and sponsors before you rank anything.

    • Open a discussion thread that asks for priorities, with a clear closing date.
    • Group feature requests by the problem they solve, not by who asked.
    • Talk to the companies or teams that run the project in production.
    • List the technical debt and security work the project needs, even though users never ask for it.

    Milestone: A grouped list of candidate themes, with each theme linked to the issues behind it.

  3. Prioritize Into Themes (Weeks 4 to 6)

    Turn the requests into a short, ranked set of themes.

    • Score each theme on user impact, maintenance cost and how many contributors are available.
    • Send niche requests to plugins or separate packages instead of the core.
    • Split the themes into Now, Next and Later.
    • Write down what is out of scope, and why.

    Milestone: The maintainers agree on a ranked theme list with three horizons in a recorded meeting.

  4. Publish (Weeks 6 to 7)

    Put the roadmap where contributors already work.

    • Create a ROADMAP.md file or a GitHub Projects board, and link every item to an issue.
    • Add a header that says dates are intentions, not commitments.
    • Explain how to propose a feature and how items move between columns.
    • Announce the roadmap in your forum, your chat and your release notes.

    Milestone: A public roadmap page where every item links to a tracked issue.

  5. Present to Stakeholders (Week 8)

    Translate the roadmap for people who will never read the issues.

    • Build a short deck: the goal, three themes, what ships next, the risks and what you need.
    • Replace issue numbers with outcomes in plain words.
    • Show dependencies on other projects or teams.
    • Ask for one specific decision, such as funding, people or a priority call.

    Milestone: Leadership or sponsors confirm the priorities, or ask for a change that gets written down.

  6. Maintain (Ongoing)

    Keep the roadmap honest so people keep trusting it.

    • Triage new issues every two weeks.
    • Refresh the Now, Next and Later columns after each release.
    • Keep a log of roadmap changes, with a one line reason for each.
    • Review the whole roadmap once a year.

    Milestone: The roadmap shows a recent "last updated" date, and no finished item is still listed as planned.

Open Source Roadmap: Two Meanings, One Decision

People who search for an open source roadmap usually want one of two things. Maintainers and product managers want to build and publish the roadmap of an open source project. Teams on a budget want an open source roadmap planner they can host themselves instead of paying for a tool.

In practice, the two meet. A maintainer needs somewhere to publish the plan. A company that uses an open source tool still needs a method to fill it.

So start by deciding who reads the roadmap. Contributors need issue links and a clear scope. Managers and clients need outcomes, timing and risks. One source of truth can serve both if you add a summary view on top.

Which Format to Use for a Public Roadmap

The CNCF contributor guide on open source roadmaps lists four types: feature roadmaps, release roadmaps, technology roadmaps and roadmaps for projects that aren't code. The type you pick decides the format.

Many projects combine formats: a ROADMAP.md explains the themes and links to a board that shows live status. OpenSearch is a good example of the board approach. Its announcement on the OpenSearch blog says the roadmap lives on a GitHub Projects board, each item links to a GitHub issue, and bug fixes are left out so the roadmap stays about new features and improvements.

  • Markdown file (ROADMAP.md): simple, versioned with the code and easy to review in pull requests. Best for small projects with a few themes.
  • Milestones: tie issues to a release. Best when the roadmap is mostly "what goes into the next version."
  • Project board: columns or a timeline linked to issues. Best when many contributors pick up work and need to see status quickly.
  • Themes (Now, Next, Later): group work by intent instead of by date. Best when capacity is uncertain, which describes most volunteer projects.

Should a Public Roadmap Have Dates?

Yes, with a clear warning at the top. OpenSearch says on its blog that "dates and milestones reflect intentions rather than firm commitments," and that releases coming soon get more detail than distant ones. OpenProject's public roadmap page also warns that the timeline and feature set are subject to change.

A simple rule works for most projects, shown below. When a date slips, update it and write the reason in the change log. A roadmap that changes in the open keeps more trust than one that quietly drifts.

  • Now: give a release date or a month.
  • Next: give a quarter.
  • Later: give no date.

Open Source Roadmap Tools Compared

If you want an open source roadmap planner, compare the options against how your team actually works. The facts below come from each tool's official site or documentation.

Verdict. If your code is on GitHub, put the public roadmap in GitHub Projects. Contributors are already there, and every item can point to an issue. If your company needs a self hosted planner that is built around releases, choose OpenProject or Redmine. Choose Taiga if your team works in sprints, and Plane if you want a newer issue tracker on your own servers.

  • OpenProject: self managed or cloud, with a free Community edition and paid Enterprise plans. Version boards, timelines and Git or SVN integration. Best for teams that want classic project management with release planning.
  • Redmine: self hosted under the GPL v2 license. A built in Roadmap view based on versions, plus a Gantt chart. Best for teams that already work by version numbers.
  • Taiga: open source, self hosted or cloud. Epics with Scrum and Kanban boards. Best for teams that plan by sprint and use epics as themes.
  • Plane: self hosted or Plane Cloud, under the AGPL v3 license. Cycles for sprints and Modules to break up large projects. Best for software teams that want a modern tracker they host themselves.
  • GitHub Projects: hosted by GitHub and not open source itself. Table, board and roadmap layouts linked to issues and pull requests. Best for the public roadmap of a project whose code is already on GitHub.

Three Questions Before You Switch Tools

Before you move the roadmap to a new tool, answer these three questions. Issue trackers are built for running the work. Leadership usually needs a one page picture of phases and milestones, so plan to export that view or redraw it.

  • Who hosts and maintains it? Self hosting means servers, backups and upgrades.
  • Who can see it? Check whether people outside the team can read it without an account.
  • Can you get a clean visual? A presentation needs phases and milestones on one page, not a list of tickets.

How to Present an Open Source Roadmap to Leadership

A roadmap can be accurate on GitHub and still fall flat in a steering meeting, because it reads like a list of tickets. Rebuild it for the people in the room with five slides.

Keep issue numbers in an appendix. If a manager asks "when?", answer with the horizon and how confident you are, not a promised day.

  • Slide 1, Goal: what the project should achieve this year, in one sentence.
  • Slide 2, Themes: three themes across Now, Next and Later, with the outcome of each.
  • Slide 3, Next release: what ships, roughly when, and who it helps.
  • Slide 4, Risks and dependencies: maintainer capacity, upstream projects and security work.
  • Slide 5, The ask: the one decision you need.

Keeping the Roadmap Current

The CNCF guide calls roadmaps "living documents" and recommends updating them with new information and community feedback. It suggests issue triage and grooming every two weeks in community meetings, workshops about every six weeks while the project is young, and a yearly roadmap review. Most projects can keep that pace.

Give the roadmap an owner, a "last updated" date at the top and a short change log. After each release, move finished items to Done instead of deleting them, so readers can see that the project delivers. When a sponsor or a large user asks for something big, send it through the same process as everyone else and record the decision.

Common mistakes to avoid

  • Publishing a wish list of every request; rank the themes and list what is out of scope.
  • Promising exact dates for distant work; date only the near term and say that dates are intentions.
  • Listing items with no issue behind them; link every item to a tracked issue that contributors can pick up.
  • Letting the roadmap go stale; triage every two weeks and refresh it after each release.
  • Showing leadership the raw issue board; present a five slide summary built on outcomes.
  • Moving to a self hosted tool with no owner; make someone responsible for hosting, upgrades and backups before you migrate.

Frequently asked questions

How do you start an open source roadmap?

Write a scope statement, collect the open issues and promises, and group the requests into themes. Rank the themes into Now, Next and Later. Publish them in a ROADMAP.md or a project board, link each item to an issue, and add a note that dates are intentions.

What is the best open source roadmap planner?

It depends on how you work. OpenProject and Redmine fit planning by release, Taiga fits teams that work in sprints, and Plane fits software teams that want a modern tracker they host themselves. If your code is already on GitHub, GitHub Projects is usually the simplest place for a public roadmap, but it is not open source itself.

Should an open source roadmap include dates?

Only for the near term. Give months for what is in progress, quarters for what comes next, and no dates for later work. Put a note at the top that says dates are intentions, not commitments.

How often should an open source roadmap be updated?

Triage new issues every two weeks, refresh the columns after each release, and review the whole roadmap once a year. Show the last updated date at the top so readers know the plan is still current.

What should an open source roadmap include?

The project scope, themes or features grouped by horizon or release, a link to the issue behind each item, a note on how dates work, and a clear way to propose new ideas. Include work that isn't code too, such as documentation, security and contributor onboarding.

Generate this roadmap with AI