The Stale Board: Why Jira Is Always Two Days Behind Your Code
In a typical enterprise, the Jira board trails Git by almost two business days per issue: code is written before tickets reach "In Progress", and tickets stay open days after their pull requests merge. Learn what engineering leaders on Reddit say about stale boards, status-chasing standups and sprint carryover that exists only on paper, and how Keypup MCP compares each issue's workflow timeline with the commits and merges of its linked pull requests to measure the lag and list the tickets to close.
TL;DR: Engineers work in Git; leadership reads Jira. In between, someone has to drag the ticket. In a typical enterprise organization, the board trails the code by a median of 1.8 business days per issue. On 44% of issues, code is committed before the ticket enters "In Progress". 31% of tickets stay open more than two business days after their last pull request merges, 47% of closures happen in the last two days of the sprint against 21% of merges, and 28% of sprint carryover is work whose code had already merged. The Keypup MCP Server reads each Jira issue's workflow timeline, current status, sprint, past sprints, story points and assignees, and, for the pull requests linked to it through its issue key, the first commit, the last merge and the resolution state. Your AI assistant can then measure the board lag, show when tickets catch up, compare teams, size paper carryover and list the tickets to close before the sprint review.
It's Thursday, sprint review is tomorrow, and the Checkout board shows eleven stories "In Review". The engineering manager opens each one to prepare the demo. Nine have merged pull requests: two of them merged last Friday. One story is still "To Do", although its code has been in production since Tuesday. By the time the board is clean, the review shows a sprint that went well. Until Thursday, every report built on that board said it was going badly.
The Friction: A Board That Describes Last Week
Jira is the system of record for planning. Git is the system of record for work. When the two disagree, the board is usually the one that's wrong, and it's wrong in predictable ways:
Work starts before the ticket moves. An engineer opens a branch, commits, pushes, and moves the ticket to "In Progress" when someone asks about it.
Work finishes before the ticket closes. The pull request merges; the ticket stays "In Review" until the next standup, the next grooming session or the sprint review.
Status meetings become synchronization meetings. Standups spend their time asking "is this actually done?" instead of "what's blocking you?".
Every metric built on the board inherits the lag. Cycle time, sprint burndown, velocity and carryover all measure when people updated Jira, not when they did the work.
The result: leadership sees a board that is always pessimistic in the middle of the sprint and suddenly optimistic at the end, and nobody trusts either picture.
Why This Matters: The Real Cost of a Stale Board
The Forecasting Problem
A burndown chart that stays flat for eight days and drops on the ninth can't tell anyone whether the sprint is on track. Release managers and product owners who plan from the board plan from information that is two days old at best.
The Carryover Problem
Tickets left open after their code merges are rolled into the next sprint. Last sprint's velocity drops for work that was done, next sprint's commitment grows with work that isn't there, and the team looks less predictable than it is.
The Attention Problem
Every hour spent in standups reconciling the board with Git, and every message asking an engineer "can you update your ticket?", is time taken from the work itself. Engineers resent status chasing; managers resent having to do it.
The Enterprise Discussion: What Engineering Leaders Are Actually Saying
"Nobody updates Jira until the standup", "half our carryover is already merged" and "I spend Thursday afternoons cleaning the board for the review" are recurring complaints wherever engineering managers, staff engineers and delivery leads compare notes. The quotes below are representative of recurring threads on r/EngineeringManagers, r/ExperiencedDevs, r/agile and r/jira.
"Our standup has turned into a Jira grooming session. I go ticket by ticket asking 'is this merged?' because I can't trust the status column. Twenty people on a call doing data entry."
"I merge, I move on to the next thing, I forget the ticket. Then my manager pings me on Friday because the burndown is flat. The code shipped on Tuesday. The board is the only thing that's late."
Delivery Lead, Retail Group (r/agile)
"We carry over a third of our stories every sprint, and leadership thinks we can't estimate. When I actually checked, most of them were merged before the sprint ended. Nobody closed them."
The pattern holds: organizations plan, report and forecast from the board, while the work happens in Git, and nobody measures the distance between the two.
How Keypup MCP Measures the Stale Board
The Keypup Model Context Protocol (MCP) Server gives your AI assistant structured access to the data Keypup imports from Jira and from GitHub, GitLab, Bitbucket and Azure DevOps. For this analysis, what matters is each Jira issue: its workflow timeline, with when it entered and left each status, its current status, its closure date, its sprint with start and end dates, its past sprints, its story points and its assignees; and, for the pull requests linked to it, the date of the first commit, the date of the last merge and the issue's resolution state, which says whether all its linked pull requests are merged.
Two lags make up the board lag. The start lag is the time between the first commit of the linked pull requests and the issue's first entry into "In Progress", when the code came first. The close lag is the time between the last linked merge and the issue's closure. Both are counted in business days, 09:00 to 17:00 UTC, Monday to Friday. All figures cover issues closed in the last 12 full months, November 2025 to October 2026, whose linked pull requests are all merged, for an organization of around 1,200 engineers in eight Jira projects.
1. Measuring How Far the Board Trails the Code
The first question: how big is the gap, and at which end?
MCP Prompt:
For Jira issues closed in the last 12 full months whose linked pull
requests are all merged, show KPI cards with: the median board lag
(business days between the first commit and the first entry into
"In Progress" when the code came first, plus business days between
the last linked merge and the issue closure), the share of issues with
a commit before "In Progress", the share closed more than 2 business
days after their last merge, and the number of open issues today whose
linked pull requests are all merged.
Output: The Stale Board at a Glance
Key Insight: The board trails the code at both ends. On 44% of issues, code was being written before anyone moved the ticket to "In Progress". On 31%, the ticket stayed open more than two business days after its last merge. Today, 1,840 open tickets have nothing left to merge.
2. Seeing How Long Tickets Stay Open After the Merge
A median hides the tail. The distribution shows how many tickets drift for days.
MCP Prompt:
For the same issues, show a column chart of the business days between
the last linked pull request merge and the issue closure, in buckets:
under 0.5, 0.5 to 1, 1 to 2, 2 to 5, 5 to 10 and over 10. Show the
count and share in each bucket.
Output: Closure Lag Distribution
Key Insight: Half the tickets close within a day of the merge. The other half drift. 5,410 issues stayed open more than five business days after their code merged, and 2,080 more than two working weeks: long enough to be carried into the next sprint on paper.
3. Finding When the Board Catches Up
If tickets don't close when the code merges, when do they close?
MCP Prompt:
For issues closed in the last 12 full months that belong to a two-week
sprint, show grouped columns of the share of last linked merges and the
share of issue closures by business day of the sprint, from day 1 to
day 10.
Output: Merges and Closures by Sprint Day
Key Insight: Code merges evenly. Tickets close in a rush. Only 21% of merges happen in the last two days of the sprint, but 47% of closures do. The board is updated for the sprint review, not when the work is done, so for eight days out of ten it understates progress.
4. Comparing Teams
An organization-wide median hides teams whose boards are nearly live and teams whose boards are days behind.
MCP Prompt:
By Jira project, show a diverging bar chart: to the left, the median
business days between the first commit and the first entry into
"In Progress" for issues where the code came first; to the right, the
median business days between the last linked merge and the issue
closure. Sort by the total.
Output: Board Lag by Jira Project
Key Insight: The same work looks four and a half days longer on one board than on another. Mobile and Checkout trail Git by more than four business days per issue in total; Notifications trails by half a day. Same company, same Jira, same Git platform: the difference is in when each team's tickets move, not in when its code merges.
5. Finding Where Finished Tickets Sit
Some statuses legitimately follow a merge. Others shouldn't survive one.
MCP Prompt:
Show a donut chart of open Jira issues whose linked pull requests are
all merged, by current workflow status, with the count and share of
each status. Flag QA and Ready for Release separately: in our workflow,
they can follow a merge.
Output: Open Issues With All Code Merged, by Status
Key Insight: 1,325 of these tickets (72%) are in a status that a merge should have ended. 698 are still "In Review" although their pull requests are merged, 442 are "In Progress" and 110 never left "To Do". The 515 in QA or Ready for Release may be exactly where your process wants them.
6. Sizing Carryover That Exists Only on Paper
Carryover is read as a planning failure. Part of it is a closing failure.
MCP Prompt:
For issues carried over from at least one earlier sprint in the last 12
full months, show 100% stacked bars by Jira project: issues whose linked
pull requests were all merged before their current sprint started,
against issues whose code was still in flight. Show the share and count.
Output: Carried-Over Issues by Jira Project
Key Insight: 28% of carryover is a ticket nobody closed. 2,516 issues were moved into a new sprint although their code had already merged. In Mobile, it's 41%: two in five "unfinished" stories inflate the next sprint's commitment and lower last sprint's velocity for work that was done.
7. Listing the Tickets to Close Before the Sprint Review
Measurement is only useful if it ends with a list someone can act on today.
MCP Prompt:
List open Jira issues whose linked pull requests are all merged,
excluding QA and Ready for Release. Show the issue key, project, status,
assignee, number of merged pull requests, business days since the last
merge, story points and business days until the sprint ends, longest
first. Add KPI cards for the totals.
Output: Tickets to Close Before the Sprint Review
Issue
Project
Status
Assignee
Merged PRs
Business days since merge
Points
Sprint ends in
PAY-4821
Payments
In Review
j.morales
2
6.4
5
2 bd
MOB-7310
Mobile
In Progress
a.kowalski
3
5.9
8
2 bd
CHK-2265
Checkout
In Review
r.chen
1
4.7
3
2 bd
INFRA-918
Platform Infra
To Do
d.osei
1
4.1
2
7 bd
ID-3390
Identity
In Progress
m.lindqvist
2
3.3
5
2 bd
DATA-1542
Data Platform
Blocked
s.patel
1
2.6
3
No sprint
Key Insight: Ten minutes of board hygiene before the review recovers 2,940 story points. PAY-4821 has been "In Review" for 6.4 business days after both its pull requests merged; its sprint ends in two days. INFRA-918 never left "To Do". Sending each assignee their list is enough: nobody needs to investigate.
The Technical Implementation: What Keypup MCP Actually Reads
Every number above comes from fields Keypup already imports from Jira and your Git platforms. It helps to be precise about what each one depends on.
Links Come From Issue Keys
Keypup links a pull request to a Jira issue when the pull request references the issue key: in its title, or in its body or a commit message after a closing keyword such as "fixes", "closes" or "resolves". Each issue then carries the list of its linked pull requests, the date of the first commit and of the first and last merge among them, and a resolution state: in progress when at least one linked pull request is open, implemented when all of them are merged, none when there are none or they were all closed without merging. Issues whose pull requests don't reference their key can't be measured, so check the share of merged pull requests with a linked issue first.
Status History Comes From the Workflow Timeline
Keypup imports each issue's workflow timeline: every status it went through, with when it entered and left it. Keypup's TIMELINE_FIRST_START_AT function returns when an issue first entered a status, which is how the start lag is measured. Status names are whatever your Jira workflows use, so a prompt that says "In Progress" or "In Review" must use the names your projects actually have, and a project with "In Development" instead needs that name in the prompt.
"Stale" Is a Comparison, Not a Judgment
An issue is counted as stale when it's open, its resolution state is implemented, and its current status is one you've said a merge should end. Keypup doesn't know your process: whether QA or "Ready for Release" legitimately follow a merge is your call, and the prompt should say so, as in the donut chart above.
Sprints and Points Come From Jira's Own Fields
Each issue carries its sprint, with start and end dates, the list of past sprints it went through, and its story points. The sprint-day view uses the issue's current sprint; carryover means the issue went through at least one earlier sprint. Projects that don't run sprints or don't estimate in points won't appear in those views: count issues instead.
Business Days Come From a Formula, Not a Calendar
Keypup's BUSINESS_DAYS function counts working time between two dates, Monday to Friday, 09:00 to 17:00 UTC by default, and accepts another time zone, working hours and working days. It doesn't know about public holidays or vacations: Keypup doesn't import calendars.
What Keypup Doesn't See
Keypup doesn't see local branches or work before the first commit is pushed in a pull request, so the start lag is a lower bound. It doesn't know whether code has been deployed, only whether it has merged: if your "Done" means "in production", compare it with your deployment process separately. And it doesn't read the conversation in a standup or in chat: a ticket that everyone knows is done still counts as open until someone closes it.
Real-World Impact: Enterprise Case Studies
Case Study 1: European Insurance Group
Before Keypup MCP:
900 engineers in 14 Jira projects, two-week sprints
Average carryover of 35% per sprint, and a quarterly review questioning the teams' estimation
Standups of 30 minutes, mostly spent updating ticket statuses
After Keypup MCP:
The paper carryover view changed the conversation: 40% of carryover had merged code before the next sprint started
The close list was sent to each team lead every Wednesday and Thursday, two days before the review
Carryover fell from 35% to 22% in three sprints, without changing a single estimate
"We were about to send every team to estimation training. The data showed we didn't have an estimation problem, we had a closing problem. That's a much cheaper problem to fix."
— Head of Delivery, European Insurance Group
Case Study 2: North American Healthcare Platform
Before Keypup MCP:
650 engineers, quarterly roadmap reviews built on Jira burndowns
Burndowns flat until the last two days of every sprint
Product leadership asking for a daily "real status" spreadsheet maintained by hand
After Keypup MCP:
The sprint-day view showed the cause: merges were spread across the sprint, closures were not
Teams with the largest board lag adopted a pull request title convention with the issue key, and closed tickets as part of merging
The daily spreadsheet was retired, replaced by the close list and a weekly board lag trend by project
"Our board was a weekly report pretending to be a live one. Once we could see the lag by team, the teams fixed it themselves. Nobody likes being the project that's five days behind its own code."
— VP Engineering, North American Healthcare Platform
Implementation: Getting Started with Keypup MCP
1. Connect Jira and Your Git Platforms
Connect Jira and GitHub, GitLab, Bitbucket or Azure DevOps to Keypup. Issues, workflow timelines, sprints, story points, pull requests, commits and merges are imported automatically.
2. Check How Many Pull Requests Reference an Issue Key
The board lag can only be measured on linked issues. Ask your assistant for the share of merged pull requests linked to a Jira issue by project. Where it's low, agree on a pull request title convention with the issue key before reading the lag.
3. Map Your Statuses
Write down, for each Jira project, the status that means work has started and the statuses that may legitimately follow a merge, such as QA or Ready for Release. Use those names in every prompt.
4. Connect the MCP Server to Your AI Assistant
Connect the MCP server to your AI assistant using the MCP documentation, run the board lag by project for the last 12 months to set a baseline, and look at the paper carryover before your next planning session.
5. Close the Loop Before Each Review
Run the close list two days before each sprint review and send each assignee their tickets. Track the board lag by project month by month: it should fall within a few sprints.
Frequently Asked Questions
Why is our Jira board always out of date?
Because engineers work in Git and update Jira afterwards, when they remember or when someone asks. The work starts before the ticket moves to "In Progress" and finishes before the ticket closes. Measuring the gap between commits and merges on one side and status changes on the other shows how far behind the board is, and for which teams.
How do you measure the lag between Jira and Git?
Link pull requests to Jira issues through the issue key, then compare each issue's first entry into "In Progress" with the first commit of its linked pull requests, and its closure date with the last merge. Count the difference in business days, by project and over time.
Is sprint carryover always a planning problem?
No. Part of carryover is work whose code merged before the sprint ended but whose ticket stayed open. Compare the last merge of each carried-over issue with the start of its new sprint: if the code merged before, the carryover exists only on the board.
Should we automate Jira transitions from Git?
It helps, where your workflow allows it. Jira and most Git platforms can move or close an issue when a linked pull request merges. Measure the board lag by project before and after you turn it on: Keypup doesn't see the automation itself, but it shows whether the close lag fell, and which projects still trail their code.
The Bottom Line
Planning, forecasting and reporting run on the board. The work runs on Git. In many enterprise organizations, the two are almost two business days apart, and every metric built on the board inherits the gap. Keypup MCP makes the stale board visible:
✅ Measuring how far the board trails the code, at the start and at the end of the work ✅ Seeing how long tickets stay open after the merge, including the long tail ✅ Finding when the board catches up, day by day through the sprint ✅ Comparing teams, to find the boards that are days behind their code ✅ Finding where finished tickets sit, and which statuses a merge should end ✅ Sizing carryover that exists only on paper, before blaming estimation ✅ Listing the tickets to close before the sprint review, with who should close them
Ready to Transform Your Analytics?
Join teams already using AI to make data-driven decisions faster than
ever.
In a typical distributed enterprise, a pull request reviewed from another hub waits 4.1 times longer for a first review, and each round of requested changes costs a day instead of a few hours. Learn what engineering leaders on Reddit say about code review across time zones, and how Keypup MCP measures the time zone tax, from the hour a review request is sent to the teams that review locally and the cross-hub pull requests to hand off before logging off.
In a typical enterprise, a pull request sent to another team's repository waits 3.8 times longer for a first review, takes almost five working days to merge and is three times more likely to be abandoned. Learn what engineering leaders on Reddit say about cross-team contributions, and how Keypup MCP measures the inner source tax, from which owning teams are bottlenecks to which cross-team pull requests to unblock today.
In a typical enterprise, the longest phase of a pull request's life starts after it is approved: a median of 9.6 business hours from last approval to merge, and 31% of approved pull requests waiting two business days or more. Learn what engineering leaders on Reddit say about approved code that doesn't ship, and how Keypup MCP measures merge limbo, from who holds the merge button to which approved pull requests can be merged today.