DEV Community

Cover image for Jira Dependency Lag: Working Days Between Tasks
Mihai Perdum
Mihai Perdum

Posted on Originally published at leanzero.net

Jira Dependency Lag: Working Days Between Tasks

A Jira dependency lag doesn't exist in Jira itself: the issue link has no field for a wait. In LeanZero Management, our Gantt and planning app for Jira Cloud, you set the lag on the link. It counts working days, and the timeline keeps to it while you plan. I think that's what people want from a lag: a wait you re-enter by hand every time the blocker slips is just another date to forget. On our demo plan, linking ATLAS-150 to ATLAS-146 with a lag of 2 moved ATLAS-146 from Nov 12 to Tuesday Dec 15, 2026. A drag that tried to start it later was refused. Apply, the button that writes your draft to Jira, wrote the link and then the dates in about 17 seconds, and the lag itself stayed in the app.

Lag is the waiting time between one task finishing and the next one starting. Think of a sign-off that takes two days, or concrete that has to cure. People ask Atlassian for it. JRACLOUD-88033, a request filed against Jira Plans when it was still called Portfolio, asks for more kinds of scheduling dependency, including a way to "set the delay such as number of days before the start of another Epic/Story". It had 56 votes and 33 watchers when we read it on 16 November 2026, and it was still Gathering Interest.

We make the app, so I'm not neutral. The first section below is what Jira does without it, read from Atlassian's own pages. There's a 91-second video of this walk, published on 3 October 2026. We ran the steps again on 16 November on version 6.19.0. Our pair, ATLAS-150 and ATLAS-146, is not the video's, because they sit a few rows apart, and Step 4's refused drag isn't in the video.

https://www.youtube.com/watch?v=tRudIEzbhdk

Note

Before you start

  • Jira Cloud with LeanZero Management installed. It's free on the Marketplace today. We ran this on 6.19.0, released 6 November 2026.
  • A plan in the app with two work items that have start and due dates. A plan is the app's view of one or more Jira projects, a board or a JQL query, with every work item's schedule worked out from its dates and links.
  • Jira's Link Issues permission on both work items, because the app creates a real Jira link. To write the dates you also need Browse Projects and Edit Issues, and Schedule Issues if your plan uses Jira's own Due date field. The app asks Jira about each of these before it writes.
  • A desktop browser. Ours was 1,675 by 1,250 px.
  • When you're done, one work item will wait two working days after another, Jira will hold the link and the new dates, and you'll know where the lag itself is kept.

[[steps]]

  1. Open the plan on the Timeline and show the links: every connector is drawn.
  2. Drag from the first bar's end dot onto the second bar: a staged link appears.
  3. Click the link and press + twice: Lag (working days) reads 2.
  4. Drag the second work item later: the app refuses and says why.
  5. Click Apply 2 changes: the review lists the dates and Lag 2 working days.
  6. Click Apply 2 changes again: the link goes to Jira first, then the dates.
  7. Check Jira and the link menu: the link is there and the lag is still 2.

What a Jira dependency can't say: wait two days

A dependency in Jira is an issue link, usually of the type Blocks: "this work item blocks that one". We read Jira Cloud's REST API description (the published contract for the web interface that programs use to read and change Jira). An issue link has five properties (id, inwardIssue, outwardIssue, self and type), and the request that creates one takes four of the same kind. There's no field where a delay could go, so no app can store a lag in the link itself. I'd like Jira to have that field. It doesn't.

Three robots around one enormous solid chrome chain link that joins two platforms: the red robot jams a brass hourglass against the seamless metal and it slips, the green robot leans on a wrench with a magnifying glass, a small purple robot peers up at the link. Flat cobalt blue background.

Jira's project timeline draws these links. Atlassian's page What are dependencies on the timeline? says the timeline "can only show work items with the Blocks work item link type and link work items from a single space". We searched that page and three other Atlassian pages on timeline and plan dependencies for the words lag and lead time. Neither word appears on any of the four.

Finish-to-start is the common kind of dependency: the second task can start only when the first one has finished. The Data Center ticket JSWSERVER-24935, "To support time lag between dependencies", has asked for a lag on it since April 2021. It has 12 votes.

Jira Plans shows lead time but can't set a lag

Jira Plans is the planning tool in Jira's Premium and Enterprise plans. Its dependency page, What are dependencies in your plan?, says every link type you show is treated as Blocks, "meaning that the first work item must end before the second one can begin". A dependency turns red when the first work item puts the second at risk.

The knowledge-base article Calculate lead time in Jira Advanced Roadmaps defines lead time in Plans as "the time between the end time of the first issue and the start time of the second issue", a gap you can see between two dates you typed. Nothing in Plans holds that gap when the first work item slips.

Plans has no working-day calendar with weekends and holidays yet. JRACLOUD-88154, "Include working days and hours on advanced roadmaps", asks for one and had 341 votes on 16 November 2026, up from 331 when we wrote about it in August. And JRACLOUD-88193, which asks Plans to shift blocked work when a blocker's end date changes, had 119. I don't think a lag setting makes much sense in Plans before those two land, because a wait only means something if the waiting work moves.

Outside Jira the words mean something else. Microsoft Project's page Add lead or lag time to a task says "When you add lag time, you delay the start time of the successor task", and lead time is an overlap. This tutorial uses them that way.

Lag counts working days, not calendar days, on the Jira timeline

LeanZero Management counts a lag in working days: the days your plan treats as workdays, Monday to Friday unless you change it, minus the plan's holidays. Lag 0 means the next working day after the blocker's due date. A lag of N adds N more working days on top.

Our run shows it across a weekend. ATLAS-150 is due on Thursday 10 December 2026:

Lag on the link ATLAS-146 starts Why
0 Fri Dec 11 the next working day
1 Mon Dec 14 Saturday and Sunday are skipped
2 Tue Dec 15 one more working day

A lag of 2 calendar days would have put the start on Sunday 13 December. I prefer working days. A two-day sign-off doesn't happen over a weekend. We also ran the app's scheduling function directly with a holiday on Friday 12 June 2026 and a blocker due Wednesday 10 June. Lag 2 gave Tuesday 16 June instead of Monday 15 June, so a holiday pushes the start one more day.

Step 1: Open the plan on the Timeline and show the links

  1. In Jira's top bar, open Apps and select LeanZero Management. The Plans page opens.
  2. In Find a plan or project key, type the plan's name or its Jira project key. We typed ATLAS.
  3. Select the plan. We opened ATLAS Portfolio Plan, which has 2,349 open work items. It opens on its summary cards.
  4. Select the Timeline tab, then Everything and Week in the Timeline toolbar. Everything shows one row per work item, and Week makes each day wide enough to drop a link on.
  5. Open the ⋯ menu at the right end of the Timeline toolbar.
  6. Select Show all connectors, which is off by default. Lines now run from each bar to the work items it blocks.
  7. Scroll until both work items are on screen. Ours were four rows apart.

You should see both bars and their connector lines. The plan header should read Saved with no Apply button. I always check that first. If an Apply button is already there, the plan holds changes Jira doesn't have yet. Your Apply would write those too, so find out whose they are first.

Step 2: Draw a finish-to-start dependency between two Jira work items

  1. Hover over the bar of the work item that must finish first. A small dot appears just past the right end of the bar. We hovered ATLAS-150.
  2. Press on that dot and drag onto the work item that must wait. Drop on the green dot at the left end of its bar. We dropped on ATLAS-146.
  3. Release. I aim for the dot, not the bar; it's small, so zoom in if you need to. A dashed connector joins the two bars, and the second bar moves to the next working day after the first one ends. ATLAS-146 went from Nov 12 → Nov 23 to Dec 11 → Dec 22, 2026.
  4. Look at the plan header. It now shows Save (2) and Apply 2 changes: the new link is one change, and ATLAS-146's dates are the other. Only Apply writes to Jira.

LeanZero Management timeline after drawing a link: a dashed staged connector from ATLAS-150 to ATLAS-146, and ATLAS-146 now finishing Dec 22, 2026

A dashed line means the link is staged. Staged means it's in your own draft of the plan and nowhere else: Jira hasn't been told. Nobody else sees it.

The bar kept its length. ATLAS-146 was 8 working days long before the link. It still is.

Step 3: Set the lag in working days with + in the link menu

  1. Click the connector line itself, between the two bars. A small menu opens. Ours read "ATLAS-150 blocks ATLAS-146", with an orange staged tag, then Lag (working days) with − 0 +, and a red Remove link button.
  2. Click + once. The value goes to 1 and ATLAS-146 moves to Dec 14 → Dec 23.
  3. Click + again. The value goes to 2 and ATLAS-146 moves to Dec 15 → Dec 24, 2026.
  4. Press Escape to close the menu.

You should see the second bar sitting two working days further right than in Step 2. I keep lags small. Two or three days is a real wait; twenty is usually a missing task. The − button stops at 0. There's no negative lag, which would be a lead (the second task starting before the first one finishes). The app's code refuses one with "Lead (negative lag) is not supported yet".

LeanZero Management link menu reading ATLAS-150 blocks ATLAS-146, staged, Lag (working days) with minus, 2 and plus buttons, and Remove link

When the lag is saved depends on the link. Ours was staged, so the lag travels with it and is saved when Apply creates the link. On a link that is already in Jira, the app's manual says the lag "is saved to the plan as soon as you set it and everyone who opens the plan sees it". Undo doesn't take that back; you set the old value in the same menu. The dates a lag moves are staged in both cases.

Step 4: Drag the successor later: what the timeline refuses and why

  1. Drag the second bar to the right. We dragged ATLAS-146 five calendar days later.
  2. Release. You should see the bar go back to Dec 15 → Dec 24, and this warning at the top right (with your own keys and date):
ATLAS-146 must start 2 working days after ATLAS-150 finishes — on Dec 15, 2026. Cannot move after: a linked task starts on that day, not later. To start it later, change the link's lag or move ATLAS-150.
Enter fullscreen mode Exit fullscreen mode

The rule is strict. The app's code calls it "'on', never 'on or after'": a linked work item is pinned to the day its links set. So a lag here is an exact start, where Microsoft Project treats it as the earliest one. We tested only the later drag; the code refuses an earlier one too. If you want ATLAS-146 to start a week later, raise the lag to 7 or move ATLAS-150. I think that's the right call. A bar that drifts away from its link without saying why is exactly how a plan stops matching the work.

Two robots hauling a red block left and a green block right on a long workbench, both pinned at a fixed distance by one rigid bolted steel bar, while a third robot measures the bar with a tape; three red refusal discs float above. Flat sunflower yellow background.

LeanZero Management Review changes dialog with ATLAS-146 start and due dates struck through and replaced, a New dependencies row ATLAS-150 blocks ATLAS-146 with Lag 2 working days, and next to it the warning that ATLAS-146 must start 2 working days after ATLAS-150 finishes

Step 5: Read the lag in the Apply review

  1. In the plan header, click Apply 2 changes. A dialog called Review changes opens and says "2 changes will be written to Jira".
  2. Read What this does to your commitments. A commitment is a date the plan promised someone, such as a release. Ours said "No commitment moves."
  3. Read Date changes. Ours had one row: ATLAS-146, with Start Nov 12, 2026 struck through and Dec 15, 2026 next to it, and Due Nov 23, 2026 struck through and Dec 24, 2026 next to it.
  4. Read New dependencies. Ours had one row: "ATLAS-150 blocks ATLAS-146" with an orange Lag 2 working days label.

I read the New dependencies section first. It lists every staged link with its lag in one place. Each row has a tick box, so you can leave a change out. I wouldn't skip this screen. A link with no lag reads "No lag". A changed lag reads as before and after, for example "Lag 2 → 3 working days". The buttons at the bottom are Discard all, Review with AI, Cancel and Apply 2 changes.

Step 6: Apply: the Jira issue link is written first, then the dates

  1. Click Apply 2 changes at the bottom of the review. A progress dialog runs through "Checking your staged links against Jira", "Saving your reviewed draft", "Checking for conflicts with other saved drafts" and "Writing to Jira".
  2. Wait for Applied. Ours read "2 of 2 changes written to Jira" with four ticked steps, Starting, Writing, Verifying and Complete, about 17 seconds after the click.
  3. Click Done. The plan refreshes and the header goes back to Saved.

I think the order is the most useful thing in this tutorial. The new dates were worked out from the link, so the app writes the links first and starts on the dates once they are all in Jira. If a link fails, no date is written. Jira's own history of ATLAS-146 shows the order. At 04:23:36 (our time, UTC+2) the app added "This work item is blocked by ATLAS-150". Six seconds later it changed the start date from 12 November to 15 December and the due date from 23 November to 24 December. I trust Jira's history more than any dialog, ours included. Check it once.

LeanZero Management Applied dialog: 2 of 2 changes written to Jira, with Starting, Writing, Verifying and Complete all ticked and a Done button

Step 7: Check what Jira and the plan hold now

  1. Open ATLAS-146 in Jira. Under linked work items it says it is blocked by ATLAS-150, and its start and due dates are Dec 15 and Dec 24, 2026.
  2. Back on the Timeline, click the connector again. The menu reads "ATLAS-150 blocks ATLAS-146" and Lag (working days) 2, without the staged tag.
  3. Optional: read the work item's history over the Jira REST API to see the order of the writes. Set JIRA_SITE (your site's address), JIRA_EMAIL and JIRA_API_TOKEN (an Atlassian API token) first, and change the key and the date to yours. We ran it against our demo site after the Apply:
curl -s -u "$JIRA_EMAIL:$JIRA_API_TOKEN" "$JIRA_SITE/rest/api/3/issue/ATLAS-146/changelog?maxResults=100" \
  | jq -r '.values[] | select(.created | startswith("2026-11-16T04:23:3") or startswith("2026-11-16T04:23:4"))
    | "\(.created)  \(.items | map("\(.field): \(.fromString // "-") -> \(.toString // "-")") | join("; "))"'
Enter fullscreen mode Exit fullscreen mode
2026-11-16T04:23:36.001+0200  Link: - -> This work item is blocked by ATLAS-150
2026-11-16T04:23:42.683+0200  Start date: 12/Nov/26 -> 15/Dec/26; duedate: 2026-11-23 00:00:00.0 -> 2026-12-24 00:00:00.0
Enter fullscreen mode Exit fullscreen mode

You should see two lines: the link first, the dates a few seconds later. I do both checks the first time. Only the second one tells you the lag survived Apply. Jira now has the link and the dates, and the app has the 2.

LeanZero Management link menu after Apply: ATLAS-150 blocks ATLAS-146, Lag (working days) 2, Remove link, with no staged tag

Where the lag lives, and what deletes it

We keep the lag in the app's own storage on Atlassian's platform, one map per plan, keyed by the Jira link's id. It isn't an issue property and it never reaches Jira; the code puts it as "Lag is app-private (Jira links carry none)". The Apply review shows the lag so you can check it, but what Apply writes is the link and the dates the lag produced.

If you remove the link with Remove link in the app, the removal is staged like any other change. When you Apply, Jira goes first: the app clears the lag only after Jira confirms the link is gone.

With two blockers, the app works out each link's date with its own lag and then takes the later one. The blog post on how a Jira dependency moves dates walks through a worked case where a lag of 5 on the earlier blocker decides the start.

How the app stores and computes a lag (for Forge developers)

If you build on Forge, Atlassian's platform for apps that run inside Jira, this is the part I'd have wanted to read first.

LeanZero Management keeps one key per plan, p:{planId}:deps, in Forge's key-value storage: a map from the Jira link id to a whole number of working days. It sits apart from the app's per-plan copy of Jira data. That copy is rebuilt every time the app re-reads Jira (a re-index or the hourly refresh), and a rebuild would wipe any lag kept on its rows. When a plan loads, each work item gets its incoming links' lags copied onto it as predecessorLags, so the scheduler never looks the map up while it runs.

Our first version, on 5 July 2026, keyed the map by the pair of work-item keys, so a link deleted and drawn again got its old lag back. I'd call that a bug. The code comment that now prunes old lags says one would "silently reapply if the link is recreated". The releases of 30 September and 1 October 2026 moved plans to link ids; an old plan is migrated at its next rebuild, and a pair whose link is gone is dropped.

Creating a link with a lag is two calls in a fixed order: the app creates the link in Jira, reads back the new link's id (Jira's 201 answer has no body), then saves the lag against that id. If the second call fails, the link stays staged with a warning, so you can't end up thinking a lag is saved when it isn't.

Here's the rule: a successor's earliest start is the latest, over its blockers, of the next working day after the blocker's due date plus that link's lag. The browser computes it for the timeline you see, and the server computes it again to check what you save. A code comment admits the browser's date helper counts one day short, so the browser passes lag + 1, and a parity test suite holds the two to the same answer. I like that the off-by-one is written down next to the fix. I'd copy this whole pattern for any data Jira has no field for.

Plan protection uses the same rule. When someone moves a work item's start in Jira to before its blocker allows, the app puts the old start back if the old one keeps the rule, otherwise leaves the date, and either way leaves a comment on the work item saying why. The July commit that added lags made protection lag-aware too, or it would undo a start that's correct because of a lag.

Undo the lag before Apply, and put things back after it

Before Apply, nothing is in Jira. I use that a lot: I try a lag, look at it and often throw it away. I'd be careful how. Pressing − back to 0 only takes the lag off: ATLAS-146 goes back to Dec 11 and the link stays staged. Remove link (confirm with Remove) takes the link out of your draft, but the dates it moved can stay changed. Discard all in the review clears both, along with any other unapplied edit. When the plan header reads Saved with no Apply button, nothing is left.

After Apply, the link and the dates are in Jira. In the app, click Remove link and confirm with Remove, then set the old dates and apply again. We put our demo site back over the Jira REST API with a script instead, because we needed an exact before-and-after record. We set the lag to 0 through the app, deleted the link in Jira, wrote the old dates back and refreshed the plan.

Our first restore didn't stick. We deleted the link at 04:23:54 and wrote the old dates at 04:23:55. At 04:23:57 the app wrote Dec 15 and Dec 24 back and left a comment on ATLAS-146 headed "Date change reverted". That was plan protection. The plan hadn't re-read Jira since we deleted the link, so it still saw ATLAS-150 as a blocker and put the start back. We refreshed the plan and restored again. Then everything matched: no link, ATLAS-146 back on Nov 12 → Nov 23, and none of the 2,359 schedules we compared had changed after a reload. We deleted the protection comment afterwards.

A blue robot on a stool slides two blank tiles back into a big blank wall-calendar grid under a red circular undo arrow, while a second robot on a taller ladder re-presses the same two tiles with a rubber stamp; a hands-only wall clock ticks one step ahead and an open toolbox of gears sits on the bench. Flat emerald green background.

If you undo an Apply in Jira directly, delete the link first. Then select Refresh from Jira now in the ⋯ menu at the right end of the plan header (you need edit rights on the plan), wait until the plan stops saying Refreshing from Jira, and only then write the old dates. I'd rather remove the link in the app. Apply then deletes the link before it writes the dates, so protection has nothing stale to act on.

If it didn't work

You hover the bar and see no dot. The dot only appears for a work item you can change on a bar wider than a few pixels, and never on a parent such as an epic. Zoom to Week or Day so the bar is wider.

You release and no link appears. You let go over the bar instead of the green dot at its left end, or the timeline scrolled under the pointer. Dragging near the edge of the chart scrolls it. We missed twice that way before keeping both bars in the middle of the screen.

"The link ATLAS-150 → ATLAS-146 is in Jira, but its lag of 2 working days could not be saved yet — it shows 0." (with your own keys). Jira took the link and the app couldn't store the lag. The message's own advice: Apply again, or set it in the link's menu.

"Someone changed the lag ATLAS-150 → ATLAS-146 to 3 working days since you opened it. Nothing was saved." (with your own keys and number). Another planner set the same link's lag first. Reopen the menu and decide which value stands. When two people each stage the same new link with different lags, Apply asks "Two lags for one link" and offers Keep mine or Take theirs.

An Apply that stops with "Apply stopped" and "No dates were written — they wait for these links". A link failed, so no date was written. Fix what the dialog names, usually a missing Link Issues permission on one of the two work items, and Apply again.

What it doesn't do

It models finish-to-start only. There's no start-to-start, finish-to-finish or start-to-finish link, and no lead time. I'd like lead time too. It isn't there yet. A negative lag is refused, and the scheduling engine treats one as 0.

There's no calendar-days lag. Every lag counts the plan's working days and holidays.

We didn't test a very large lag live, and we didn't test a link between two plans; a code comment says such a link counts as lag 0.

You can't see a lag outside the app: Jira's timeline, Plans, filters and exports show the link and the dates, and nothing that explains them. If someone deletes the link in Jira, the next refresh drops the lag with it, and a link drawn again gets a new id and starts with no lag. I'd rather the lag were in Jira. It can't be. I'd put the reason for any lag over a day or two in a comment on the work item.

What you have now

[[takeaways]]

  • A finish-to-start dependency between two Jira work items, drawn on the timeline and written to Jira as a Blocks link.
  • A lag of 2 working days on that link, counted across the weekend: Friday Dec 11 became Tuesday Dec 15.
  • A refused drag, and a message that names Dec 15, 2026 and says what to change instead.
  • A review that listed the link with Lag 2 working days, and an Apply that wrote the link before the dates in about 17 seconds.
  • Not covered here: two blockers with different lags, holidays on a live plan, and links between plans.

The 2 stays in LeanZero Management, keyed to that one link. The Jira Gantt dependencies tutorial shows what happens when the blocker slips, the critical path tutorial shows which links set your plan's finish, the comparison of Jira's timeline and Plans covers what each does when a date moves, and the product page has the manual's section on lag.

My advice: put a lag only on a wait that really exists, like an approval or a delivery, and write down why. A lag nobody can explain looks the same on the timeline as a real one, and six months later nobody will remember which is which.


Originally published on leanzero.net. More Atlassian, Forge and local-AI write-ups at leanzero.net/blog, and if you're planning a migration or a Forge app, that's what we do: leanzero.net/services.

Top comments (0)