Jira Gantt Chart with Dependencies: The 2026 Guide

Real Gantt charts need dependency lines that propagate schedule changes. Jira's native Timeline has none. Marketplace options — Structure.Gantt, BigPicture, and Foundation — all support the four dependency types and auto-scheduling. The details differ in where links are stored and how they sync to Jira.

Why do Gantt dependencies matter more than the bars themselves?

A Gantt without dependencies is a timeline with fancy styling. The value is not the bars — it's the lines. A dependency encodes a rule: “if the predecessor slips, the successor must slip too.” With that rule, the chart is a live schedule model. Without it, it's a drawing that has to be re-drawn every time reality changes. See the broader Jira Gantt guide for everything else that makes a real Gantt real; this page focuses on the links.

What are the four dependency types (FS, SS, FF, SF)?

Finish-to-Start (FS): B starts after A finishes — the default, used for sequential handoffs. Start-to-Start (SS): B starts after A starts; the two run in parallel once both are live. Use for shared kickoffs. Finish-to-Finish (FF): B finishes after A finishes — common for tracks that must wrap together. Start-to-Finish (SF): B finishes after A starts. Rare in software, common in infrastructure cutovers where an old system runs until the new one launches.

The schedule network analysis literature treats all four as first-class, and mature Gantt tools support all four. Specialty apps sometimes ship FS-only because it covers ~80% of cases — but the other 20% tends to be the expensive part. Verify all four work during an evaluation.

How do Jira Gantt apps store dependencies — in Jira links or their own layer?

This is the most consequential design decision a Gantt app makes, and buyers rarely ask about it. Storage determines whether your dependencies are visible to the rest of your Atlassian stack or locked inside one app.

Foundation stores dependencies as Jira issue links. A Foundation FS dependency is a Jira “blocks” link — visible in the issue view, in JQL, in Automation rules, and in the REST API. Structure.Gantt and BigPicture both store dependencies in their own data layer by default, with optional write-back to Jira links. That keeps Jira's link graph clean but hides the dependency from everything outside the Gantt app. If you rely on Automation or JQL reports, the Jira-link model is simpler; if you want the Gantt's links isolated, the proprietary layer gives you that at the cost of visibility.

How does drag-to-link work in each app?

The universal pattern: hover a bar, a handle appears, drag to a target, the dependency is drawn. Default type is FS; the other three are chosen via menu or side-panel after creation. Structure.Gantt exposes handles on both edges (left for SS/SF, right for FS/FF) with live preview. BigPicture has a right-edge handle and an inline type picker. Foundation uses a single right-edge handle, defaults to FS, and lets you change type or add lag via a popover. Because Foundation's dependencies are Jira links, deleting one in the Gantt deletes the corresponding Jira issue link — worth noting if other teams rely on it.

How does auto-scheduling propagate a change through the chain?

When you reschedule a predecessor, successors slide by the same amount, subject to type and lag. FS with no lag: A slips two days, B slips two days. FS with 3 days lag: B still slips two days (lag preserved). SS: B's start moves, duration stays fixed. All three apps run this in real time during a drag.

They diverge on conflict handling. Structure.Gantt warns if a link would be violated and offers to keep or cascade. BigPicture cascades by default and shows violations in a validation panel. Foundation cascades and writes new dates back to Jira via the Forge inline-edit API within seconds. For locked dates all three support a per-item scheduling mode (Auto / Manual / Locked); see the critical path guide for how locked items affect critical-path math.

How do the apps detect and prevent cycles?

Cycles break Gantt math. Critical-path analysis requires a directed acyclic graph; if A depends on B and B depends on A, there is no longest path. A Gantt that allows cycles either infinite-loops or silently produces wrong dates.

All three apps run cycle detection on every link creation: before saving A → B, walk the successor graph from B and check whether A is reachable. If it is, reject the save. What differs is messaging. Structure.Gantt names the issues in the cycle. BigPicture highlights the path in red. Foundation does both — names the issues and rings the affected bars in red. Saving a fresh baseline after fixing a cycle resets your reference schedule.

Where is Jira's native timeline weak (and why that forces you to a Marketplace app)?

Jira Cloud ships a Timeline tab on every board and a richer Plans view at the Premium tier. The board Timeline has no dependency concept. Plans surfaces a blocker icon when a Jira “is blocked by” link points to an incomplete predecessor, but it draws no arrow, supports only FS-style blocker semantics, and does not cascade dates. Plans also defaults to Epic-level scope. That gap is what drives teams to Structure.Gantt, BigPicture, or Foundation.

How the three apps compare on dependencies

Tool	FS/SS/FF/SF	Storage	Drag-to-link UX	Auto-shift	Cycle detection	Lead/lag
Structure.Gantt	All 4 types	Proprietary layer (opt-in Jira link write-back)	Left and right edge handles, live preview	Warn-or-cascade choice	Named-path error	Lead + lag, working-day aware
BigPicture	All 4 types	Proprietary layer (optional Jira-link sync)	Right-edge handle, inline type picker	Cascade by default + validation panel	Red path highlight	Lead + lag, working-day aware
Foundation	All 4 types	Jira issue links (visible to JQL, Automation, REST)	Right-edge handle, popover type picker	Cascade + Jira write-back within seconds	Named issues + red ring on bars	Lag in MVP, lead on roadmap

How we tested

This draws on hands-on testing against all three apps in March 2026 across three real Jira projects (500–2,000 issues each). We built identical 40-link FS/SS/FF/SF graphs in each tool, ran the same drag-to-reschedule and cycle-creation workflows, timed auto-shift propagation, and cross-checked Jira-link visibility with JQL. We build Foundation, so treat this as a biased source and verify anything load-bearing.

Where Foundation fits

Foundation's distinguishing choice is the Jira-link storage model — every dependency you draw in the Gantt is a real Jira issue link, visible to JQL, Automation, and the issue view. See the Foundation Gantt product page for a deeper walkthrough.

Frequently asked questions

Can Jira’s native timeline show dependency lines between issues?

No. Jira Plans surfaces a blocker icon when a linked issue is in the way, but it does not draw arrows between bars and does not auto-shift successors when you reschedule a predecessor. For drawn dependency lines with cascade behavior you need a Marketplace app — Structure.Gantt, BigPicture, or Foundation.

What’s the difference between FS, SS, FF, and SF?

Finish-to-Start: B starts after A finishes (the default). Start-to-Start: B starts after A starts (shared kickoff, parallel work). Finish-to-Finish: B finishes after A finishes (tracks that wrap together). Start-to-Finish: B finishes after A starts (rare; handover scenarios where the old system runs until the new one launches).

Why does it matter where the Gantt app stores dependencies?

If dependencies live inside a proprietary app layer, they are invisible to JQL, Automation, the Jira issue view, and third-party integrations. If they are stored as Jira issue links, the same relationship is visible everywhere. Foundation uses Jira links directly. Structure.Gantt and BigPicture store dependencies in their own data layer with optional write-back.

Do all three Marketplace apps support lead and lag on dependencies?

Structure.Gantt and BigPicture support both lead (negative lag) and lag (positive lag) as per-link properties. Foundation supports lag in the MVP; lead is on the near-term roadmap. All three respect working-day calendars when calculating lag in business days.

What happens if I accidentally create a circular dependency?

A good Gantt tool detects the cycle before saving and rejects the change. All three apps run cycle detection on every link creation. Without it, critical-path math breaks — the algorithm needs a directed acyclic graph to compute the longest chain.

Can I bulk-edit dependencies across many issues?

Yes in all three apps, though the UX differs. Structure.Gantt exposes link editing in its Attributes panel. BigPicture has a dedicated Dependencies tab. Foundation lets you edit links inline in the grid or drag on the Gantt. For large rewrites, all three support CSV export of the link graph, manual editing, and re-import.