Dependencies in project management do not need to be your bane. Yes, they require proper product planning to reduce the risk of any issues. Especially when they go beyond the boundaries of your project pushing your focus to other initiatives. But armed with Jira project management tools, it is not like you cannot handle it.
Today, we will explore how you can use those Issue Links for creating and managing cross-project dependencies. Then, we will move on to Jira’s extended capabilities with BigPicture and BigGantt project management software. We will show you how you can use their features to create Jira cross-project dependencies and make their management easy and efficient.
Today, we will cover:
- What are cross-project dependencies?
- Using Jira Issue Links for linking cross-project task dependencies
- Managing Jira cross-project dependencies
- Best practices for handling cross-project dependencies
What are cross-project dependencies?
A cross-project dependency means a relationship between two or more projects. Specifically, it indicates that one task relies on another from a different project to start or finish.
You can use cross-project dependencies in several ways to ensure your project runs as it should. For instance, when you want to:
- Set a date for a task from Project A to start only after the Project B task starts or finishes. Such a relationship will help you ensure that the features or resources necessary for completing a task are available.
- Know about changes in task dates of a dependent task from another project. This will let you assess the impact of such a change on the dependent tasks in your project.
- Immediately reschedule the period of a task in your project that will be impacted by dependent tasks from another project. An up-to-date schedule ensures your team starts working on a given task at the right time.
Difference between cross-project dependency and inter-project dependency
A cross-project dependency is about the relationship between tasks (start/end) that belong to different projects. On the other hand, an inter-project dependency relies on a project’s deliverables. In other words, a task in Project A depends on a deliverable in Project B (as opposed to a start/end date) before it can start or finish.
Jira Issue Links for linking cross-project task dependencies
In Jira, there are no dependency links. But there are Issue Links that you can use to link tasks from different projects to indicate that one task depends on another. There are two default Jira Issue Links types that could serve as dependency link. Those are:
- Blocked: blocks / is blocked by
- Relates: relates to / relates to
How do Blocked and Relates Issue Links work?
Imagine you have two issues: A and B, and you want to indicate that issue A depends on issue B. By linking A and B with the “Blocked” Issue Link type, issue B becomes the “blocker” (issue B blocks issue A). Whereas issue A is blocked by issue B. It means that until you change the status of issue B to “Done,” issue A cannot transition (start or finish).
Similarly, you could use the “Relates” link to indicate some sort of connection between two issues. But neither of these two links will tell you how two issues relate to each other (i.e., which one is supposed to start or finish first). That is because all they say are “relates” and “blocks.” So while you could use Jira Issue Links to link tasks from different projects, without proper descriptions, they are not very informative.
Furthermore, Issue Links in Jira are simply labels. So even if you link two issues together using any of the Issue Links available in Jira (including custom ones), none of them will prevent tasks from transitioning. In other words, if issue B is supposed to block issue A, issue A will start or finish anyway—an Issue Link will not stop them from doing so.
How to create cross-project Issue Links in Jira?
You create cross-project links exactly the same as you would create an Issue Link between issues that belong to the same project. You navigate to the issue you want to link, select an Issue Link type, and search for the target task by its key (e.g., OA-66).
You can link any issue to others as long as you have permission to view the issues in other projects.
How to track cross-project Issue Links in Jira?
Since plain Jira does not visualize Issue Links on project boards (or anywhere else for that matter), you will not be able to view cross-project dependant tasks. But there are a few “hacks” you could try that would allow you to look up and follow up on interdependent tasks across projects.
Jira issues filtering plugin
A simple Jira plugin could help you filter Project A issues with a certain Issue Link type. And then use those results to see the issues from the other projects.
Two separate task boards
You can create separate boards for each project with at least one dependent task. To elaborate on this, let’s assume you have two classic projects running. For the first project, you create a regular issue board and set filters on this board to apply only to issues from that project. You create a “cross-project” board for the second project that would hold dependent issues from other projects. To make it work, you will need to configure filters on this board in the following way:
project = MYPRJ or labels = MYPRJ ORDER BY Rank ASC
As a result, if any task from another project has a label matching the project key of the project they depend on, it will appear on the “cross-project” board.
Issue workflows
You can prevent your issues from transitioning (e.g., you do not want one issue to start before the other) by configuring your issue workflows. On top of that, with a Jira plugin providing conditions, validators, and post-functions for your workflow, you would be able to disable a transition as long as there is a blocking linked issue. Such a solution would reduce the need for a manual status update for each issue.
As you can imagine, these “hack” methods are ineffective practices in Jira and could cause some problems in the long run. That is why let’s consider a more practical method: extending Jira with dedicated project management plugins.
How to manage Jira cross-project dependencies with BigPicture and BigGantt
BigPicture is a PPM software that allows you to create and manage a variety of complex projects along with their dependent tasks (issues). It supports classic, agile, and hybrid projects. The BigGantt app, on the other hand, is geared more toward classic project management (although using the Gantt chart in Agile is also possible). This tool comes with various features that make cross-project dependency management a breeze.
(If you are not ready to start the 30-day trial yet, we encourage you to visit the demo page, where you can try all the BigPicture features. The demo app runs inside the browser, so you do not need to install anything or create an account).
Jira Issue Links as cross-project dependencies
BigPicture and BigGantt integrate seamlessly with Jira. Thanks to this, all the Jira Issue Links you have created for your project will not go to waste. When you create a dependency link in BigPicture, the respective link will also appear in Jira—and the other way round.
Consequently, when you install BigPicture (or BigGantt), the app will create Soft and Strong links (Start to Finish; Start to Start; Finish to Finish; Finish to Start) in your Jira. You will also see your default and custom Jira Issue Links in BigPicture. This way, you can easily map your Issue Links to the Soft or Strong dependencies.
Related: BigPicture Tutorial – How to use links? (video)
Customizing default dependency settings
By default, the “Blocks” Jira link will become a Soft link in BigPicture (or BigGantt). Whereas the Strong links are unassigned.
It means that, initially, you will have no Strong dependencies in your project (because the BigPicture and BigGantt apps do not know yet which Jira links should impact your schedule). That is why, if you want to have real dependencies between your Jira Issues, you can do it in two ways:
- Customize dependency settings in the App Configuration. Select which Jira Issue Link you want to be Start to Finish, Start to Start or any other Strong type. Please keep in mind that Strong link mapping is a 1:1 process. It means that you can set 1 Jira Issue Link to 1 Strong dependency type. For example, you could map the “Relates” link to the “End to Start” dependency (take a look at the screenshot below).
- Leave default settings as they are and create Strong dependencies between individual tasks manually (more on it in the next section).
How to create Jira cross-project dependencies
In BigGantt and BigPicture apps, you can link issues/tasks (as well as other items, like milestones) from different projects. You can also build an external link to connect two dependent items within the scope of different Templates.
Issue-Key method
Here, you simply create dependencies from within your project by pointing to the task that belongs to another project. To do this, hover over the task you want to link (either on a Gantt chart or Agile/Kanban board) to prompt a little dot to appear on the right side next to the task.
When you click it, a window will appear where you provide the issue key of the task you want to cross-link. At this point, you can specify the dependency link you want to create (Strong or Soft).
Drag-and-drop method
Following the same procedure, you click on the dot on Task A and drag an arrow to Task B. In this case, however, you need to have tasks from yours and other projects (or boxes) available on your board or Gantt chart.
See also: Creating dependencies on a Gantt chart (documentation)
Tracking cross-project dependencies
You can look up your cross-project dependencies the same way as you would with dependencies from the same project.
First, you have the Infobar at your disposal, located on the right hand-site. It will list all the dependencies and group them by their type (Soft and Strong).
Second, for a more comprehensive and high-level overview, you can generate two reports using the Reports module (available in BigPicture only): the Dependencies report and the Cross-Team Dependencies report.
The difference between both reports is that the Cross-Team report shows parent-child dependencies but not between tasks of the same team (you will find it in the Dependencies report). Whereas the Dependency report does not include parent-child dependencies.
Finally, you can use BigPicture’s enhanced JQL (Jira Query Language) to find the specific dependency links.
Cross-project dependencies: best practices
Here are some best practices for creating and managing cross-project dependencies.
Share with stakeholders
You should always keep your stakeholders up-to-date. You can communicate how the project is moving on and what dependencies you currently face through the project charter. Or, if you are using BigGantt, you can share a view of your project so they can see what you see.
Use cross-project dependencies sparingly
Cross-project dependencies can be beneficial, but you still may want to have as few as possible. That is because each dependency adds a certain amount of complexity to your scheduling. Not to mention that fewer dependencies are easier to manage.
Avoid linking summary tasks
A summary task summarizes a set of activities. According to the work breakdown structure hierarchy, summary tasks are work packages (WBS level 2). Since it is a roll-up of tasks rather than a single activity, you should not add dependency links to them. Neither within your project nor across another project. Otherwise, you risk creating circular dependencies and skewing critical path calculations.
However, if you want to create such a dependency for any reason, BigPicture will not prevent you from doing so.
Be careful with deleting dependent tasks
Before you delete any project or task, check whether any cross-project dependencies are hooked up to them. Unlink dependencies first and only then delete your project or task.
Use only one cross-project dependency direction
Link your projects in only one direction, meaning that you either link project A to project B or project B to project A. Linking two projects in both directions will cause a circular reference that could result in a difficult to deconstruct error. (If that happens, the BigPicture app will prompt an error.)
Pick early tasks from the successor project
Whenever possible, link tasks that occur early in the successor project schedule. This will help you reduce the need for cross-project dependencies.
