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

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.

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.

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

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)

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:

1. 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).
2. 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.
3. Cross-team view — since dependencies in your case span teams, having all teams' timelines on one dashboard makes "who's blocking whom" much clearer.

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.

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.

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.

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:

• JRACLOUD-88193: Advanced Roadmap - automatically shift blocked tasks when changing end date 
• JWMCLOUD-536: Move dependent issues when main issue is moved in calendar/timeline view 

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

Cheers,
Tobi