nav[aria-label="Primary Navigation"] { padding: 0; & ul { list-style: none; width: 100%; display: flex; flex-direction: row; justify-content: start; align-items: start; gap: 30px; padding: 0; & li { margin: 0; } & ul li { list-style: none; } } }

How do you manage task dependencies across multiple development stages in Jira?

Alexander

Hi everyone!

Excited to join the community and looking forward to learning from your experiences.

In our team, we're trying to build a roadmap that shows not just individual tasks, but also the dependencies between them across different stages of development.

For example:
Task A (one team) → blocks → Task B (another team)

Multiple tasks might be waiting on a single epic to be completed.

We need to see:
- A timeline view with dependency lines/arrows between tasks
- Ability to drag and adjust tasks and have dependencies update automatically
- Critical path identification so we know what's blocking what

We're currently using Jira's built-in issue links, but the visualization is lacking. Does anyone know a plugin that handles dependencies well on a roadmap/timeline view?

Accepted answers

All comments

Mary from Planyway

Hi Alexander,

Jira’s built-in issue linking does allow teams to store dependencies (for example, blocks / is blocked by, relates to, duplicates), but Jira does not provide a strong native dependency visualization experience in standard issue views. Advanced Roadmaps adds dependency mapping on a timeline, but it is available only in Premium/Enterprise plans and is designed more for portfolio planning than lightweight cross-team execution.

Speaking of plugins with day-to-day dependency management, you can check out Planyway. It's a cross-team/cross-project planning app that allows you to create dependencies directly on the timeline by dragging from one task to another, and the relationships are visualized with arrows. If dependent tasks overlap, Planyway highlights the conflict so you can spot potential scheduling issues earlier.

Снимок экрана 2026-07-22 в 10.00.47.png

These dependencies sync back to Jira as standard “blocks / is blocked by” issue links, so you’re not creating a separate dependency system. You can also turn dependency visibility on or off depending on how much detail you want to see.

Hope it helps.

Best,
Mary from Planyway.

Tomislav Tobijas

Hi @Alexander ,

Have you explored Jira Plans? You can do a lot with those but they won't cover all of the requirements you've listed here.

For example, you'll be able to get two things (from 3 listed) here:

Timeline view with dependency lines	Critical path identification

As for the third thing:

...Ability to drag and adjust tasks and have dependencies update automatically...

Unfortunately, Plans are still not a Gantt chart. For Gantt views that do support this, you'll have to use the Marketplace app.

However, you could build an automation flow which would automatically move the start/due date on the linked work item, but as Plan is actually a sandbox, these won't be updated until you 'publish changes'.

There are a couple of feature requests that would cover this part:

All in all, plans are a really cool feature and specific users could really benefit from it (in my opinion).

Cheers,
Tobi

Joshua Brock _ Seibert Group_ GmbH

Greetings @Alexander , and welcome to the Community!

For a lightweight fix within native Jira: the dependency direction you're describing (Task A blocks Task B, possibly across projects) stores fine as an issue link, but as Mary and Tobi already noted, the built-in Timeline view won't draw those as visual dependency arrows unless you're on Advanced Roadmaps/Plans (Premium/Enterprise) and even there it's built more for portfolio planning than day-to-day cross-team execution.

As others have already mentioned, there are native Jira capabilities and Marketplace apps that can help with timeline-based dependency management, depending on how complex your planning needs are.

If your dependencies are less "two tasks on a timeline" and more "several teams committing to interdependent epics/features every planning cycle," that's a different category of problem, and it's worth checking whether a SAFe-style planning layer would serve you better than a scheduling app.

If you're open to a Marketplace app in that space, Agile Hive is built around exactly this:

A Program Board that visualizes dependencies and blockers across every team on your Agile Release Train, not just within one project
Automated detection and visualization of cross-team dependencies as work items change, instead of a diagram someone has to update by hand
Risk tracking (ROAM) so blocked or at-risk work is flagged before it derails a Planning Interval
ART and team reports comparing planned work against capacity, so dependency conflicts surface at planning time instead of mid-sprint

Agile Hive _ Dependency Management.png

One caveat: this is aimed at multi-team, Planning-Interval-based cadences (SAFe-style). If your dependencies are within a single team or a handful of related tasks rather than a recurring cross-team planning problem, Planyway or native Advanced Roadmaps is probably the more proportionate fix.

You can find more information at our website.

And in full disclosure, I work at Seibert Group GmbH, the team behind Agile Hive.

Hope this helps, and again, welcome!

Joshua
Content Writer & US Representative
Agile Hive and Aura Apps (products of Seibert Group GmbH)

Melika-Everview

Welcome to the community @Alexander , and this is a well-scoped question, you've named exactly the three things that native issue links don't give you on their own.

Quick note on the native ceiling first, since it explains why the visualization feels lacking: Jira's built-in links are great as data (they make dependencies queryable), but the standard boards and timeline don't render them as a true dependency graph — no auto-updating arrows when you move a task, and no critical-path calculation. Advanced Roadmaps gets you dependency lines on a timeline, but it's oriented around planning rather than showing you the live knock-on effect when something actually slips. So your instinct to look for something purpose-built is right.

For your three specific needs — a timeline with dependency arrows, drag-to-adjust with dependencies updating automatically, and critical-path identification — that exact combination is what you'd want to evaluate a dependency-focused tool against.

I'm on the team at Everview, and this is squarely what we built for, so I'll be direct about it since you asked for a plugin. We sit on top of Jira (no rip-and-replace — your issues and existing links stay exactly where they are) and turn those links into a dependency-aware timeline: arrows between tasks across teams, drag a task and the dependent items and lines update automatically, and the critical path is highlighted so you can see what's actually blocking what. Because it reads your real Jira links, the Task A → blocks → Task B relationships you already have show up without re-entering anything.

Screenshot 2026-08-10 at 3.46.12 PM.png
Everview (demo data): dependency-aware timeline with critical path across teams.

We're on the Atlassian Marketplace if you want to try it against your own instance: Everview.Ai

Either way — when you evaluate options, the thing I'd stress-test hardest is the auto-update behavior: plenty of tools draw arrows, fewer keep the critical path correct the moment you drag something. Happy to answer questions if you go down that road.

Daria Spizheva_Reliex_

Hi @Alexander , welcome to the community!

You're on the right track using Jira's built-in issue links — the key is a tool that visualizes them properly. ActivityTimeline can help with part of what you're looking for:

Dependency tracking — enable "Track blocked issues" in the configuration, and ActivityTimeline will read Jira's blocks/blocked-by links and automatically highlight blocked issues if they're scheduled incorrectly (e.g., a dependent task planned before its blocker is done).
Timeline with drag & drop — plan tasks across teams on a shared timeline, drag to reschedule, and immediately see when a change creates a conflict with dependent work. Epics can also be visualized via per-Epic aggregation and epic-based coloring, so it's easy to see everything waiting on one epic.
Cross-team view — since dependencies in your case span teams, having all teams' timelines on one dashboard makes "who's blocking whom" much clearer.

Team panel and personal timeline.png

To be transparent: ActivityTimeline highlights dependency conflicts rather than drawing arrow lines between tasks, and it doesn't do automatic critical-path calculation — our focus is resource planning, workload, and scheduling on top of Jira. If dependency arrows and critical path are your top priority, a roadmap-focused tool (like Jira Plans/Advanced Roadmaps, which ActivityTimeline integrates with) may complement it well.

Happy to show how the dependency highlighting works in practice — feel free to reach us at support@reliex.com.

Rasmus Ersmarker

Hi @Alexander you’ve described the gap between Jira issue links as data and a working dependency schedule very clearly.

Full disclosure: I’m with Nirama Solutions, the team behind FastGantt for Jira. It is designed for this use case: it reads your Jira issues and links into a real Gantt, draws dependency arrows, supports dependency types and lag, and highlights the critical path. When you drag or resize work, the changed schedule writes back to the Jira issues, subject to each user’s Jira permissions.

You can scope the plan with JQL, so it is practical to bring the relevant cross-team work into one schedule rather than creating a separate planning dataset. It also includes baselines and a per-person workload view if those become useful later.

You can evaluate it here: [FastGantt on the Atlassian Marketplace]. I’d test it first with a representative set of linked issues, especially where several teams converge on the same epic.

Vahtang Manukyan - Be On Time

HiAlexander,

The three things you listed — dependency arrows, auto-recalculation on drag, and critical path — are exactly where native Jira (and even Plans/Advanced Roadmaps) stops: issue links are data, not a schedule, and Advanced Roadmaps draws the lines but doesn't recalculate.

Disclosure: I'm on the team behind MSP Planner for Jira. A few things that map 1:1 to your list: dependencies with types (FS/SS/FF/SF) and lead/lag drawn on the timeline; a deterministic scheduling engine (CPM) under the bars, so when you drag or resize a task, dependent tasks and the critical path recalculate in real time rather than just redrawing; a deadline-aware critical path with float/slack per task, so you see not just what's blocking what but how much buffer each item has and an explicit push/pull sync model that writes the plan back to Jira issues, so plan and tickets don't silently overwrite each other.

Marketplace page: https://marketplace.atlassian.com/apps/3162894022/msp-planner-for-jira

Test it first with a representative set of linked issues where several tasks converge on the same epic — that's where auto-recalculation earns its place or doesn't. Happy to answer questions.

Josh

Welcome — and good problem to nail early.

Native pattern that scales without inventing a second backlog:
1. Model stages as status categories or a custom “Stage” field on the same issue type — not as separate issue trees you have to keep in sync.
2. Use issue links (blocks / is blocked by) for true hard dependencies between work items. On Cloud you can surface those on Timeline/Plans.
3. If stages are sequential gates (Design → Build → Test), a workflow with conditions/validators is cleaner than a dependency web.
4. For multi-project roadmaps, Plans (Premium) or a board filtered by a shared label/fix version often beats cloning the same epic into every project.

Avoid nesting “stage” as parent/child unless the child is real work — hierarchy is expensive to maintain when the only difference is a status.

What does “stage” mean in your case — workflow status, or a separate deliverable?

Welcome!

It looks like you're new here. Sign in or register to get started.

Quick Links

Find more posts tagged with

jira

cloud

jira-cloud

advanced-roadmaps

roadmap