How To Build a Product Plan Example or Roadmap
Tags: productivity, programming, agile
Published: 2018-12-10 21:24:14

---
title: How To Build a Product Plan Example or Roadmap
published: true
tags: productivity, programming, agile
canonical_url: https://blog.coda.io/how-to-build-a-product-plan-example-or-roadmap-fe43d3e16d31
---

You have a team of designers, engineers, and product managers who are ready to work on a new product launch. The first thing you might do is consult a product plan or product roadmap. With this product plan example, you can save a lot of time and resources from having to buy expensive software for managing your team’s resource allocation for getting your product out into the market.

![](https://cdn-images-1.medium.com/max/200/1*i6As9W15QplnJa55sXOS-Q.gif)<figcaption>Credit: Tenor</figcaption>

If you want to get started right away with the product plan and roadmap, this is [the template](https://coda.io/t/Product-Roadmap_txK9SyEKNLt?utm_source=coda&utm_medium=blog&utm_campaign=product-plan-blog-post-nov2018) in the Coda gallery. Watch the video below on how to build this product plan from scratch:

{% youtube i0KxFK9tH7w %}

### What Is A Product Plan or Roadmap?

At a high level, a product plan or roadmap does the following:

- Provides the guiding strategy for your product
- Details the work required for your product
- Evaluate how new features and functionality impact planned work

Do a quick Google search for a product plan or roadmap, and you’ll come across platforms and software like the following:

![](https://cdn-images-1.medium.com/max/1024/1*oKFfmrEpZBRFDN1TfSDUmA.png)<figcaption>Credit: <a href="https://www.aha.io">Aha!</a></figcaption>

![](https://cdn-images-1.medium.com/max/1024/1*MXfbO1SlT0hmoCCKIan2KQ.png)<figcaption>Credit: <a href="https://www.productplan.com">ProductPlan</a></figcaption>

![](https://cdn-images-1.medium.com/max/1024/1*j_YwDX12fUR3OgDGsOhUmA.png)<figcaption>Credit: <a href="https://roadmunk.com">Roadmunk</a></figcaption>

If you read my previous post about picking [time-tracking software](https://medium.com/@alchen1/how-to-choose-time-tracking-software-72b861fe3c4c), you’ve probably noticed I prefer to _build_ my applications rather than work within the constraints of a piece of software. Nothing is wrong with purchasing software that does one thing really well, but your product might take twists and turns during the development cycle that your software was not built to handle.

Instead of relying on someone from the software company’s support desk to help you tweak something about the software, let’s see how we could build a product plan or roadmap from scratch in 15 minutes or less in Coda. The 3 main tables we need to build to make this app work are:

1. **People ** — Stores all the people on our team and their roles/skills
2. **Features**  — All the product features we will build
3. **Resource Allocation**  — How our people will be staffed to work on the product features

### Start With Your Team

Before we get into features, resource allocation, and effort, we need to identify who is going to work on this product. This probably means a mix of Engineers, Designers, and Product Managers.

![](https://cdn-images-1.medium.com/max/816/1*YQJuRW4GbGfyYfW_WKKk0w.gif)

In the table above, I have 3 columns: People, Role, and Skills. The People column is a People [column type](https://help.coda.io/organizing-your-doc/formatting-options-for-your-doc/overview-of-column-formats#types-of-column-formats) in Coda allowing you to select all the teammates in your domain. Where does the Role select list that contains the options Engineer, Designer, and Product Manager come from? I created a separate “Team” table that just has those 3 options as the [display column](https://help.coda.io/faq/editing-docs/what-is-the-display-column):

![](https://cdn-images-1.medium.com/max/1024/1*ZWUf_1w4UNkPea297drFNQ.png)

You’ll notice that the People column in the “Team” table contains all the team members from my “People” table correctly assigned to their respective roles. The formula in the People column of the “Team” is:

```
=Lookup(People, Role, thisRow).People
```

This formula does a lookup to the “People” table, finds the rows where the Role in the “People” table matches the current row in the “Team” table, and just brings back the People column. It’s kind of like doing a VLOOKUP in Excel except you can return _multiple values_ from your Lookup table instead just one value. The Skills column in the “People” table let’s you select what skills your teammates are good at, and the values for this select list are determined by a small one-column table called “Skills”:

![](https://cdn-images-1.medium.com/max/710/1*-iFoK3iavft4K2mxJciu7Q.png)

Now that we have the basic tables for our team (“Team”, “People,” and “Skills”), it’s time to build out two more tables: **Features** and **Resource Allocation**. Then we’ll have the tables we need to create our own product roadmap application that is flexible and customizable to our team and product launch.

### Features In Your Product Plan

This is the master list of where your team can store all the specific product features you want to build and launch. Some of the columns we are going to add include:

- Feature
- Description
- Lead (person)
- Start Date
- End Date
- Working Days
- Effort
- Effort Per Day
- Assignees

You don’t need to have all these columns in your final product plan app, but you may find some of these columns useful depending on how you want to track resource allocation for your team. Here is what our final Features table looks like:

![](https://cdn-images-1.medium.com/max/1024/1*WitVM9lm-OyGn2fzw5Z-RA.png)

The Feature and Description columns are in the Text format so you can enter free-form text here. We will revisit the Lead, Effort, Effort per day, and Assignees columns after we talk about our “Resource Allocation” table. A few things to note about the “Features” table:

![](https://cdn-images-1.medium.com/max/515/1*1NkR8zSiedFJ1_nK6gGxFg.gif)

Start and End represent the dates when the features should begin and end working. These columns are in the Date format which opens up the date picker to let you select the appropriate dates for your feature.

Working Days is a table formula that calculates — you guessed it — the number of business days between the Start and End dates. The [NetWorkingDays](https://coda.io/formulas#NetWorkingDays) formula is used to get this number. This is one of my favorite formulas since it excludes weekends from the calculation.

Let’s move on to our final table: **Resource Allocation**.

### Story Points Vs. Hours

This is an [age-old debate](https://www.atlassian.com/agile/project-management/estimation) in the agile world, and we don’t have an opinion on which method you use to estimate work for your team. The great thing about building your own product planning app: _you can pick whatever method of work estimation you want._

Our “Resource Allocation” table should do a few things:

1. Assign a team member to a specific product feature (from our “Features” table)
2. Give you the ability to entire in a work estimate (story points, hours, etc.) for a person
3. Associate feature start dates and end dates for a person working on that feature

As you can imagine, this table is tightly integrated with the “Features” and “People” tables. Here’s what our final “Resource Allocation” table looks like:

![](https://cdn-images-1.medium.com/max/1024/1*wYwqh3b6QGtJ_VEn4wKQgA.png)

This looks like a pretty basic table, but let’s dive into each column to see how this table ties into the “Features” and “People” tables.

![](https://cdn-images-1.medium.com/max/620/1*oQZDC0Rk8LftLxCzNHRB-w.gif)

The Feature column is a [Lookup from table](https://help.coda.io/formulas/using-lookups#how-to-use-lookup-columns) format that connects to the “Features” table. Once you create this column, you can select _any_ of the features in the “Features” table. Want some more context about that specific feature? Just hover your cursor over the feature and you’ll see all the other columns from the “Features” table (e.g. Description, Start, End, etc.)

The Role column is also a lookup but to the “Team” table we created when we created the “People” table. If you recall, the “Team” table also has a People column in it, so we can reference this column by writing the formula =Role.People. We use this formula in the Assignee column here:

![](https://cdn-images-1.medium.com/max/1024/1*22uHoNN462PVKSZgAOsrWw.png)

This means all the team members who have a job title of Engineer in the “Team” table will show up as selectable options in the Assignee dropdown:

![](https://cdn-images-1.medium.com/max/755/1*7666u06Z2LJEo5tZwtlpYg.gif)

Finally, let’s take a closer look at some of the other columns like Effort, Start, and End. Since our first column — the Feature column — is a lookup to the “Features” table, we can also reference other columns from the “Features” table like Total Effort, Start, End, and Working Days simply by starting our formula with =Feature...

![](https://cdn-images-1.medium.com/max/1024/1*GtmngK8bK3AtVdFOjGr8bA.gif)

If we revisit the “Features” table now and look at the Effort column here, you’ll notice it references the “Resource Allocation” table in order to sum up the effort associated for a feature with the following formula:

```
=[Resource Allocation].filter(Feature=thisRow).Effort.Sum()
```

![](https://cdn-images-1.medium.com/max/1024/1*v_fYZoxJZZDILluRT2Mz9A.png)

The Features.Effort column is also used in the “Resource Allocation” table as well (see the previous gif). You just built some pretty complicated logic to enter in effort at the team member level but also have the sum of the effort show up in both tables. If you had to get this same functionality in a spreadsheet, you would have to do a combination of SUMIFand VLOOKUP.

So we’ve built out our 3 main tables, let’s get into the fun stuff of _visualizing_ our data so we can see what features are being staffed by whom, which team members are being over-allocated, and where effort is being distributed among the team.

### Product Feature Roadmap and Timeline

Let’s build a simple view of our “Features” table that hides a few columns so that it only shows the feature name, description, start date, and end date. When you create a [view of a table](https://help.coda.io/organizing-your-doc/setup-best-practices/creating-a-view#why-views-matter), it’s like creating a copy of that table but all changes you make in the view also carries over into the table as well.

![](https://cdn-images-1.medium.com/max/1024/1*Gs3hAjcRygFjP6NnikWMMw.gif)

While this view of the “Features” table looks ok, it would be a lot more useful if we could see a waterfall or timeline of how these features stack against each other. If we insert a gantt chart, Coda automatically looks at your start and end dates to build out the gantt chart:

![](https://cdn-images-1.medium.com/max/1024/1*phDDwAPOh8VofC9MwOr31w.gif)

You’ll notice that when you move the bars in the gantt chart, it also changes the dates in the “Main Features” _view_. This is a core concept in Coda where all your data — regardless if it’s in a table or chart — are connected.

### Assigning Work and Estimating Effort

Now that you see how we can build views off of tables, let’s build a view off of the “Resource Allocation” table. With this view, we can group by the Feature column to quickly see the team members working on each feature in an organized way. If we change the number in the Effort column of our _view_, it changes it in the master “Resource Allocation” _table_ as well.

![](https://cdn-images-1.medium.com/max/1024/1*ZOUgK2Wi-08kDCuiGNPcsA.gif)

### Resource Utilization by Person

Nothing is worst than a team member who is overloaded, so being able to see utilization by team member can help you balance the load. The chart below is a view of your “Resource Allocation” table but the _layout_ is a stacked bar chart. You can quickly see who is being overloaded based on the total Effort that team member has:

![](https://cdn-images-1.medium.com/max/1024/1*4Ym0A6QhOF_GYGSAtXXsIw.gif)

Perhaps you still want to see how your team is being resourced in a table format, so you can build a view for that. One of my favorite layouts is the gantt chart broken down by person, so now you see a timeline by person but you can drill down into the features that person is working on as well:

![](https://cdn-images-1.medium.com/max/1024/1*ES_rkjK2oadfly_oCjGJ9A.gif)

### Resource Utilization by Feature

Since we have our “Resource Allocation” master table built out, we can view our data in many ways. This is similar to how PivotTables work in Excel. In this view, we see a timeline/gantt chart broken out by features, but once we drill down we see the _team members_ associated with that task. This like the reverse of the gantt chart you see in the previous gif:

![](https://cdn-images-1.medium.com/max/1024/1*QM6gzh6EjaqJc1h9X4HpyQ.gif)

### Resource Utilization by Team

Finally, a really useful view of our “Resource Allocation” table is grouping data by Teams. Since we have entered all the Effort for a team member and we have mapped team members to teams, we can get a bird’s eye view of the total estimated effort by Team:

![](https://cdn-images-1.medium.com/max/1024/1*8eBeIwmjI1ityDhSG3qO6A.png)

If you recall our original “Team” table, it only had two columns: Team and People. There are actually a few columns hidden in that table, so the view below, we _unhide_ the Total Effort and Avg effort / person columns to see the total hours or story points each team has:

![](https://cdn-images-1.medium.com/max/780/1*hkmNkbzSJVYgal3DNsqTMw.png)

The Avg effort / person is a formula that takes the Total Effort and divides it by the number of people in each team (represented by a hidden [Num People] column. Now we can see that the Engineering team is clearly the team that is adding the most effort to this product launch.

![](https://cdn-images-1.medium.com/max/1024/1*TqfcuGIo6CfDm4Eh7iiT0w.png)

### Final Thoughts

Building your own product roadmap in Excel or Google Sheets can get complicated as your team grows and the features you need require extra customizations. On the flip side, if you buy a specialized piece of software to manage product planning or product roadmapping, you are constrained to that software’s own feature set.

By building your own application that looks and feels like a real product roadmap software (without needing to be a programmer), you can get the best of both worlds.

> Find freedom on the canvas. — Bob Ross

* * *