Use cases

Discover how Dependency Map makes your job easier

Product Owner

Maximize customer impact and keep track of technical dependencies at the same time!

As an agile product owner, you want to deliver the most important features first.

The most common way to prioritize features is through a backlog, where stories are listed by priority.

A backlog is great for keeping track of the implementation order of your stories, but it does not show technical constraints. Sometimes, it is just impossible to finish stories in the preferred priority order.

With Dependency Map, you can see both priorities and technical constraints in the same visualization!

In this Map, stories are grouped by Priority. The arrows are Blocks links – technical dependencies.

 A visualization like this makes it easy to spot potential planning problems.

 The highlighted “Integrated cockpit systems” Story has a lower Priority than the “Passive safety” Story. But the dependency states that “Integrated cockpit systems” has to be completed first!

Adding the Sprint field to the Map provides a great overview of how stories are prioritized in each sprint.

You can move issues directly in the map with a few mouse clicks, so exploring different “what-if” scenarios becomes a breeze!

And because you are modifying the actual Jira issues, your database is kept up to date while you work.

Epic-to-Story and Story-to-Subtask relations makes it easy to see the breakdown of the project.

In this example, color has been mapped to Status, which makes it easy to spot Epics and stories that are at risk! (If you don’t like the default colors it is easy to change them.)

You can include different link types in the same Map.

This example, which uses an ungrouped layout, has both  Epic-to-Story relations (black dashed arrows) and dependencies (thick red arrows).

The colors have been selected to represent Issue Type.

Once a sprint is underway, you want to keep track of progress.

In this example, the top row represent what’s being done in the current sprint (Chassis Sprint 4). As the team finishes tasks, the issues will progress from left to to the right.

Issues at risk are colored red. By selecting them in the map, you can immediately see if any other issues could be affected.

Scrum Master or Team lead

Improve the quality of your sprint planning and stand-up meetings!

As an agile scrum master, ensuring that your team members are aware of dependencies is an important key to get reliable estimates.

Forgetting about an important dependency when planning can have drastic consequences!

And dependencies do not have to be technical, of course! Other examples include team member availability, and deliverables from other teams or external suppliers.

Dependency Map helps you discover and manage dependencies during both planning and standup meetings.

Let’s look at an example!

The black dashed arrows in this map is the Epic-to-Story-to-Subtask breakdown of a project.

The thicker red arrows are the dependencies (Jira’s “Blocks” link, in this case).

The issue colors represent the Issue Type.

Groping Stories by Epic highlights the dependencies between Stories.

Here, dependencies are drawn as black arrows and the colors represent the Priority set by the product owner.

Grouping issues by Assignee and technical Component is a great way to get a feel for who is working on what.

In this example, one person – Erica – is responsible for all Stories in one of the Components (“Shell”).

The dependencies makes it easy to spot risks. If one of the Stories that Erica relies on is delayed, she may end up with nothing to do!

Dependency Map is useful in standup meetings too.

You can move issues to a different row or column with a few mouse clicks, so changing Status or Assignee is lightning quick!

Release Train Engineer or Scrum-of-scrum Master

Large-scale planning and monitoring made easy!

To plan and monitor large-scale projects, you have to collect and integrate data from multiple Jira projects.

Also, frameworks like SaFE or Scaled Agile rely upon views where Epics and Stories can be assigned to different teams and different releases, and where you can find, assess, and manage dependencies between teams and tasks.

The flexibility of Dependency Map greatly simplifies such work!

With Dependency Map, you can create the views you need with a few mouse clicks. In this example, issues are grouped by Sprint and Jira Project.

Moving issues between Sprints can be done directly in the view with a few mouse clicks.

You can group issues by any Jira filed. And if you use Atlassian’s Advanced Roadmaps (formerly Portfolio), you can group by Team and by Initiative too!

Here is the same view, with dependencies (“Blocks” links) added as black arrows. The colors represent Priority.

In a view like this, it becomes easy to spot planning problems.

For example, the highlighted “Geometrical specifications” Epic must be complete before the “Body shell” Epic. But they are planned for release in the same sprint – this may be a cause for concern!

Once your iteration is underway, Dependency Map makes it simple to track progress.

This example shows the Epics and Stories in an ongoing Sprint. The issue icons denote the Issue Type and the colors represent Priority.

There are two types of arrows: the dashed black arrows is the Epic-to-Story breakdown, and the red arrows are the dependencies.

When you select an issue that is at risk, any related issues become highlighted too. This makes it easy to see the impact of potential delays.