Skip to main content

How to Manage Dependencies in Jira

Dependencies are the silent killer of project timelines. A single blocked issue can cascade through your schedule, delaying entire releases. Yet most Jira teams manage dependencies reactively — discovering them only when something breaks.

This guide covers how to proactively model, visualize, and resolve dependencies in Jira.

Understanding Dependency Types

There are four standard dependency types in project management. Knowing which one to use matters:

Finish-to-Start (FS)

The most common type. Task B cannot start until Task A finishes.

Example: "Backend API must be complete before frontend integration begins."

Start-to-Start (SS)

Task B can only start after Task A has started. They can run in parallel, but B can't begin first.

Example: "QA testing can start once development starts (on completed features)."

Finish-to-Finish (FF)

Task B cannot finish until Task A finishes. Both can be in progress simultaneously.

Example: "Documentation cannot be finalized until the feature is complete."

Start-to-Finish (SF)

The rarest type. Task B cannot finish until Task A starts.

Example: "The old system stays active until the new system goes live."

Jira's Native Dependency Support

Jira supports issue linking out of the box with link types like "blocks / is blocked by" and "is cloned by / clones." However, native linking has significant limitations:

  • No timeline visualization — you can see that issues are linked, but not how they affect the schedule
  • No auto-rescheduling — moving one issue doesn't automatically adjust dependent issues
  • No critical path analysis — you can't identify which dependency chains determine your delivery date
  • No lag/lead time — you can't specify "start 3 days after Task A finishes"
  • Limited to single projects — cross-project dependencies require Advanced Roadmaps (Premium tier)

Visualizing Dependencies with Gantt Charts

A Gantt chart transforms flat issue lists into a timeline with visible dependency arrows. This makes it immediately obvious:

  • Which issues are blocking others
  • Where the critical path runs through your project
  • What happens to downstream issues when a date slips

Gantt-Chart for Jira renders all four dependency types as visual arrows on the timeline, with automatic rescheduling when dates change.

Setting Up Dependencies in Gantt-Chart for Jira

  1. Link issues in Jira using standard issue links ("blocks / is blocked by")
  2. Open the Gantt view — dependencies appear as arrows between bars
  3. Drag to reschedule — dependent issues shift automatically based on the dependency type
  4. Enable auto-scheduling — the chart calculates optimal dates based on dependencies, working days, and holiday calendars

Cross-Project Dependencies

Enterprise projects rarely live in a single Jira project. When your API team is in project BACKEND and your mobile team is in project MOBILE, cross-project dependencies are essential.

Gantt-Chart for Jira supports multi-project views where you can see and create dependencies across any Jira projects on a single timeline.

Identifying the Critical Path

The critical path is the longest chain of dependent tasks that determines your minimum project duration. Any delay on the critical path delays the entire project.

To find your critical path:

  1. Map all dependencies between issues
  2. Calculate the total duration of each dependency chain
  3. The longest chain is your critical path

Issues on the critical path deserve extra attention: more frequent status updates, earlier escalation, and buffer time where possible.

Common Dependency Problems (and Fixes)

Circular Dependencies

Issue A blocks B, B blocks C, and C blocks A. Nothing can start. This usually indicates a design problem — break the cycle by identifying which dependency is actually softer than assumed.

Hidden Dependencies

Two issues don't have an explicit link, but they both modify the same code or share a resource. These are the most dangerous because they're invisible until they cause a conflict. Encourage teams to link issues proactively during sprint planning.

Over-Linking

Not every relationship is a dependency. "Related to" is not "blocked by." If Task B could technically start without Task A finishing, don't create a Finish-to-Start link. Over-linking creates artificial bottlenecks and makes your Gantt chart unreadable.

Long Dependency Chains

A chain of 10+ sequential dependencies means any single delay cascades through 10 issues. Look for opportunities to parallelize: can some tasks start before their predecessor fully completes (Start-to-Start)?

Best Practices for Dependency Management

  1. Link during planning, not during crisis — add dependency links in sprint planning or backlog refinement, not when something is already blocked
  2. Use the right link type — "blocks" vs. "is blocked by" matters for visualization and scheduling direction
  3. Review dependencies weekly — as scope changes, dependencies become stale. Remove links that no longer apply
  4. Keep chains short — prefer parallel work over sequential chains. If a chain exceeds 5 issues, look for ways to decouple
  5. Account for non-working days — use holiday calendars (Gantt-Chart supports 144 countries) so your timeline reflects reality
  6. Visualize cross-project — dependencies within a project are easy to track. Cross-project dependencies are where most surprises come from

From Reactive to Proactive

Teams that invest in dependency management shift from firefighting ("why is this blocked?") to forecasting ("if this slips by 2 days, here's the impact"). The difference is visibility.

Try Gantt-Chart for Jira to visualize your project dependencies and see the critical path. Available on Cloud, Data Center, and Server.

For a broader comparison of Gantt chart tools, see our comparison of the best Gantt chart apps for Jira.