Support for this app is written, not conversational. Every message the app can show links to a heading on this page, and every heading answers one question completely. There is no chat widget and no phone number, and that is a deliberate design choice, not an oversight: the app is built and maintained by one person, and written answers scale where conversations do not.
Getting started
Before installing. The try page runs this gadget in your browser on sample data, with nothing you do there sent anywhere.
On a classic dashboard. Open the dashboard, select Edit, then Add gadget, and select Add beside Cycle Time & Lead Time (Stintwise). Atlassian's steps for adding a gadget start from Dashboards in the sidebar. The new tile asks for a saved filter: open the gadget's menu at its top right and choose Edit.
On one of Jira's new dashboards. The same chart is a widget there, under the same name: select Edit on the dashboard, then Add widget, and choose Cycle Time & Lead Time (Stintwise). Its settings open in Jira's Add widget drawer, and Add saves them. To change them later, select Edit on the dashboard, then the widget's pencil: outside the dashboard's edit mode Jira shows no toolbar on the widget. On the developer's own test site, on 3 November 2026, in a browser window 1,728 pixels wide, a widget in a row of four was 260 pixels wide, narrower than the 280 pixels the tile draws at its narrowest, so its headline was cut off at the right until scrolled sideways; in a row of three it was about 347 pixels wide. So put at most three in a row; narrower windows have not been measured. Whether status names with characters such as &, — or é keep their spelling in its settings, and what each viewer's browser is sent with it, have not yet been checked there, so until they have, a classic dashboard is the one to use.
The settings. Pick a saved filter, check the Started and Done statuses, which are preselected from Jira's own status categories, choose a date range and which time is counted, and save. What the six settings do.
The first chart. A chart is built at the first view each day; colleagues whose own searches Jira confirms return the same work items are shown it, and the tile shows its progress while it is. On the developer's own test site, on 1 November 2026, the first view of a tile whose saved filter returns 6,000 work items took about 39 seconds from the page's reload to the chart, and of one returning 10,500 about 46 seconds, each charting 5,000 of them (the item cap). That was one view of each, on one site, so yours can take longer or less. After that, the day's views open the stored chart, unless a setting or the filter's query changes. How a chart is built. On the very first view after the app is installed, the tile can stay blank for about 40 seconds before it shows anything, a known issue.
If the tile shows something you did not expect, every message on it links to the section of this page that explains it, and the support page says what to send if that does not answer it.
How the numbers are calculated
Cycle time starts the first time a work item enters one of your Started statuses, and ends the last time it enters one of your Done statuses. A work item created in a Started status enters it when it is created, unless its status history starts before that (see below). If it leaves the Done set again — reopened, sent back for review — the end is cleared and the next entry into Done becomes the new end.
Lead time starts when the work item was created and ends at the same point cycle time ends. Normally it is therefore at least as long as cycle time.
There is one case where it is not, and the tile shows it rather than hiding it. Some work items
have a status history that starts before their creation date — imports and bulk migrations do
this routinely, because the migration preserves the original transition timestamps while stamping
created at the time of the import. When that happens the work was already in progress before the
date Jira calls its creation, so lead time — measured from creation, as above — comes out shorter
than cycle time. Open the work item in the drill panel and you will see the pre-creation stretch as
its own row, which is where the difference went.
There are four ways a lead time can be missing, and in each the cell is left blank rather than filled with a zero, and the work item is left out of the lead percentile:
- The whole history predates creation, so the lead window is empty. Cycle time is still measured, from the first move into a Started status: the creation date cannot be its start, because the history begins earlier. A work item whose only Started status is the one its history begins in has no such move, so it is counted as never entered a started status.
- The calendar you chose emptied the window. With Time counted set to Weekdays, a work item opened and closed inside one weekend has a lead window every hour of which is excluded, and so does one opened and closed inside a public holiday, or outside your working hours, such as one evening, with Working hours on weekdays or Working hours that differ by weekday. Zero would read as a measured zero-hour lead for something that was open for hours or days, so nothing is stated instead. Set Time counted to Every hour, or clear the holiday region, whichever removed the time, and the same work item has a lead time again.
- Jira withheld part of the history. For a work item counted under have incomplete history in Jira, the part the app could not read may be exactly where the work item finished, so no lead time is stated. Its rows are still in the file, in neither total.
- It was finished the moment it was created, such as a work item created straight into a Done status, or one whose creation date Jira did not return. There is no lead window to measure.
With Lead time chosen, those charted for cycle time or that never entered a started status are counted as without a lead time under the chart; any other stays under the reason it was left out of cycle time, such as have incomplete history in Jira or counted to zero.
Counted time is elapsed time minus anything excluded. Time counted, in the settings, says what is: with Every hour, nothing; with Weekdays, Saturdays and Sundays contribute nothing; with Working hours on weekdays or Working hours that differ by weekday, the time outside each weekday's working hours contributes nothing either, as below (the setting). With a Public holidays country or region chosen, its public holidays contribute nothing either. Each list is the one the open-source date-holidays library gives, with the few changes and the differences from local law that Public holidays names. A country's list holds the days the library lists for the whole country. A day it lists only for some of the country's provinces, states, cantons or regions is in their own lists, which the settings offer under the country, and counts as working time with the country's list: in Canada, Victoria Day, Thanksgiving, Remembrance Day and Boxing Day, each in the lists of the provinces and territories the library lists it for; in the United Kingdom, the Summer bank holiday, at the end of August in England, Wales and Northern Ireland and at the start of August in Scotland; in Australia, the King's Birthday and Labour Day, on each state's own dates. A few days on a country's list are not kept everywhere, and the library leaves them out of the lists of the states or regions it has as not keeping them: in the United States, Columbus Day, which California, among others, does not keep, and Washington's Birthday, which a few states keep on another day or not at all; in the United Kingdom, Easter Monday, which is not a bank holiday in Scotland; in Switzerland, where only 1 August is a federal holiday, Good Friday, Whit Monday and St Stephen's Day, which some cantons do not keep. A holiday that starts partway through a day is in no list, so its day counts as any weekday: Christmas Eve and New Year's Eve evenings in the Northern Territory and South Australia, Christmas Eve evening in Queensland, the afternoons of 1 May in Solothurn and of 1 May and Christmas Eve in Valais, and Good Friday afternoon in Kentucky. Holidays are removed only while weekends are, with Weekdays, Working hours on weekdays or Working hours that differ by weekday, so a holiday that falls on a weekend removes nothing more on that day. Where a country gives a weekday off in its place, some lists include that substitute day, and it is removed: in the United States, Friday 3 July 2026 for Independence Day; in the United Kingdom, Australia and New Zealand, Monday 28 December 2026 for Boxing Day. Canada's list has no substitute days. With Days the whole team is off listed under Public holidays, each of those weekdays contributes nothing either, removed whole like a public holiday and only while weekends are; a day that is also a public holiday of the list is that holiday (the setting).
With Working hours on weekdays, every weekday that is not a removed holiday counts only the time
from the working day's start, From, to its end, To: one window, the same on every weekday, in the
gadget's time zone, and the rest of the day is excluded as off-hours. With Working hours that differ by
weekday, Monday to Friday each have a window of their own, and each day counts only its own weekday's.
Weekends and holidays are removed whole, as above, however short a weekday's window.
One day means 24 hours of counted time, not one calendar day, or, with Working hours on weekdays, one working day: as many counted hours as your working day holds, 8 for 09:00 to 17:00. The method line says which: the tile states this under Time zone, build time and method, at the end of the line under its chart's footer rule, and every image and summary of the chart states it in full. A work item that starts Friday at 16:00 and finishes Monday at 10:00, with Weekdays, counts 18 hours — 8 on Friday evening and 10 on Monday morning — and excludes 48. One that starts Friday at 13:00 and finishes Monday at 17:00 counts 76 hours, 3.2 days, with Every hour; 28 hours, 1.2 days, with Weekdays; and 12 hours, 4 on Friday and 8 on Monday, 1.5 working days, from 09:00 to 17:00. On a day the clocks change, a day counts the hours its clock shows between From and To.
With Working hours that differ by weekday, one day is the average working day, the week's working hours divided by five: 7.2 hours for Monday to Thursday 09:00 to 17:00 and Friday 09:00 to 13:00. A work item started Thursday at 10:00 and finished Monday at 10:00 counts 12 hours, 7 on Thursday, 4 on Friday and 1 on Monday: 1 d 4 h 48 m in the drill panel, 1.67 working days, which the chart states as within 1.7 working days. A day of the drill panel is the average day too, so a whole Monday of 8 hours reads 1 d 48 m there, and a whole Friday of 4 hours 4 h.
Percentiles use the nearest-rank method: the 85th percentile of ten values is the ninth value when sorted, not an interpolation between the eighth and ninth. This is why a percentile is always a real work item's real duration and never a number nothing achieved. The tile names the method under Time zone, build time and method and in Values to the minute.
Why a "within" figure is rounded up
Where the chart states a percentile as a limit, as in 85% of charted work items finished within 6.2 days of starting, the figure is the percentile rounded up, never to the nearest, so that the sentence is true: under nearest rank at least 85% of the work items took no longer than the 85th percentile, and the figure is never below it. Rounded to the nearest, an 85th percentile of 6 days 2 hours 40 minutes (6.11 days) would read 6.1 days, and the work item at the 85th percentile took longer than that. The key under the chart states the 50th, 85th and 95th percentiles and lead time's 85th the same way, and Values to the minute, at the end of the key, shows each of them to the minute. On the chart each rule is drawn at the exact percentile and tagged with its name from the key, 50%, 85%, 95% or Lead 85%; where two of the key's figures read the same, their rules share one tag, such as 50% · 85%.
The step follows the size: whole minutes under an hour, never fewer than 1; tenths of an hour under a day; tenths of a day under 100 days; whole days from 100 days. A figure that reaches the next unit is written in it, so 60 minutes reads 1 hour and 24 hours reads 1 day. A day is 24 hours of counted time, or, on a chart counting only working hours, one working day of D hours: there 8.0 hours reads 1 day, and on a working day of one hour 60 minutes does; on a chart counting working hours that differ by weekday, D is the average working day (why).
To reproduce a figure from the ledger export, take its closing row's hours
(the CSV format), divide by D, round the quotient to six decimals, and round up to
one decimal, ROUNDUP(ROUND(hours / D, 6), 1): the result is the figure in days. D is 24, or, in a
file that ends with a working_day row, that row's third cell, the working day in hours, as
8.0000: on a chart counting working hours that differ by weekday, the average working day, as 7.2000. For the 85th percentile above, the file reads 146.6667; 146.6667 / 24 is 6.1111,
which rounds up to 6.2. For a figure in hours, round the hours up to one decimal; a figure is in hours
while it is under D hours. For one in whole days, from 100 days, ROUNDUP(ROUND(hours / D, 6), 0).
For one in minutes, round to the second first, ROUND(hours * 3600, 0), then divide by 60 and round
up to a whole minute, at least 1. The six decimals are for binary arithmetic, a spreadsheet's or a
script's, in which a quotient exactly on a tenth can come out a hair over it: 146.4 / 24 gives
6.1000000000000005, which rounds up to 6.2 where the chart states 6.1.
The recipe always lands on the chart's figure. The file's hours are the exact value rounded to the nearest ten-thousandth of an hour, 0.36 seconds, so they are never more than 0.18 seconds from it. The exact value is a whole number of seconds, and so is every step, so that difference never carries a value across a step, and a value exactly on one is printed exactly. A duration the app states as a value rather than a limit, such as a total in the drill panel, is rounded to the nearest minute instead (why the totals do not match a calendar).
The 70% line. Show the 70% line, under the chart on Histogram, Scatter and Aging, above the key, adds a rule at the 70th percentile of the charted cycle times, tagged 70%, and its figure to the key, as in 70% within 4.1 d, rounded up as above; while it is shown, the method line under Time zone, build time and method reads 50th / 70th / 85th / 95th percentile (nearest-rank), and Values to the minute stays on the four figures the closing rows state. It changes no sentence: the headline, the Aging view's answer and its solid marks stay on the 85th, and Trend, By status, Compare, Flow, Forecast and the comparison with the period before stay on the 50th, 85th and 95th: while the tile compares, the table that takes the key's place does not state the 70th, and the line keeps its tag. With Lead time chosen, the line on Histogram and Scatter is at the 70th percentile of lead times, over L1's rows. The box is remembered for the gadget in your browser (privacy).
No closing row states the 70th. To reproduce it, take the issue_total rows whose charted is
true, n of them: the 70th is SMALL(issue_cycle_time_hours, CEILING(0.7*n,1)) over them, never
PERCENTILE, then round it up by the steps above. Cycle times are whole seconds, so it lands on the
key's figure as a closing row's does. Under Show, take the group's rows (S3). The
Aging view draws its 70% line at that figure, in hours, as A3 draws the others; a
work item past it, Past the 70% line in its tooltip and past 70% in a list, is strictly older, as
A2 counts.
A target: how many finished within it
Show a target, under the chart after Show the 70% line, draws a target for how long work should take, and states how many work items met it. Tick it, type a number after within and choose its unit: days, to one decimal, from 0.1 to 999, or whole hours, from 1 to 9,999. On a chart counting only working hours the unit reads working days, and a day is one working day of the chart's (why). On a chart counting working hours that differ by weekday, whose average working day is not a whole number of half hours, such as 7.2 hours, a target in days is whole days, and the line under the box says On this chart a day is the average working day of 7.2 hours, so a target in days is whole days; or set it in hours. Anything else is not a target: the line under the box says A target is whole hours, or days to one decimal, from 0.1 to 999 days or 1 to 9,999 hours., and nothing is drawn.
On Histogram the target is a vertical rule, and on Scatter, Trend and Aging a horizontal one, dashed in the text's colour and tagged Target; one longer than the axis is drawn at its end, and its tag says so with ›. The key states it after the percentiles, as in Target 5 d: 18 of 23 within it (78%): how many charted work items finished within the target, of how many, and their share, rounded down, so it never reads higher than the work items show. Within is at most: a work item that took exactly 5 days is within a target of 5 days. On Aging the key counts the work in progress the view plots that is past the target, strictly older, as in Target 5 d: 6 of 14 in progress past it. Under Show, both are the group's.
On Trend, each period that finished anything adds its own count to its tooltip and its name, as in 9 of 11 within the 5 d target (81%), and the key states the whole range's; the sentence about the two halves does not change. By sprint, the Trend view draws no target yet and its columns state no count; the key still states the whole range's. Compare adds a Within 5 d column after 95%: each row's share of its own work items, with its count on pointing at it and in the row's name, as in 18 of 23 within 5 d (78%), and, below 480 px, at the end of the row's second line, as in 78% within 5 d. Saved filters side by side add the same column, and the comparison with the period before a Within 5 d row. By status, Flow and Forecast draw no target and state none: the box stays ticked, and the target is back on a view that draws it. Nothing else the tile states changes with a target: no headline, answer, verdict, colour or percentile.
The target is yours alone: it is remembered for the gadget in your browser, as a number and its unit, never a setting and never sent to the app or to Jira, so another person looking at the same dashboard sees their own or none (privacy). While one is shown beside the period before, the tile asks the app for that period's charted cycle times in whole minutes, to count it there; the target itself stays in your browser. An image or summary states the target it was drawn with, so a copy says whose line it is. Each count can be checked against the export with the target recipe.
Natural process limits on the Scatter
Show natural process limits, under the chart on Scatter, between Show the 70% line and Show a target, draws the average of the cycle times the scatter shows and their natural process limits, by the formula ActionableAgile's control chart uses, and rings each dot beyond them. It is offered on Scatter only: a Trend period's figure is not a single cycle time. It is not offered while the tile compares the chart with the period before, so two periods' dots are never read against one period's limits; the box stays as you left it, and the limits are back once the tile stops comparing.
The cycle times are taken in the order their work items finished. The average is their sum over n, how many there are; each one's moving range is how far it is from the one before it; and the limits are the average plus and minus 2.66 times the average moving range, the sum of the moving ranges over n − 1. They need at least 20 cycle times: with fewer, the line under the key says Natural process limits need at least 20 cycle times; 12 are shown. Over the item cap they are of the 5,000 charted, and with one group shown they are the group's.
The figures are printed outward, on the steps a "within" figure takes (rounded up): the upper limit rounded up, the lower limit rounded down, and the average to the nearest step, a half up. Where the lower limit is zero or less, or rounds down to zero, there is none. Each rule is drawn at the figure printed, so its tag, the key, the sentence and the dots it rings state one figure: the limits long-dashed in the text's colour, the average short-dashed in grey, each tagged Upper limit, Lower limit or Average, apart from a target's rule and the percentiles'. An upper limit longer than every dot is drawn at the top of the plot and its tag ends in ›: the axis stays the dots', so ticking the box never moves them. The key states the three figures after the percentiles, as in Average 4.2 d · Upper limit 13.6 d · Lower limit 0.4 d.
One rule decides a ring: a dot is beyond a limit when its work item's cycle time, in the whole seconds the dot is drawn at, is strictly longer than the upper limit printed, or strictly shorter than the lower one. A dot on a limit's line is not ringed. There is no other rule, such as a run of dots on one side of the average. Under the key, a line states the figures and how many are beyond, as in Natural process limits of the 287 cycle times shown, taken in the order they finished: average 4.2 d, upper limit 13.6 d. 6 took longer than it., and List these 6 opens them; with a lower limit, average 4.2 d, limits 0.4 d and 13.6 d. 6 took longer than the upper and 2 less time than the lower., with List the 6 above and List the 2 below. A ringed dot's tooltip says which limit it is beyond, as in Longer than the upper limit, 13.6 d, and its name for a screen reader ends , longer than the upper natural process limit. The tile states the figures and does not say what they mean for the team.
The box is remembered for the gadget in your browser, never a setting and never sent to the app (privacy). The limits come from a part of the tile loaded the first time the box is ticked; until it is here the scatter is drawn without them, and if it cannot be loaded the line under the key says Natural process limits could not be loaded., with Try again. An image or summary of the Scatter draws them and states their line. Checking the limits reproduces every figure from the export.
Checking natural process limits against the ledger export
Every figure of the natural process limits can be reproduced from Export data (CSV), once the file is imported as the CSV format says.
| Step | Recipe |
|---|---|
| L1 the cycle times | The issue_total rows whose charted is true, read from the last up: the file lists finished work most recently finished first, and work finished at one instant by its id, so read upward they are in the order they finished, as the tile takes them. Do not sort them by left_at: sorted as text, it misorders the hour the clocks go back through. Under Show, the group's rows only, by S1's or S10's condition. x = ROUND(issue_cycle_time_hours*10000,0), each cycle time in whole ten-thousandths of an hour. |
| L2 n, S and M | n = how many, at least 20. S = SUM(x). M = the sum of ABS(x − the x before it), from the second on. |
| L3 the limits | A = S / n; U = S / n + 2.66 × M / (n − 1); L = S / n − 2.66 × M / (n − 1); each in ten-thousandths of an hour. The average moving range is M over n − 1, not over n. |
| L4 U printed | h = U / 10000, and D the day's hours: 24, or the working_day row's third cell (why). Under an hour, CEILING(ROUND(h*60,6),1) minutes; under D hours, CEILING(ROUND(h*10,6),1)/10 hours; under 100 × D hours, CEILING(ROUND(h/D*10,6),1)/10 days; otherwise CEILING(ROUND(h/D,6),1) days. 60 minutes is written 1 hour, and D hours 1 day. B = that figure in seconds. |
| L5 L printed | As L4, with FLOOR in place of CEILING. There is none where L is 0 or less, or where it rounds down to 0. B′ = that figure in seconds. |
| L6 beyond | A work item took longer than the upper limit where ROUND(issue_cycle_time_hours*3600,0) > B, and less time than the lower one where ROUND(issue_cycle_time_hours*3600,0) < B′. That is its cycle time in the whole seconds its dot is drawn at: a cell is never more than 0.18 seconds from it. Equivalently, x > ROUND(B/0.36,0), the bound's own cell. Not x > B/0.36 on the bound unrounded: under an upper limit of 7 minutes, B = 420, a work item of exactly 420 seconds has x = 1167, which is 420.12 seconds, so it would count as longer while its dot sits on the line. Nor against the limit before it is printed. |
| L7 A printed | In the tier L4 would take for A, ROUND(ROUND(q,6),0) in that tier's step, q being A in it: minutes, tenths of an hour, tenths of a day, or days. |
The spreadsheet form lands on the tile's figures but in one case: an exact limit within a millionth of a step without
being on it, which ROUND(…,6) moves onto the step. 5,000 cycle times of 48 hours, one of them a second longer, have
exact limits a hair either side of 2 days, which the tile prints 2.1 d and 1.9 d and the spreadsheet form 2.0 d and
2.0 d, counting the longer one beyond. The ROUND(…,6) stays for the binary fractions a spreadsheet works in: without
it, 20 cycle times of exactly 33.6 hours, 1.4 days, print 1.5 d. The script below works in exact fractions and lands on
the tile's figures in every case: it prints n; A, U and L in hours; the three figures as the tile writes them; and the
keys of the work items beyond each limit. With one group shown, give it --issue-type, --project, --parent,
--label, --component or --team and the group's name, as the file writes it.
import csv, math, sys
from decimal import Decimal, ROUND_HALF_UP
from fractions import Fraction
args = sys.argv[1:]
opt = lambda name: args[args.index(name) + 1] if name in args else None
with open(args[0], newline='', encoding='utf-8-sig') as f:
rows = list(csv.DictReader(f))
D = next((Fraction(Decimal(r['status'])) for r in rows if r['issue_key'] == 'working_day'), Fraction(24))
charted = [r for r in rows if r['row_type'] == 'issue_total' and r['charted'] == 'true']
for option, column in (('--issue-type', 'issue_type'), ('--project', 'project'), ('--parent', 'parent'),
('--team', 'team'), ('--label', 'labels'), ('--component', 'components')):
if opt(option) is not None:
cells = lambda r: r[column].replace('\r', '').split('\n') if column in ('labels', 'components') else [r[column]]
charted = [r for r in charted if opt(option) in cells(r)]
charted.reverse()
x = [int(Decimal(r['issue_cycle_time_hours']) * 10000) for r in charted]
n = len(x)
if n < 20:
sys.exit(f'{n} cycle times: natural process limits need at least 20')
S, M = sum(x), sum(abs(b - a) for a, b in zip(x, x[1:]))
A = Fraction(S, n)
U = A + Fraction(266, 100) * Fraction(M, n - 1)
L = A - Fraction(266, 100) * Fraction(M, n - 1)
def printed(units, rounding):
step = {'up': math.ceil, 'down': math.floor, 'nearest': lambda q: math.floor(q + Fraction(1, 2))}[rounding]
h = units / 10000
if h < 1:
m = step(h * 60)
if m == 60 * D:
return 10, 'd', 3600 * D
return (10, 'h', 3600) if m == 60 else (10 * m, 'm', 60 * m)
if h < D:
t = step(h * 10)
return (10, 'd', 3600 * D) if t == 10 * D else (t, 'h', 360 * t)
if h < 100 * D:
t = step(h / D * 10)
return t, 'd', 360 * D * t
d = step(h / D)
return 10 * d, 'd', 3600 * D * d
def text(p):
tenths, unit = p[0], p[1]
return (f'{tenths // 10}' if tenths % 10 == 0 else f'{tenths // 10}.{tenths % 10}') + ' ' + unit
def hours(units):
return f'{Decimal(units.numerator) / Decimal(units.denominator) / 10000:.6f}'
seconds = lambda r: int((Decimal(r['issue_cycle_time_hours']) * 3600).to_integral_value(rounding=ROUND_HALF_UP))
upper = printed(U, 'up')
lower = printed(L, 'down') if L > 0 else None
lower = None if lower is None or lower[0] == 0 else lower
print('n', n)
print('A', hours(A), 'U', hours(U), 'L', hours(L))
print('average', text(printed(A, 'nearest')))
print('upper limit', text(upper))
print('lower limit', 'none' if lower is None else text(lower))
print('above', *[r['issue_key'] for r in charted if seconds(r) > upper[2]])
print('below', *[r['issue_key'] for r in charted if lower is not None and seconds(r) < lower[2]])
Lead time on the chart: Measure
On Histogram, Scatter and Trend, Measure under the chart chooses what the view draws: Cycle time, from the first move into a Started status, or Lead time, from creation (how each is measured). By status, Compare, Aging, Flow and Forecast are about cycle time or throughput and keep it; your choice waits for when you show one of the three again, and is remembered for the gadget in your browser (privacy). Measure is offered while the chart charts a cycle time; a chart of work items that never entered a Started status alone keeps its own message.
With Lead time chosen, everything the view states is lead time's, over the work items with a lead
time: the charted work items and those that never entered a Started status, each with a lead time,
the population the three lead_time closing rows count. The headline reads 85% of work items with a
lead time finished within 9.8 days of creation, or All 4 work items with a lead time where there are
6 or fewer. The line under it counts them, as in 27 work items with a lead time · 5 excluded, itemised
under the chart, and the line under the chart says why each of the others is left out: 5 excluded from
lead time: 2 without a lead time · 3 have incomplete history in Jira. Without a lead time opens the
work items, charted or never started, that have none (why); every other reason is one of
the chart's own, except never entered a started status, whose work items lead time counts. On
Histogram and Scatter the bars and the dots are purple; Trend keeps its blue columns and dots, its
titles naming lead time. The key states lead time's 50th and 95th, and its 70th while Show the 70%
line is ticked, with cycle time's 85th as the reference, Cycle time 85% within 6.2 d of starting, 23
charted, drawn as a dotted blue rule tagged Cycle 85%; the headline states lead time's 85th. Values
to the minute gives lead time's three to the minute, and cycle time's 85th. On Trend each period is
the work items with a lead time that finished in it, and the sentence compares the two halves' lead 85ths
by the same rule.
Show splits lead time as it splits cycle time: a group's face is over its own work items with a lead
time, Issue type Bug only: 12 of the 27 work items with a lead time, and List these 12 opens them with
those of the group that have none. Compare with … compares the two periods' lead 85ths by
the same verdict rule, from 20 work items with a lead time in each, and its table states both
periods' lead time. Show a target and Show natural process limits are not offered in lead time; ticked,
they stay ticked for cycle time. Where nothing has a lead time the view says No lead time to chart in this
range, and why. Image or summary copies the view as it is, in lead time, its image's file name ending
the view's name with -lead-time.
Every figure is in the ledger export, which is the same file in either measure: checking lead time against the ledger export.
Checking lead time against the ledger export
Export data (CSV) ends with nine closing rows (the CSV format), three of them lead time's:
lead_time,p85 after the three cycle_time rows, and lead_time,p50 and lead_time,p95 after the
wip_line rows. G is a row's issue_lead_time_hours; D is 24, or the file's working_day row's hours
(why). Each step below is run on the file's text by the app's own tests.
| Step | Recipe |
|---|---|
| L1 rows | The issue_total rows where charted is true or exclusion_cause is NEVER_STARTED, and G is not blank. Their number n_L is the fourth column of every lead_time row and the count line's 27 work items with a lead time. |
| L2 percentiles | SMALL(G, ROUNDUP(p*n_L/100, 0)) over L1's rows, for p = 50, 85 and 95 (and 70 while the 70% line is shown), equals each lead_time row's hours; rounded up with the file's D it is the headline's and the key's figure. With 6 or fewer the 85th is their largest, and the headline says All n_L. Never PERCENTILE. |
| L3 a bar | The width as S5 decides it, over MAX(G) of L1's rows; a bar counts L1's rows with G in [lo*D, hi*D), the last bar closed. The counts add up to n_L. |
| L4 left out | Every issue_total row not in L1: by exclusion_cause, NEVER_STARTED aside, and without a lead time, the rows where charted is true or exclusion_cause is NEVER_STARTED and G is blank. Over the item cap: the cycle_time,p85 row's fifth column less COUNTIFS(row_type,"issue_total",charted,"false"). Their sum is the lead_time rows' fifth column, and the line under the chart's excluded from lead time. |
| L5 Trend | The Trend recipe on L1's rows, with G for H; a bar is the period's n_L. |
| L6 Show | L1's rows of the group, by issue_type, project, parent, labels, components or team as S1 and S10 take each, then L2 over them. |
| L7 the period before | L1 and L2 on the period before's own export, then C1 to C4 on the two lead_time,p85 rows, with n_L 20 or more in each. |
What a bar says when you point at it
Point at a bar of the histogram, or move to it with Tab, and it says its range, how many work items it holds, and how many of all the charted work items finished in under its upper edge, as in 17 of 23 finished in under 5 days. A bar holds the work items from its lower edge up to, but not including, its upper edge, so one of exactly 5 days is in the 5–6 days bar and not under 5 days. The last bar includes its upper edge, so it says within. Bars narrower than a day are read in hours: 6–12 hours, or, on a chart of 9-hour working days, 2.25–4.5 hours.
To reproduce the count from the ledger export, count the issue_total rows whose charted is
true and whose issue_cycle_time_hours is below the edge in hours, the edge in days times D: 120
for 5 days, or 40 for 5 working days of 8 hours (D); or at most the edge for the last
bar. Cycle times are whole seconds and the file's hours are never more than 0.18
seconds from them, so the file always agrees with the chart about which side of an edge a work item
is on.
What a By status row averages
By status has one row per status. Each row is the counted time all charted work items spent in that status during their cycle time, divided by the number of charted work items, so the rows add up to the Mean cycle time printed under them, and the sentence above them names the status that takes the longest. Time in a status outside a work item's cycle time is not in any row: in the list a row opens, the lines marked lead time only, from before work started, and the lines marked in neither total, from before an imported work item was created.
Click a row to see the work items that spent cycle time in that status. Their lines for it that are marked neither lead time only nor in neither total add up to the row's total, which is divided by every charted work item, not only by the ones listed. The note above the rows names that divisor, as each row does for a screen reader; the panel names it too, and counts the work items listed. Where a work item entered a status more than once during its cycle time, the line under its table adds up its lines for each status, and those figures add up to its cycle time.
The figures are in tenths of a day when the mean cycle time, rounded to a tenth of an hour, is a day's hours, D, or more: 24.0 hours, or 8.0 on a chart of 8-hour working days (D); in tenths of an hour when, rounded to a minute, it is 60 minutes or more; and in whole minutes below that. So a mean is written 1.0 day rather than 24.0 hours, and 1.0 hour rather than 60 minutes. They are rounded as a set, so that they add up to the mean printed under them: each row is first rounded down to a step of its unit, and the steps still needed to reach the mean, rounded to the nearest step, go one at a time to the rows that lost most in rounding down, and where two lost the same, to the row listed first. A row can therefore read one step more or less than its own mean, which the panel states to the hundredth, in the same unit.
The rows run in the order work moves through them, as far as the app can tell without reading your workflow, which it has no permission to read. First come statuses of Jira's To Do category, where work that had started was moved back; then the others, each placed by where it usually falls in the work items' histories (the median of its positions); last come your Done statuses and any other status of Jira's Done category. Statuses that fall in the same place run by name, compared by their UTF-16 character codes, so capitals come before small letters, Testing before review, whatever language your browser or Jira is in. A Done status has a row only when work was reopened after reaching it: the time from that finish to the reopening is part of cycle time. Your own choices come before Jira's categories: a status you chose as Started stands with the working statuses, and one you chose as Done comes last. The categories are read with the status names, at most an hour old. The order changes no mean; it decides only which row takes a step two rows tie for, as above.
With one group shown, an issue type, project, parent, label, component or team, each row is the counted time that group's charted work items spent in the status during their cycle time, divided by the group's count, and the note above the rows names the group. The rows keep the whole chart's order, a status none of them spent cycle time in has no row, and a row opens the work items of the whole chart's row that are in the group. The app keeps each group's time per status only while a chart has few enough groups of that kind. On a chart with too many projects, or too many issue types, By status says it cannot be split by that kind on this chart, and Show all work items goes back to the whole chart's rows.
Flow efficiency. Under the answer, a sentence states the share of the charted cycle time spent in your Started statuses, and each Started status's row is marked Started before its name (flow efficiency).
By board column. On a chart of a saved filter, Group by: Board column stands each row under the heading of the column of the board holding its status, in the board's order, Not on the board last (grouped by a board's columns). A heading's figure is the sum of the figures printed in its rows, so the rows under it add up to it as every row adds up to the mean, and each row keeps its own list: from a file exported grouped, add up the rows of the statuses A15 places in the column.
Flow efficiency: the share of cycle time in your Started statuses
Under its answer, By status states the chart's flow efficiency, as in Flow efficiency: 62% of cycle time was in your Started statuses, marked below, and 38% in other statuses between start and finish. The first figure is the counted time all charted work items spent in one of your Started statuses during their cycle time, as a share of their cycle times, in whole percent with a half rounded up. Every other status between a work item's start and its finish counts as waiting, and the second figure is that share: 100 minus the first, never rounded on its own, so the two always add up to 100%. Each Started status's row is marked Started before its name, and its name for a screen reader says a Started status. There is no setting of its own: the Started statuses in the settings are the ones counted as working time.
Neither figure reads 0% or 100% unless it is exact: a share that rounds to 100% but is not all of it reads over 99%, with under 1% beside it, and the converse. With every second in Started statuses the sentence says 100% alone, and with none, 0%, all of it was in other statuses between start and finish, and no row is marked. The tile states the figure and does not call it high or low.
The share is worked out from the same cells as the ledger export, to the ten-thousandth of an hour, and the rows above it are means rounded as a set (what a By status row averages), so it can be a point or more from what the printed rows suggest: a Started row printed 0.8 days of 1.2 is 67% of the rows, while the cells behind it can make 70%. Checking flow efficiency reproduces it from the export.
Your Started statuses are preselected from Jira's In Progress category, which often holds queues such as In Review or Ready for test, where work waits. Counted as Started, their time reads as working time, so a new tile commonly reads close to 100%. To count a queue as waiting, untick it under Started statuses in the settings: the chart is built again, and the queue's row loses its mark. Cycle time then starts at a work item's first move into a status still ticked, so a work item that reaches the queue before any other Started status starts later, and one that never enters a status still ticked is excluded as never started.
Rows are by status name, so two statuses of one name, one Started and one not, are one row, counted as
Started. A Started status since removed from your site's workflows still starts cycle time where the chart's
work items entered it, and is counted as Started under the name its history gives, with its mark and its
started_status row in the export.
With one group shown, the sentence's place says Flow efficiency is stated for the whole chart only., and the group's rows keep their Started marks. The sentence comes from a part of the tile loaded the first time By status shows it: its place is kept while it loads, so the rows under it do not move, and if it cannot be loaded the place says so, with Try again. An image or summary states it as the tile does.
Checking flow efficiency against the ledger export
Flow efficiency can be reproduced from Export data (CSV), once the file is imported as the CSV format says.
| Step | Recipe |
|---|---|
| E1 the Started statuses | The second cell of each started_status closing row: one for each Started status the charted work items spent cycle time in, in the order By status lists them, each the row marked Started. A status whose name begins with =, +, -, @ or a tab is written with an apostrophe before it, in these rows and in segment rows alike, so compare the cells as the file writes them. |
| E2 A and T | A = the sum of counted_hours over the segment rows whose in_cycle_time is true and whose status is one of E1's; in_cycle_time is true only on the rows of charted work items. Decide "one of E1's" in a helper column, SUMPRODUCT(--EXACT(status, E1's cells))>0 or its equal, never as a SUMIFS, COUNTIFS or MATCH criterion: those ignore case and read *, ? and ~ as wildcards, so a status named Ready?, or Review beside REVIEW with one of them Started, would give another A. T = the sum of issue_cycle_time_hours over the issue_total rows whose charted is true. |
| E3 the figure | In whole ten-thousandths of an hour, a = ROUND(A*10000,0) and t = ROUND(T*10000,0); p = QUOTIENT(200*a+t, 2*t), which is A / T as a whole percent with a half rounded up, exactly. Not ROUND(A/T*100,0): a spreadsheet's binary fractions can put an exact half a hair under itself, as 23 / 40 × 100 can come to 57.49999999999999 and read 57. Not Python's round, which takes a half to the even number, so 62.5 reads 62. |
| E4 what is stated | p, and the share in other statuses, w = 100 − p, never (T − A) / T rounded on its own: at A / T = 0.625, p is 63 and w is 37, where 37.5 rounded on its own is 38 and the two would add up to 101%. Except: where p is 100 and A is less than T, over 99% with w under 1%; where p is 0 and A is more than 0, under 1% with w over 99%; where A equals T, 100% alone; where A is 0, 0%, all of it in other statuses; and nothing where T is 0, which a charted work item never makes, since a cycle time counted to zero is excluded. |
What the Trend view shows
The Trend view says in its first sentence whether work is getting faster (how that sentence is decided), then shows the range period by period, by week, fortnight, month, quarter or sprint (which, and when). It has two panels over one row of columns, one column for each period, all of the same width.
- The upper panel, Cycle time per month, draws the 85th percentile of the cycle times of the work items that finished in each period as a thick step, and the 50th as a thin one, each at the exact percentile, tagged 85% and 50% at the right of the chart, level with the last step drawn, or 50% · 85% where the two read the same. A tag never covers the mark of a work item. Neighbouring steps join.
- The lower panel, Finished per month · 142 charted, has one bar for each period, counting the work items that finished in it: the sample the steps above it are computed over. The bars add up to the number in its title, which is the reconciliation line's number charted. With one group shown, the bars and the title are that group's, and the title names it, as in Finished per month · 55 charted Bug work items, as does the note under the answer.
Only charted work items are in either panel, so a period's count can be lower than the number of work items your board shows as finished in it: an excluded work item is in no period, as it is in no other view.
A period of fewer than 7 states no percentile. Under nearest rank the 85th percentile of six values or fewer is the largest of them, so a step there would be a sentence about its slowest work item. Such a period draws each of its work items as a dot, at the day it finished and at its cycle time, and the steps break on both sides of it. Pointed at, it states the slowest of them, rounded up, as the bound of all of them: All 4 within 20.1 d, or Cycle time within 2.2 h for a single work item.
The axis ends at the highest mark, or at three times the highest 85% line drawn, whichever is lower, so that one very slow work item in a quiet period does not flatten every step. A work item above it is drawn as ▲ at the top of the panel, and its period, pointed at, states the slowest of its work items. An axis that ends at a day or less is marked in hours.
Periods the range cuts. A range seldom starts on the first day of a week or a month, so its first and last periods can be cut: a 365-day range from 30 Sep 2025 to 29 Sep 2026 has one day of September 2025 and 29 days of September 2026. A cut period holds the work items that finished on its days inside the range. It is never scaled up to a whole period and never dropped, so the bars still add up. Its bar is hatched, and when nothing finished in it, a hatched strip sits under the axis. Pointed at, even when nothing finished in it, it says which of its days are in the range, as in Only 1–29 Sep is in the range, and the footer under the chart states the range's first and last day.
Periods the item cap cuts. Over the 5,000 item cap the app keeps the most recent completions, so the chart holds completions only from the day the earliest work item charted finished. A period that ends before that day is hatched, with a strip under the axis, and, pointed at, says Not charted: its completions are over the 5,000 item cap where it would state its count, so a month the cap emptied never reads as a month nothing finished in. The period that day falls in is hatched too, and says which of its days are charted, as in Only 9–31 Mar is charted: earlier completions are over the 5,000 item cap; its figures and its list are over those days, and its list is headed by them, as in Finished 9–31 Mar 2026. The key names these period cut by the item cap.
Every period opens its work items. Point at a period, or move to it with Tab, and it states how many work items finished in it and its 85% and 50%, each rounded up as every "within" figure is (why). Click it, or press Enter, and the panel lists exactly those work items, headed Finished in Aug 2026 for a whole month and by its days in the range otherwise, as in Finished 1–29 Sep 2026. Export this list (CSV) in that panel gives them as a file whose closing rows restate the period's figures (the recipe). A period nothing finished in opens nothing and is not a stop on the Tab path.
The key under the chart names only the marks it draws, such as 85% of each period or period cut by the range. The chart's whole-range figures follow it, after Whole range:, as on the other views. Over the item cap they are over the charted days only, and follow All charted work items: instead, or, with one group shown, a label naming it, such as All charted Bug work items: or All charted work items labelled api:. A fortnight here is two calendar weeks, not a Jira sprint. For Jira's sprints, choose Sprint (how).
Weeks, fortnights, months, quarters and sprints in the Trend view
A work item is in the week, fortnight, month or quarter that holds the day it finished, in the chart's
time zone: the date its left_at cell in the ledger export starts with. Those periods are the
calendar's, the same for everyone on every day, so a period keeps its name from one day's chart to the
next.
- A week runs from Monday to Sunday.
- A fortnight is two weeks from a Monday, every second Monday counted from Monday 5 January 1970: 3–16 Aug 2026 is one, and so is 22 Dec 2025 – 4 Jan 2026. It is a calendar period and does not follow your board's sprints. For Jira's sprints, choose Sprint (how).
- A month is a calendar month.
- A quarter is a calendar quarter: January to March, April to June, July to September or October to December.
- A sprint is one of your Jira sprints, from when it started to when it closed (which work counts in which sprint).
Each range opens on a size of its own, and offers others where they fit:
| Range | Opens on | Also offered |
|---|---|---|
| Last 30 days | Week | Fortnight |
| Last 90 days | Fortnight | Week, Month |
| Last 180 days | Fortnight | Week, Month |
| Last 365 days | Month | Fortnight, Quarter |
A size is offered when the range holds from 3 to 27 of its periods, cut ones included, and each column is at least 12 px wide at the gadget's width. So a 365-day range, which holds 53 weeks, never offers weeks, and a narrow gadget offers fewer sizes: at 280 px, the narrowest it draws, a 365-day range fits only months and quarters, and a 180-day range only fortnights, months and the quarters it offers. Where only one size fits, there is nothing to choose and the Period control is not shown. One 30-day range a year also offers months: the one charted on 2 March in a year that is not a leap year, which runs from 31 January to 1 March and so touches three months. A 180-day range offers quarters when it touches three of them, as it does unless it starts on one of the first few days of a quarter, at most the first five, and so ends within the quarter after. Custom dates of a few days hold fewer than 3 periods of any size, and then the Trend view is not offered. Sprint is never a range's own size: it is offered when the range holds 3 to 27 sprints, None included, that fit the width.
The size you choose under Period is kept by your browser for that gadget, and never sent to the app or to Jira (privacy). Where the gadget's width does not offer it, the range's own size is drawn instead, or the longest size offered when that does not fit either, and your choice comes back when the gadget is wide enough again; Sprint comes back, too, on a chart that holds 3 to 27 sprints again. Another browser, or this one with its site data cleared, opens on the range's own size.
Whether work is getting faster: the Trend view's sentence
The Trend view's first sentence compares the two halves of the chart's range. The range is split on its middle day, the first day plus half its length in whole days: a 365-day range from 30 Sep 2025 to 29 Sep 2026 splits on 31 Mar 2026, so its earlier half is the 182 days before that day and its later half the 183 from it. A work item is in the half its completion date falls in, in the chart's time zone. The sentence does not depend on the period size: weeks, fortnights, months and quarters divide the same range.
Over the 5,000 item cap the halves are those of the days the chart holds completions from, not of the range: the app keeps the most recent completions, so the earlier half of the range would hold only its last weeks, or nothing. The charted days start on the day the earliest work item charted finished, and the split day is that day plus half the days from it to the range's last day, counting both, rounded down. The sentence then compares the later half of the charted days, and the note under it says where they start, as in The chart holds completions from 9 Mar 2026: earlier ones are over the 5,000 item cap, so the halves split the days from then.
For each half it states the 85th percentile of cycle time, rounded up as every "within" figure is (why), and the note under it states how many charted work items finished in each half. It says faster or slower only when the two figures, as printed, are at least 10% of the earlier one apart: against 13.2 days before, 11.8 days or less is faster, 14.6 days or more is slower, and anything between reads as about the same. Rounding up never reverses an order, so a lower printed figure is never a higher exact one. With fewer than 20 charted work items in either half it compares nothing, and says how many each half holds. The 10% and the 20 are a judgement of when a difference is worth stating, not a statistical test. When the sentence states a verdict, the two figures are drawn across the chart as dashed lines, each over its own half.
To check it from the ledger export, keep the issue_total rows whose charted is true. A row is
in the later half when the first ten characters of its left_at, its completion date in the chart's
time zone, are on or after the split day, and in the earlier half otherwise; do not convert
left_at through its offset. Count each half. Its 85th percentile is the issue_cycle_time_hours
at position ROUNDUP(85*n/100, 0) in ascending order, where n is the half's count (not
PERCENTILE, which interpolates), rounded up as the section above says. The next section has the
recipe for every figure in the view.
Sprints: which sprint a work item counts in
Where your site has a Sprint field, the app reads the sprints each work item of your chart is or was
in, with the reads it already makes of each work item, and the ledger export names, for each finished work item, the
sprint it counts in (the CSV format). A finished work item counts in the sprint it
finished in: of the sprints its Sprint field lists, a sprint holds it when the sprint had started
by the instant the work item finished, the instant its issue_total row's left_at gives, and either
closed after that instant or is still running. Where two hold it, it counts in the one that closed
first, a running sprint closing last, then in the one that started first, then in the one with the
smaller id. Where none holds it, it counts in no sprint.
- Carried-over work lists every sprint it was in and counts in the one it finished in: a work item in Sprint 1 and then in Sprint 2, finished during Sprint 2, counts in Sprint 2.
- Instants, not days. A sprint that closed at 16:00 does not hold work finished at 16:00 or later that day, and a work item finished at the instant a sprint started is in it.
- In no sprint is work finished after its sprint closed and before the next started, as when statuses are tidied after a sprint is completed, and work finished in the backlog and added to a sprint that started later.
- Parallel and overlapping sprints, and several boards in one saved filter, follow the same rule, and no sprint is merged with another: a work item two of its sprints hold counts once, in the one that closed first.
- A sprint with no dates holds nothing: a future sprint, whose planned dates the app does not keep, and a closed sprint Jira holds no start or close for. A work item that lists only such a sprint counts in no sprint, and the file still lists that sprint, with its dates blank, so you can see why.
- A sprint's dates are those Jira holds for it when the chart is built: its start date and the date it was completed. A sprint whose dates are edited later keeps the chart's dates until the next chart is built.
- Why the figures can differ from Jira's Sprint report: a work item counts by when it entered one of your Done statuses, not by where it stood on the board when the sprint was completed, and one added to a sprint after it finished, while that sprint was running, counts in it.
- At most 100 sprints are kept for one chart. Past that, the file names no sprint and says so in one row, and the Trend view offers no Sprint.
The Trend view by sprint. Sprint under the Trend view's Period draws one column for each sprint your chart keeps whose time overlaps the chart's range, in the order they started, two that started at the same instant by the smaller id, then a column None for the work that finished outside every sprint it was in. Every charted work item is in one column, so the bars add up to the charted count, as every period's do, and each column's 85% and 50% are its own work items' (the recipe). Under the chart each column is labelled by the day its sprint started, thinned as week labels are, and None always, after a dashed rule. Pointed at, a column names its sprint as Jira names it to you, with its days, as in SPR Sprint 2, 14–27 Sep 2026 or SPR Sprint 3, from 28 Sep 2026, still running; a sprint the range cuts, or one still running, is hatched as a cut period is, and the key says sprint cut by the range. A column opens its work items, headed Finished in SPR Sprint 2, and None's Finished outside sprints. A column the range or the item cap cuts holds only its work of the days it says are in the range or charted, as a cut period does, and its list is headed by those days first, as in Finished 1–13 Sep 2026 in SPR Sprint 1 or Finished 5–30 Sep 2026 outside sprints. The sentence over the chart still compares the range's two halves, and no half lines are drawn: sprints can overlap, so their columns are not one line of days. Sprint is offered as every size is (when), and never on a chart that keeps no sprints.
A chart of the last closed sprint. Last closed sprint in the Date range searches the work your saved filter finished in the 90 days before today, as Last 90 days does, and its work in progress now, and of the sprints that work was in takes the closed one that closed last before today, the smaller id where two closed at the same instant. Its chart runs from the instant that sprint started to the instant it closed, and holds the work that counts in it by the rule above. A sprint none of whose work has finished and none of whose work is in progress now, all of it back in a To Do status or out of the filter, is not found: the chart then names the sprint before it, and the name and dates on its face show which it is. A sprint that closed today is the last closed sprint from tomorrow. On such a chart:
- the period before is the sprint before it on its board, the closed sprint there that closed last before it, found in the same work (how it is compared);
- the Aging view sets your saved filter's work in progress now, not the sprint's, against the sprint's lines, as it does for a past quarter;
- the Flow view's first and last days are parts of days, said with the times the sprint started and closed, as in 14 Sep 2026 from 09:30 and 27 Sep 2026 to 16:00, and its means per day count both parts as days;
- the Forecast view says the range ended on the day the sprint closed;
- work the app may not read is counted as on every chart, from the 90 days searched: whether it was in the sprint is not known, and the line under the chart and its list say so.
A sprint's name. The app keeps no sprint's name. When the tile names the sprint of a chart of the last closed sprint or of the sprint before it, when its Trend view is divided by sprint, and when your export lists sprints, it reads each one's name as you, from one work item of your chart that was in it, and shows it to you or writes it in the file; Jira answers with the names you may see. The Trend view reads them once, when it first draws your chart by sprint, and keeps them only while the tile is open. A sprint Jira does not name for you, such as one deleted since the chart was built, is named on the tile as the last closed sprint or the sprint before, with its dates, in the Trend view as A sprint Jira does not name for you, with its days, and written in the file without a name; its id, its dates and your work items in it are shown all the same. When the tile's read fails it names the sprint the same way, and the Trend view names each column by the day its sprint started, as in Sprint starting 14 Sep 2026, as it does until the names arrive, with Try again under the chart. Image or summary reads no name: its columns are labelled by the days they started. When the export's read fails, the export says it failed and you can ask again: a file never holds a blank name for a sprint the read did not reach.
How the Sprint field is found. About once an hour, at a chart's build, the app reads your site's
list of fields as itself and takes as a Sprint field every field whose type is Jira Software's sprint
type, whatever it is called. It reads up to five such fields, the lowest-numbered first, and a sprint
listed in two is read from the first. Jira lists to the app only the fields used in projects the app may
browse. A site with no Sprint field has no sprints in its files, and their sprint and sprints cells
are blank, its Trend view offers no Sprint, and a chart of Last closed sprint says No Sprint field
found: the app found none, which
can also mean an app access rule keeps the app from the projects that use one. When the field list
cannot be read, or a work item's Sprint field holds a value in a shape the app does not read, the chart
keeps no sprints, its Trend view offers no Sprint, and its file says so (sprints_not_read) rather than
place every work item in no sprint; a chart of Last closed sprint then fails to build and is tried again, or says Sprints could
not be read.
Checking the Trend view against the ledger export
Every figure the Trend view states can be reproduced from Export data (CSV) in a spreadsheet, in
the steps below. The formulas work in Excel and LibreOffice Calc once the file is imported as
the CSV format says, which keeps left_at as text.
The rows. Keep the rows whose
row_typeisissue_totaland whosechartedistrue. For each, D is the first ten characters of itsleft_at,LEFT(left_at, 10): the date it finished, in the chart's time zone. Do not convertleft_atthrough its offset, which moves a work item that finished near midnight into another day. H is itsissue_cycle_time_hours.Its period. Month:
LEFT(D, 7), such as2026-08. Quarter:YEAR(DATEVALUE(D))&"-Q"&ROUNDUP(MONTH(DATEVALUE(D))/3, 0), such as2026-Q3. Week: the Monday it starts on,DATEVALUE(D) - MOD(DATEVALUE(D) - DATE(1970,1,5), 7), shown as a date. Fortnight:DATEVALUE(D) - MOD(DATEVALUE(D) - DATE(1970,1,5), 14).A bar. Count the rows in each period. The counts add up to the number in the lower panel's title, which is the reconciliation line's number charted and the count on the file's
cycle_timeclosing rows.A step, for a period of 7 or more. With
nrows in the period, its 85% isSMALL(H, ROUNDUP(85*n/100, 0))over the period's H cells, and its 50% isSMALL(H, ROUNDUP(50*n/100, 0)). Then round up as why a "within" figure is rounded up says. Do not usePERCENTILE, which interpolates between two work items.A period of 1 to 6.
MAX(H)over the period, rounded up the same way: the figure in All 4 within 20.1 d, or in Cycle time within 2.2 h for a single work item.One period, the short way. Open the period and use Export this list (CSV). The file's closing rows are computed over exactly that period's work items: for a period of 7 or more, its
cycle_timerowsp50andp85, rounded up, are its two steps; for a smaller one,p85is its slowest work item; and their count is its bar. Itslead_timerow gives the period's lead time, which the Trend view does not draw.The halves and the sentence. The later half starts on the split day, which the note under the sentence names: the footer's first day plus half the range's length, rounded down, which is 15, 45, 90 or 182 days for a range of 30, 90, 180 or 365 days. A row is in the later half when
D >= S, comparing D with the split day S as text, as in2026-03-31, and in the earlier half otherwise. Count each half, and take each half's 85% as in step 4. Write both printed figures as whole seconds,ROUND(days * D * 3600, 0)for a figure in days, D as in why a "within" figure is rounded up,ROUND(hours * 3600, 0)for one in hours, andminutes * 60for one in minutes, so that the comparison is exact: 12 days and 10.8 days, exactly 10% apart, are 1036800 and 933120 seconds, whereas compared in days or in hours a spreadsheet's rounding error puts them just under 10% apart. Whole seconds are exact on every chart; whole minutes are not where a tenth of a day is not a whole number of minutes, as on a chart whose average working day is 7.2 hours, a tenth of which is 43.2 minutes. Withearlierandlaterthose two numbers, the sentence says faster when the later figure is lower and10*(earlier - later) >= earlier, slower when it is higher and10*(later - earlier) >= earlier, and about the same otherwise. With fewer than 20 rows in either half it compares nothing. The dashed lines are these two 85% figures, drawn at their exact values.When the reconciliation line shows work items over the 5,000 item cap, the halves split the charted days instead. Let C be the earliest D among the rows of step 1: the day the chart holds completions from, which the note names. The split day S is C plus half the number of days from C to the footer's last day, counting both, rounded down, and every row is on or after C.
A cut period. A period that starts before the footer's first day, or ends after its last, is cut by the range, and its figures are over its days between them, which it names when pointed at: Only 1–29 Sep is in the range. Over the item cap, a period that ends before C is not charted, and the period that holds C is cut by the cap: its figures are over its days from C, as in Only 9–31 Mar is charted: earlier completions are over the 5,000 item cap.
By sprint: the rows, the bars, the steps and the names. Steps S1 to S4 of checking the sprints against the ledger export: stop where the file's marker row says it holds no figures by sprint; otherwise group the rows of step 1 by their
sprintcell, a sprint's id or blank for None, count each group for its bar, and take its steps as in step 4, or its slowest as in step 5; each sprint'ssprintrow gives the day it started, the first ten characters of itsentered_at, which labels its column, its close and its name.By sprint: which sprint each row counts in. Steps S5 to S8 of checking the sprints against the ledger export check each row's
sprintcell against its sprints' instants, and that no row in None had a sprint holding it.
The key after Whole range: restates the file's closing rows, as on the other views (why a "within" figure is rounded up).
Checking the sprints against the ledger export
The sprints a file names (the CSV format) can be checked in a spreadsheet, in the steps below, or with the Python under them.
- S1, the rows. First, if the file has a
sprintrow whosesprintcell is blank, itsexclusion_cause,sprints_not_readorsprints_withheld, says why the file holds no figures by sprint: stop there. A file of a chart of the last closed sprint keeps its own sprint's row and cells even then, and S6 still holds on it. Otherwise keep theissue_totalrows whosechartedistrue. G is a row'ssprintcell: a sprint's id, or blank for none. H is itsissue_cycle_time_hours. - S2, a sprint's count. Count the rows of each G. The counts add up to the count on the file's
cycle_timeclosing rows. - S3, its steps. For a G with 7 or more rows,
SMALL(H, ROUNDUP(85*n/100,0))andSMALL(H, ROUNDUP(50*n/100,0))over its H cells, rounded up as why a "within" figure is rounded up says; for 1 to 6,MAX(H)rounded up the same way. NotPERCENTILE. - S4, a sprint's dates and name. The
sprintrow whosesprintcell is G:entered_atis when it started,left_atwhen it closed (blank: still running),statusits name as Jira named it to you when you exported (blank: not named for you), andexclusion_causeits state. - S5, which sprint: the audit. For a row, the ids in
sprintsare its sprints the file lists. A listed sprint holds the row when itsentered_atis not blank and is not later than the row'sleft_at, and either its state isclosedand itsleft_atis later than the row's, or its state isactive. Compare instants, not text: the offsets differ across a clock change. In a spreadsheet, an instant in days isDATEVALUE(LEFT(x,10))+TIMEVALUE(MID(x,12,8))+IF(MID(x,20,1)=".",VALUE(MID(x,21,3))/86400000,0)-IF(RIGHT(x,1)="Z",0,IF(LEFT(RIGHT(x,6),1)="-",-1,1)*TIMEVALUE(RIGHT(x,5))), to the millisecond the file prints, which it does whenever an instant has one. Of the sprints holding the row, G is the one with the earliest close, a running one last, then the earliest start, then the smallest id; with none holding it, G is blank. - S6, a chart of the last closed sprint. On such a file every charted row has the same G, the
chart's sprint, whose
sprintrow is always in the file; the file can hold othersprintrows, of overlapping sprints its rows list. Each charted row'sleft_atis at or after thatsprintrow'sentered_atand before itsleft_at, as instants. The closing rows are the chart's, as on every chart. - S7, the sprint before. With L that chart's file and E the file of the sprint before it: the
sprintrow of E's charted rows' G has aleft_atbefore that of L's, and noissue_keyis charted in both. The verdict is the period before's, unchanged. - S8, none. Every row with a blank G has no listed sprint holding it by S5.
In Python 3.11 or later: python3 sprints.py cycle-time-ledger-2026-07-07-to-2026-10-04.csv prints
each sprint's count of charted rows, then None's, and the keys of any row whose sprint cell is not
the one S5 gives, or none.
import csv, sys
from datetime import datetime
with open(sys.argv[1], newline='', encoding='utf-8-sig') as f:
rows = list(csv.DictReader(f))
marker = next((r['exclusion_cause'] for r in rows if r['row_type'] == 'sprint' and r['sprint'] == ''), None)
if marker is not None:
print('no figures by sprint:', marker)
sys.exit()
sprints = {r['sprint']: r for r in rows if r['row_type'] == 'sprint'}
at = datetime.fromisoformat
def holds(s, t):
if s['entered_at'] == '' or at(s['entered_at']) > t:
return False
return s['exclusion_cause'] == 'active' or (s['exclusion_cause'] == 'closed' and s['left_at'] != '' and at(s['left_at']) > t)
def order(s):
running = s['exclusion_cause'] == 'active'
return (running, 0 if running else at(s['left_at']), at(s['entered_at']), int(s['sprint']))
counts, wrong = {}, []
for r in rows:
if r['row_type'] != 'issue_total':
continue
holding = [] if r['left_at'] == '' else [s for s in (sprints[i] for i in r['sprints'].split()) if holds(s, at(r['left_at']))]
g = min(holding, key=order)['sprint'] if holding else ''
if g != r['sprint']:
wrong.append(r['issue_key'])
if r['charted'] == 'true':
counts[g] = counts.get(g, 0) + 1
for g in sorted(counts, key=lambda g: (g == '', int(g) if g else 0)):
print(g or 'None', counts[g])
print('not the sprint S5 gives:', ' '.join(wrong) or 'none')
Comparing a chart with the period before
Tick Compare with … on the tile, under the chart and above its key, and the tile sets your chart beside the period before it, as in Compare with Q1 2026, with that period's dates beside the box, and the comparison takes the key's place, under the box. The tick is yours: it is kept by your browser for that gadget, no one else's tile changes, and another browser starts without it (privacy). On a tile of several saved filters side by side it is offered for a saved filter shown on its own, by pressing its row, and on the table of all of them, once every row is ready, where the tick is not kept (how).
Which period. One rule for every Date range:
- the last 30, 90, 180 or 365 days: as many days before them, the 90 days before;
- the last full month or quarter: the month or quarter before, Jul 2026 or Q1 2026;
- custom dates that have ended: as many days before their first day;
- a range charted to yesterday, This quarter so far or custom dates not yet over: as many days of the period before as the chart has, from its start and never past its end, as in the first 45 days of Q2 2026. So a quarter is compared with the same point of the quarter before, and sprints of one length, back to back, with the same days of the sprint before;
- a chart that includes today: today counts as one of its days, so the period before is as many whole days, from its start and never past its end, named by its dates;
- the last closed sprint: the sprint before it on its board, closed before it (which), named as Jira names it to you once its chart is in, and until then the sprint before.
There is no comparison when the period before would start before 1 January 2015, where the holiday tables start, nor on a chart with nothing charted.
A chart of its own. The period before is searched as you, over its own days, with the same
saved filter, and built and kept the same way as your chart, but only once you tick the box and your
chart is ready. The sprint before a chart of Last closed sprint is searched over the same 90 days and
charts the work that counts in it; when its board has no sprint before it in the work searched, or it
started more than 90 days before today, the line under the headline says so and nothing is searched. Its build takes its turn as any build does, and the line under the headline says how
far it has got. If it fails, the line says so, your chart is unaffected, and it is tried again at your
next view after ten minutes. Under the table, See Q1 2026 lists its work items in the drill
panel, each with its arithmetic, and Export Q1 2026 (CSV) gives its own ledger; each ledger's file
is named by the days it covers, as in cycle-time-ledger-2026-01-01-to-2026-03-31.csv.
The verdict. The line under the headline compares the two 85th percentiles as the tile prints them, rounded up (why), as in Faster than Q1 2026, when 85% finished within 5.8 days. It says faster or slower only when they are at least 10% of the earlier one apart, and only with 20 charted work items in each period; with fewer it says Too few for a verdict. and states the period before's own figure. The 20 and the 10% are a judgement of when a difference is worth stating, as for the Trend view's halves, not a statistical test, and no percentage change is given. Over the 5,000 item cap a chart covers only its latest completions, fewer days than its range, so when either chart is over it there is no verdict. A team's sprints often hold fewer than 20 charted work items each, so the last closed sprint and the sprint before it are usually stated side by side without a verdict. The two comparisons can both be true: the Trend view compares your range's two halves, and says so while the tile compares.
The table. While the tile compares, a table of both periods takes the key's place under the
chart: each one's 50%, 85% and 95%, lead time's 85%, and the charted and excluded counts its
reconciliation line states, each over its own work items and rounded up. As in Compare, a 50% or an 85%
is stated from 7 work items, a 95% from 20 and lead time's from 7, since under nearest rank a smaller
group's percentile is simply its slowest work item; an 85% of 2 to 6 reads All 4 within 4.3 d,
and a dash says what the figure needs. A grey dashed line on the histogram and the scatter marks the
period before's 85%, tagged with its name, as in Q1 2026 85%, or, for the sprint before, Sprint before
85%, since a sprint's name can be long. With one group
shown, the comparison is withheld, since the period before is the whole chart's. While a
target is shown on a view that draws it, the table adds a Within 5 d row: each period's share of
its charted work items within the target, rounded down, its count on pointing at it, the period before's
counted on its cycle times in whole minutes rounded up, which decide exactly as its ledger does; one built
before the app could read them reads —, and says why: The period before was built before targets could be
read; refresh tomorrow. Every figure can be
checked from the two ledger files with the recipe.
Checking a comparison with the period before against the ledger exports
When the tile compares a chart with the period before it, the period before is a chart of its own, built the same way, and every figure of the comparison can be reproduced from two standard ledger files, imported as the CSV format says. The chart's own file is L and the period before's is E.
| Step | Recipe |
|---|---|
| C0 files | Export data (CSV) for L, and the period before's own export, such as Export Q1 2026 (CSV), for E. |
| C1 figures | In each file, the closing row with cycle_time as its issue_key and p85 as its row_type gives the 85th percentile in hours (its third column) and how many charted work items it is over (its fourth). |
| C2 printed | Round each 85th percentile up as why a "within" figure is rounded up says, which gives the figure the tile prints. Then write it in whole seconds, ROUND(days*D*3600,0) for a figure in days, 86400 seconds a day of 24 hours, ROUND(hours*3600,0) for one in hours, and minutes*60 for one in minutes. |
| C3 verdict | With both counts 20 or more, and E and L the two figures in seconds: faster when L is lower and 10*(E-L)>=E; slower when L is higher and 10*(L-E)>=E; otherwise about the same. With fewer than 20 in either file there is no verdict. |
| C4 the cap | A file is over the 5,000 item cap when the fifth column of its cycle_time,p85 row, the excluded count, is greater than COUNTIFS(row_type,"issue_total",charted,"false"): work items over the cap are counted there and have no rows. When either file is over the cap there is no verdict. |
| C5 apart | Every row of E whose row_type is issue_total and whose charted is true has LEFT(left_at,10) on or after the period before's first day and on or before its last, and no issue_key is charted in both files. |
The verdict is decided on the figures as printed, not on the exact percentiles: 6.11 days against
6.79 days is 10.05% apart, but they print as 6.2 days and 6.8 days, 8.8% apart, which is about the
same. Whole seconds make the comparison exact on every chart: 12 days and 10.8 days, exactly 10% apart,
are 1036800 and 933120 seconds, whereas in days a spreadsheet's rounding error puts them just under 10%
apart, and in whole minutes a tenth of an average working day of 7.2 hours, 43.2 minutes, is rounded. Do
not use PERCENTILE, which interpolates between two work items. The 20 and the 10% are a judgement
of when a difference is worth stating, not a statistical test.
Over the cap, a chart keeps its most recent 5,000 completions, so its 85th percentile covers fewer days than its range, and comparing it would compare two different spans. C5 holds because a work item is charted in the period its last completion falls in: one finished in the period before, reopened and finished again in the chart's days is charted in the chart only, with its whole cycle time.
Including today
A chart whose Date range runs into today, This quarter so far or custom dates whose last day is today or later, offers Include today on the tile, under the chart and after Compare with …, or, while nothing is charted, under the line that says why. It is offered on such a range's first day too, when there is no complete day to chart yet. Tick it and your chart is built again, as you, from a fresh search of yours, unless one built from the same search is already there, over the range's days up to the start of the current quarter hour, and the tile says so: the headline reads From 17 Sep 2026 to 15:00 on 30 Sep 2026, 85% … and the footer Custom dates, 17–30 Sep 2026, charted to 15:00 on 30 Sep 2026, when you asked. The time is in the gadget's time zone, like every date on the tile, which Time zone, build time and method names at the end of the footer's first line. Work items completed after that quarter hour are not in it. While it is read, the chart of the days before today stays on screen, and the line beside the box says how far the reading has got. On a tile of several saved filters side by side it is offered for a saved filter shown on its own, and not on the table of all of them.
Tick it again within the same quarter hour and the tile shows the chart already built; in a later
quarter hour it is built again, to that one, so at most one such chart a quarter hour is built from your search
and the gadget's settings. Each is a full build of your chart, reading the whole range from Jira again,
and takes as long as your first view of the day does. Everything on the tile is then of that chart:
its lists, the period before and its export, whose file name ends with the time, as in
cycle-time-ledger-2026-09-17-to-2026-09-30-1500.csv. In that file, a work item still open, or moved
back after Done, has a last row that ends at that quarter hour. The Trend view counts today
as the range's last day, and so does the period before: today is one of the range's
days, so the period before is that many whole days from its start, named by its dates.
Nothing is remembered: untick the box, reload the dashboard or come back tomorrow, and the tile shows the chart of the days before today again. To have only the ages of work in progress measured again, on any Date range and without rebuilding the chart, tick Measure ages when this view opens on the Aging view instead. Past midnight the chart you asked for is a day old, and a list or an export from it redraws the tile without it. If it cannot be read, the line beside the box says so, the box is unticked and the chart on screen is unaffected; a failed build is tried again when you tick the box at least ten minutes later.
One group on its own: an issue type, a project, a parent, a label, a component or a team
Where the chart's work items fall into two or more groups of one kind, Show above the chart views narrows the whole chart face to one group. It lists All work items with the number charted, then the groups of each kind, under Issue type, Project, Parent, Label, Component and Team in that order, each by name with the number of charted work items it holds; a kind with only one group is not listed, and a chart with one group of each has no Show. Issue types are grouped by their exact name, across projects: a team-managed project's Story and a company-managed project's Story are one group, and bug and Bug are two. A work item is in the issue type it had when the chart was built, under that type's name then: a work item whose type changed during the range is in its new type, an issue type renamed in Jira is listed by its new name from the chart's next build while an export made before keeps the old one, and a type renamed to another type's name joins that type's group. Work items the app read no issue type for are listed as No issue type. A work item's project is the part of its key before the first hyphen, so the split by project reads nothing about a project from Jira, and a work item moved to another project is in the one its key named when the chart was built. A sub-task is in the group of its own issue type, not its parent's, and in its parent's project, whose key it carries.
A work item's parent is its epic, or for a sub-task the work item it belongs to; its labels, the names of its components and the name of its team in Jira's Team field are read with it when the chart is built. Labels, components and teams are grouped by their exact name, as issue types are: two components named Backend in two projects are one group. A work item with two labels is in both labels' groups, and one with none is in No label; the same for components, in No component; one with no team is in No team. A team is named as the Team field gives it to the app, and whether Jira would show you that team is not checked (who can see a chart). These four kinds are listed once the tile has loaded their words, the first time a chart has two groups of one of them; until then Show lists issue types and projects.
A parent is named only to someone who can open it. Each time the chart is shown to you, the app asks Jira, as you, which of its work items' parents you can open, by their ids, and reuses the answer for up to five minutes. A work item whose parent you cannot open is in No parent you can open, with the work items that have none, and nothing on the tile says how many such parents there are. Parents are named by their keys, as in PAY-12 (14). The first time you choose a parent under Show, or have Compare list parents, the app reads, as you, the summaries of the parents you can open, at most 200 in two requests, and names each with its summary, cut at 60 characters where a list names it, as in PAY-12 Checkout redesign (14), and whole where the group is named on its own. The summaries are shown, and never stored. With more than 200 parents you can open, none is read, and while a parent is shown or Compare lists parents the tile says Parents are named by their keys: these work items have 214 parents you can open, more than the 200 the tile names in full. When the app could not check which parents you can open, it names none, every work item is in No parent you can open, and the tile says Parents could not be checked as you just now, so none is named. Refresh the dashboard in a few minutes.
With a group shown, the headline, the histogram, the scatter, the Trend view, By status, the key and the values to the minute are the chart that group's work items alone draw, by the same rules, lead time among them, over the group's charted work items and those of it that never entered a started status, as in 85% of the 55 charted Bug work items finished within 2.9 days of starting, or of the 14 charted work items under PAY-12, labelled api, in component Backend, of team Payments. The line under the headline names the group and its count, as in Issue type Bug only: 55 of the 228 charted work items, or Parent PAY-12 Checkout redesign only, Label api only; List these 55 there opens the group's work items, and Show all work items goes back. With Lead time chosen, the group's face is its lead time, as in Issue type Bug only: 12 of the 27 work items with a lead time, and List these opens the group's work items with a lead time and those of it without one (L6); the reconciliation line under the chart is then the whole chart's in lead time. Every list a mark of the group's face opens is headed with the group, as in Issue type Bug · Cycle time 12–18 hours, and each work item in a list shows its issue type after its key.
Some figures are not split, and the line under the headline says so:
- The reconciliation line. The number charted, the number excluded and each reason's count are the whole chart's, and a reason opens the whole chart's work items.
- The item cap. Over the 5,000 item cap every group is drawn from the 5,000 most recent completions, and the chart holds completions only from the day the earliest of them finished, whatever its group. So the Trend view marks a group's periods as cut by the cap where the chart's are, not from the group's own first completion. On a chart that is not over the cap, a group's face is the chart a saved filter holding only its work items would draw.
The choice is not remembered: a reload opens on all work items, and no group's name is kept in your
browser. To chart one group every time, save a filter for it. A file the tile gives under Show names the
group by its short name, a parent by its key, and never by a summary. Each figure a group's face states can
be checked against the ledger export with the recipe, whose parent, labels, components
and team columns hold the four (the values). To see every group of a kind side by
side instead, use Compare.
Groups side by side
Compare, the chart view after By status, is offered on the charts Show is. It has one row per
group of one kind, issue type, project, parent, label, component or team, among the work items shown,
all of them or the group Show narrows to, side by side on one scale. Compare by, a list of the kinds
the work items shown have two or more groups of, chooses which, and is remembered for the gadget in your
browser as that one word, such as label; it starts on issue types or projects, whichever the chart has
more groups of, issue types on a tie, and so does a browser that keeps nothing. Where the work items shown
have only one kind with two or more groups, the view lists that kind, and a choice of another is kept for
when it is offered again.
By label or by component, a work item can be in several rows. A work item with the labels api and mobile is a row's work item in each, counted once in each, so the rows add up to more than the work items shown, and a line under the answer says by how many, as in 12 of these work items carry more than one label, so each is in each of its rows: the rows add up to 140, more than the 128 shown. Nothing is pooled or divided between rows. By issue type, project, parent or team, each work item is in one row.
Each row states how many work items it holds and its 50%, 85% and 95%, rounded up, but its 50% and 85% only from 7 work items and its 95% only from 20: under nearest rank the 85th percentile of 6 work items or fewer, and the 95th of 19 or fewer, is simply the slowest of them. A smaller row states that instead, as in All 4 within 28.9 d, or for one work item Cycle time within 10.8 d. While a target is shown, a Within 5 d column after 95% states each row's share of its work items within it, rounded down, its count on pointing at it and in the row's name. Each row's strip draws every one of its work items as a dot and the percentiles it states as orange ticks, on one scale for every row. The scale ends at the slowest work item, or at twice the highest 85% any row states if that is lower, so one slow work item cannot squeeze every other row; a row with work items beyond it draws ▸ at its end, and states them in its figures and its list.
Every figure in the table is in one unit, the scale's: hours when the scale ends within a day, days otherwise, so each column reads down without an hour among days. Each is rounded up in that unit, to a tenth, and never below 0.1: a row whose 50% is 23.2 hours reads 1 d in a table of days, and a row of work that took 40 minutes reads 0.7 h in a table of hours. From 100 days a figure is in whole days, as everywhere on the tile. The sentence above the rows and the sort by 85% use the figures as the table prints them, and rows printing the same figure are named together. A row's list and its export (CSV) keep the exact hours.
Pressing a row lists its work items, headed with its group, as in Project PAY, or with both groups while Show narrows the chart, as in Bug in PAY or Backend in api. A parent's row is named by its key, and with its summary cut at 60 characters once the tile has it; its list's heading names it whole. The rows come largest first; the column heads sort them by 85%, quickest or slowest first, with the rows too small for an 85% last either way, or by name, and the sort is not remembered. Up to 22 rows are listed, or 10 below 480 px; past that the first 20, or 8, and a count of the others, with Show all to list every row in a box that scrolls under the column heads. No row pools two groups, and there is no total row: the key under the view states the figures of all the work items shown.
The sentence above the rows ranges over the rows with 20 or more work items, the sample the Trend view's halves need, as in Across the 7 projects with 20 or more work items, 85% finished within 3.3 days (CHK) to 8.6 days (MOB) of starting. It takes each row's 85% as the row prints it, rounded up, and names every row that prints the lowest or the highest. It is a range, not a ranking, and a row of fewer than 20 is not in it, however quick or slow. It names a parent's rows by their keys. Where the work items shown are in one group of each kind, Compare says there is nothing to compare.
Checking one group against the ledger export
Every figure the tile states for one group, shown on its own or in Compare, can be reproduced from Export data (CSV) in the steps below, once the file is imported as the CSV format says. A group is the charted work items of one issue type, by its exact name, or of one project, by the part of the key before the first hyphen; either kind's groups add up to the whole chart. A parent, a label, a component or a team is a group by S9 to S12 below. A group's lead time is S13.
| Step | Recipe |
|---|---|
| S0 setup | Export data (CSV). Keep the issue_total rows where charted = true. Let H be issue_cycle_time_hours. |
| S1 group | issue_type = the name (exact; a blank cell is "No issue type"), or project = the key. |
| S2 count | n = the group's rows. Each kind's groups add up to the reconciliation line's charted count and to the count on the file's cycle_time closing rows. |
| S3 percentiles | SMALL(H, ROUNDUP(p*n/100, 0)) for p = 50, 85, 95, then round it up. Never PERCENTILE. Compare states p only from n ≥ 2 / 7 / 20, and shows 50 together with 85. |
| S4 small group | MAX(H), rounded up: "All n within". For n = 1, that one cell. |
| S4b Compare's unit | Compare states S3 and S4 in one unit. Its scale ends at E = the largest H of all the groups, or twice the largest S3 85th of a group with n ≥ 7 if that is lower. If E ≤ D, every figure is in hours: ROUNDUP(x, 1), at least 0.1. Otherwise in days: ROUNDUP(ROUND(x/D, 6), 1), at least 0.1, or ROUNDUP(ROUND(x/D, 6), 0) from 100 days. D is 24, or the file's working_day row's hours (why). |
| S5 a group's histogram | The width is the smallest w of 0.25, 0.5, 1, 2, 3, 5, 7, 10, 14, 21, 30, 60 and 90 days with ROUNDUP(ROUND(MAX(H)/D, 6)/w, 0) ≤ 24, else ROUNDUP(ROUND(MAX(H)/D, 6)/24, 0) days, of D hours; the other 24s are counts of bars. Bars are [lo, hi) with the last closed, and running counts follow what a bar says, over the group's rows. |
| S6 a group's By status row | SUMIFS(counted_hours, row_type,"segment", in_cycle_time,"true", status,S, issue_type,name) (or project,key), ÷ n. in_cycle_time is true only on charted work items' rows. Rows are then rounded as a set (what a By status row averages). |
| S7 shortcut | Open the row, or List these, then Export this list (CSV). Its cycle_time p50, p85 and p95 closing rows are the group's exact figures. |
| S8 the answer | S3's 85th for each group with n ≥ 20, printed in S4b's unit. Take the smallest and the largest; groups printing the same figure are named together. |
| S13 a group's lead time | The issue_total rows where charted = true or exclusion_cause = NEVER_STARTED, with issue_lead_time_hours not blank, and S1's condition, or S10's: their number n_L is the key's over n_L work items, and SMALL(G, ROUNDUP(85*n_L/100, 0)), G their issue_lead_time_hours, rounded up, its Lead time 85%. A never-started work item has no By status row and no cycle time, so only this step counts it. |
Nearest rank makes the 85th percentile of 6 work items or fewer their slowest, and the 95th of 19 or fewer, which is why S3 states no percentile below those counts and S4 states the slowest instead.
One parent, label, component or team. The same rules take the charted work items of one parent, label, component or team on their own: steps S9 to S12, with S10's condition in place of S1's. A work item with two labels is in both labels' groups, so the groups of labels, or of components, add up to more than the work items; nothing is split between them.
| Step | Recipe |
|---|---|
| S9 the columns | parent holds the parent's key, blank for none or one you cannot open; labels and components hold each value on a line of its own, blank for none; team a team's name, blank for none; in a file with a sprints_not_read row, every team cell may be blank because the site's list of fields could not be read (the CSV format). |
| S10 one group | A parent: S1's condition on the column (parent = "PAY-12"; a key holds no character a condition reads otherwise). A team, a label or a component, in a helper column: EXACT(team,"Payments") for a team, and ISNUMBER(FIND(CHAR(10)&"api"&CHAR(10),CHAR(10)&SUBSTITUTE(labels,CHAR(13),"")&CHAR(10))) for a label (or components for a component), true for the group; not a COUNTIFS criterion, which reads *, ?, ~ and a leading <, > or = in a name. For no label, labels="", and so for the others. Look for the value as the file writes it: one that begins with =, +, -, @ or a tab has an apostrophe before it, first in the cell or after a line break. FIND and EXACT are case-sensitive and read no wildcards; SEARCH is neither. |
| S11 counts | A parent's or a team's groups add up to the charted count, as S2. A label's or a component's add up to more: by how many work items, SUMPRODUCT((row_type="issue_total")*(charted="true")*ISNUMBER(FIND(CHAR(10),labels))), the charted work items whose cell holds a line break; with S10's condition beside it for the work items of one group of another kind. |
| S12 a group's figures | S3 to S7 with S10's condition. |
Checking a target against the ledger export
Every count a target states can be reproduced from Export data (CSV), once the file is imported as the CSV format says. The target is not in the file: take it from the key or the summary, which state it with its unit.
| Step | Recipe |
|---|---|
| T0 setup | Export data (CSV). D is 24, or, on a chart counting only working hours, the hours of the file's working_day row (why). TH, the target in hours: ROUND(days*D, 4), or the hours stated. Round it, since a spreadsheet can hold 0.7 × 24 as 16.799999999999997, which compared without rounding reads below the cell 16.8000. |
| T1 n | COUNTIFS(row_type,"issue_total",charted,"true"); under Show, with S1's or S10's condition. |
| T2 within | k = COUNTIFS(row_type,"issue_total",charted,"true",issue_cycle_time_hours,"<="&TH). |
| T3 the share | ROUNDDOWN(100*k/n,0). The key states k of n within it (share%). |
| T4 a Trend period | T1 and T2 over the rows whose LEFT(left_at,10) falls in the period, as the Trend recipe places them. |
| T5 Aging | n is A1's; past it, COUNTIFS(row_type,"wip_total",exclusion_cause,"",issue_cycle_time_hours,">"&TH); with ages measured when the view opened, on that file. |
| T6 side by side | Each row's T1 to T3 on its own Export data (CSV). Export saved filters (CSV), while a target is shown, ends with target_hours, TH, and within_target, k, beside the row's charted, n. Beside the period before, T1 to T3 on the period before's own export. |
| T7 exactness | Every target is a whole number of minutes and a multiple of 9 seconds, so TH is exact in four decimals, <= on the file's four-decimal hours decides as the tile decides on exact seconds, and a row of saved filters side by side, counted on its cycle times in whole minutes rounded up, decides the same. |
Saved filters side by side
A tile set up with two to twenty saved filters, projects or queries shows them side by side, one row
each, in the order the settings list them. A row is a saved filter, a project, named as Jira names it to
you, or a JQL query, named by its text. To compare Teams in Jira, components, labels or boards, save one
filter per team, such as "Team[Team]" = …, component = … or labels = …, or type each as a query, or
pick a board's own filter. A saved filter per team gives each team its own row and its own period
before. The app also reads each work item's parent, labels, components and team, and writes them in
the CSV export, where the split recipe takes one of them on its own.
Each row is that source's own chart, with the same Started and Done statuses, Date range and working day, set once in the settings. A row is the chart a tile of that source alone with its holiday list builds for you, unless its list names a time zone other than the gadget's (every state or region names one, and so does a country of one time zone, such as Japan): such a row is counted in that zone, a chart only this table shows. The footer states what the rows share once, the time zone under Time zone, build time and method. With Each saved filter's own chosen under Public holidays (the setting), each row has a holiday list of its own, which its line under the table states, and its name as a screen reader reads it, as Germany (Sachsen) holidays · counted in Europe/Berlin, and the table names none of its own: its words say each saved filter's own holidays; pressed, the row's footer and drill panel say which zone its weekends, holidays and working hours are counted in, beside the zone its times are in. A state or region that spans several time zones is counted in its main zone, the one named beside it. Texas is counted in the region's main zone, America/Chicago; teams in another of its zones, such as El Paso's America/Denver, may differ by an hour. In a few places the difference is half an hour (Labrador), 45 minutes (Eucla) or two hours (western Nunavut), or holds only in summer or only in winter. A tile of that source alone, set up from the team's own time zone, counts it there. Each source's holiday list reaches everyone who can see the gadget with its settings, also for a source they cannot open (privacy). Counting only working hours, every row counts the same window, which the footer names and every row's figures are in, so teams on different hours need a tile each. A team whose workflow uses other statuses shows it on its line under the table: a work item that never enters one of the Started statuses is excluded. Each row states how many work items it charts and its 50%, 85% and 95%, rounded up, its 50% and 85% only from 7 work items and its 95% only from 20, as Compare's rows do; a smaller row states its slowest. Every figure in the table is in one unit, the scale's: hours when the scale ends within a day, days otherwise. A row's strip draws each work item it charts as a dot at its cycle time in whole minutes, rounded up, which places the dot and states nothing.
Nothing is stated across the saved filters until every one you can open is ready. Then the sentence above the table ranges over the saved filters with 20 or more work items, as in Across the 12 saved filters with 20 or more work items, 85% finished within 2.9 days (Checkout) to 9.4 days (Data) of starting, taking each row's 85% as the table prints it and naming every saved filter that prints the lowest or the highest; the line under the table says how many work items more than one of them returns; and Export saved filters (CSV) is offered. Nothing is added up across rows: there is no total and no pooled count. Only the offer of Show four quarters weighs the work items the rows' searches find together, against Jira's hourly limit. A work item two saved filters return is in both rows, counted in each, and the line under the table says how many such work items there are; a row's own count of them is in its line under the table and in its name, as a screen reader reads it.
Order. The rows come in the settings' order. The column heads sort them by the settings' order and its reverse, by work items, or by 85%, quickest or slowest first, with the rows too small for an 85% last either way, as Compare's heads do, and the sort is not remembered. Below 480 px, past 10 rows the first 8 are listed, with Show all for the rest. Two saved filters of one name are told apart by their places in the settings, as in Platform #3.
Building. Each row is built and shown as a chart is: from your own search of its saved filter, unless a colleague's chart of it on this tile, built that day, holds exactly the work items your search returns, as Jira confirms to you (who sees what); pressed, the row shows that same chart. Rows are built three of the tile's rows at a time, or one at a time while one holds more than 1,000 work items, a row's size being Jira's count, for you, of what its search will find, until its build has searched. A row waiting for a colleague's chart of it to be built says Waiting its turn, with no count, and does not hold up the others. The tile asks after the rows still to come every 10 seconds, or every 30 while each of them is either being built from more than 1,000 work items or waiting for such a build to finish, since no other row starts until then. The first view of the day waits for all of them: eighteen small teams' filters take about a minute or two, and twenty filters of 5,000 work items each can take a quarter of an hour or more. Rows appear as they are built, and the scale and its unit can change as they arrive. A row whose chart could not be built says why and is asked after again ten minutes later, and one whose build has run five minutes says so and is asked after only while other rows are. The 5,000 item cap is per saved filter.
A saved filter you cannot open has no row and no name: the line under the table says only how
many of the tile's saved filters you cannot open (why). On a tile with a project or a
JQL query among its sources, every line says sources where it would say saved filters, the first column's
head reads Source, the file is Export sources (CSV), and the line under the table counts those you cannot
open by kind, as in 1 saved filter and 2 JQL queries you cannot open are on this tile, so they have no row
here. The file names a project as project: and its id, and a query by the word jql and its text as
Jira accepted it from you, never by the sealed text the settings hold.
Settings changed while the tile is open. Every request the tile makes about its saved filters names, in order, the ones its rows were drawn from. When the settings the app reads for the tile list others, because someone saved them while you had it open, the app states nothing about any of them, and the tile shows no row: it draws the table of the new settings, or, where Jira has not yet handed the tile the new settings, says This tile's settings were changed while it was open. with a button, Reload the dashboard.
Pressing a row shows that saved filter's own chart, with every view, Show, Compare with …, Include today, the Forecast, Export data (CSV) and Image or summary, and, while four quarters are shown, Export Q1 2026 (CSV) and Export Q4 2025 (CSV), under a line naming it, with a button back to the table. The table has Compare with … and Image or summary of its own, below; the views, Show, Include today and the Forecast are its rows'. The choices the tile remembers for you, its view, the Trend view's period, Compare's kind, the period before, the Forecast's history, date and number, whether Aging measures ages when it opens and whether the 70% line is shown, are the tile's: they apply to whichever saved filter is shown.
Comparing with the period before. Once every row is ready, tick Compare with Q1 2026 under the line counting the saved filters, and each row is set beside its own period before, by the same rule, built after the table, or shown as its row's chart is, three at a time, or one at a time while one holds more than 1,000 work items: as many charts again, and, for twenty filters of 5,000 work items, as long again. A saved filter that charts nothing in the range has no period before, as on its own chart. The strips give way to the period before's 85%, in the table's unit, and, under Against Q1 2026, Faster, Slower, About the same, Too few below 20 work items in either period, or No verdict over the item cap. Where the table's unit would show the two figures another way than the verdict its own chart states, as 0.5 d beside 0.5 d for 10 hours against 11 hours 7 minutes, the cell reads See its chart: press the row and tick its box to read it there. Nothing about the comparison is stated across rows. The tick is not kept: a reload, or the tile's refresh each hour, shows the table without it, and ticking again reads the period befores already built rather than building them again.
Four quarters. On a tile whose Date range is Last full quarter, once every row is ready, tick Show four
quarters under Compare with …, and each row states its 85% in each of the last four quarters, as Q4 2025 85%
to Q3 2026 85%, in the table's unit, in place of its 50%, 95% and strip. Each earlier quarter is that saved
filter's own chart of the quarter, built after the table, the nearest first, or a colleague's chart of that quarter
once Jira confirms to you that it holds exactly the work items your search returns, three at a time, or one at a
time while one holds more than 1,000 work items; the quarter before is the chart Compare with sets beside the
row, built once for both. A quarter with fewer than 7 work items states its slowest, as All 4 within 3 d, and one
with none reads —. A saved filter that charts nothing in the last quarter has no quarter before it built. Each
quarter is read from Jira again each day, as its own chart is: work reopened and finished again since moves to the
quarter it last finished in, a saved filter edited since applies to every quarter, a query naming days relative to
today, as created >= -90d or openSprints() do, reads as it does today, and history that came from an import is
found only as imported history says; to keep a quarter's figures as they stood, export its
ledger then (why). Nothing about the quarters is stated across rows or across quarters. With Compare
with ticked too, Against Q2 2026 follows. The box is offered while the searches of the rows find 2,000 work items
or fewer between them in a quarter: each needs three more charts, and Jira limits what the app may read in an hour.
The tick is not kept. Pressing a row while four quarters are shown offers Export Q1 2026 (CSV) and Export Q4 2025
(CSV) in its footer, each once its quarter is in, so each figure can be checked (the
recipe).
A target. Show a target is offered under the line counting the saved filters too, the same box and the
same target as on a chart of the tile (a target). Shown, each row states its share within it in a
Within 5 d column after 95%, counted on its cycle times in whole minutes rounded up, which decide exactly as
its own chart's do, its count on pointing at it and in its name. Beside the period before, the column stands
after Against Q1 2026 and each cell gains a second line, as in 85% before, from the period before's own
work items; one built before the app could read them reads —, and says why on pointing at it. Export
saved filters (CSV) then ends with target_hours and within_target (T6).
Image or summary of the table, in the footer once every row is ready, works as a chart's does: the table with every row, whatever the tile's width, its lines and its footer, and, once every row's period before or quarters are ready, the comparison or the four quarters. Its summary is a paragraph of the sentence above the table and the notes, then a line for each saved filter with its line under the table and its figures, then where they come from. In Markdown the table holds each saved filter's figures, and the lines under the table follow it as a list.
Each figure can be checked against the saved filters' own exports with the recipe.
Checking saved filters side by side against their exports
Every figure the table of saved filters side by side states can be reproduced
from each saved filter's own Export data (CSV), and, set beside the period before, from each one's
period before's own export, once each file is imported as the CSV format says, in the
steps below. Let H be a file's issue_cycle_time_hours.
| Step | Recipe |
|---|---|
| T0 files | For each saved filter, press its row, then Export data (CSV); the file is named with its place, as cycle-time-ledger-filter-3-2026-04-01-to-2026-06-30.csv, which is the row whose filter_place is 3 in the saved filters' file. |
| T1 count | In each file, keep the issue_total rows where charted = true: their number n is the row's Work items, and the count its closing rows state. Its closing rows also state how many were excluded, the number on its line under the table. |
| T2 percentiles | Each file's cycle_time closing rows state its 50th, 85th and 95th in exact hours, each equal to SMALL(H, ROUNDUP(p*n/100, 0)) over T1's rows. Never PERCENTILE. A row states its 50th and 85th only from n ≥ 7 and its 95th only from n ≥ 20. |
| T2b the table's unit | The scale ends at E = the largest H of any file, or twice the largest 85th of a file with n ≥ 7 if that is lower. If E ≤ D, every figure is in hours: ROUNDUP(x, 1), at least 0.1. Otherwise in days: ROUNDUP(ROUND(x/D, 6), 1), at least 0.1, or ROUNDUP(ROUND(x/D, 6), 0) from 100 days. D is 24, or the hours in the stated cell of the working_day line that ends Export saved filters (CSV) on a tile counting only working hours (T5). A row too small for an 85th states its largest H, rounded up the same way. |
| T3 the answer | Among the files with n ≥ 20, the smallest and the largest 85th as T2b prints them; files printing the same figure are named together. |
| T4 shared work | The issue_key values charted in two or more files: their number is the line under the table. For each file, its charted keys charted in any other file: their number is its row's. Two saved filters of one name are two files, each named with its place. |
| T5 the file | Export saved filters (CSV) has a line per row: its charted and excluded are T1's, its p50_hours, p85_hours and p95_hours T2's closing rows exactly, its max_hours the file's largest charted H, its also_in_another T4's, and its stated 50,85,95, 50,85 or none by T2's counts. On a tile counting only working hours its last line is working_day, the window, or the week, in filter_name and the working day in hours, or the average working day, in stated, every figure cell blank: T2b's D. |
| T6 files | For each saved filter that charts something, press its row, leave Include today unticked, tick Compare with Q1 2026 there, then Export Q1 2026 (CSV): cycle-time-ledger-filter-3-2026-01-01-to-2026-03-31.csv. The tile builds nothing for it: it is the column's chart. A saved filter that charts nothing has no period before and reads — (its face offers no Compare with). |
| T7 the column | In each period-before file, T1's n and T2's 85th; printed in T2b's unit, the one T2b decided over the chart's files (not these): from n ≥ 7, its 85th; from 2 to 6, All n within it; at 1, Cycle time within it; at 0, —. |
| T8 the verdict | C1 to C4 on the row's two files give the verdict its own chart states. The table states it unless C3, run on T7's two printed figures in place of C2's, gives another; then the cell reads See its chart. |
| T5b the file while comparing | before_first_day and before_last_day are T6's file's days; before_charted and before_excluded its T1; before_p85_hours its cycle_time,p85 closing row's hours exactly; verdict T8's C3–C4 answer, C4 first (capped when either file is over the cap, then few with fewer than 20 in either file, otherwise faster, slower or same for about the same); all six blank for a saved filter that charts nothing, and on the working_day line. The six columns are in the file only once every row's period before is in. |
| T9 files | For each row that charts something, with Show four quarters ticked, press the row, then Export Q1 2026 (CSV) and Export Q4 2025 (CSV): cycle-time-ledger-filter-3-2026-01-01-to-2026-03-31.csv and …-2025-10-01-to-2025-12-31.csv. Q2 2026's file is T6's. Export the files the same day as the table they check. Each quarter is read from Jira again each day (why), and a file exported on another day has the same name but can hold another build. |
| T10 the quarters' columns | In each quarter's file, take T1's n and T2's 85th, printed in T2b's unit by T7's forms. T2b's unit is the one decided over the charts' own files, not these. |
| T5c the file with four quarters | 26 columns, 27 with verdict, plus the target's two when shown. before_* is as in T5b, less verdict unless Compare with is ticked. before2_* and before3_* are T9's files' first and last days, T1's counts, and the cycle_time,p85 closing row's hours exactly. All are blank for a row that charts nothing and on the working_day line. They are in the file only once every row's quarters are in. |
The app counts shared work items by their ids, which the files do not hold, so T4 matches by key: a work item moved to another project between two saved filters' builds of one day has two keys, and would not be matched.
What the Aging view shows
Aging, the chart view after Compare, shows the work that has started and not finished: each work item your filter returns for you that, by its own history, has entered one of your Started statuses, or was created in one, and is not in one of your Done statuses. It is found by a second search of yours when the chart is built, and every list it opens is checked as you, as every list is. It is offered on every chart built since the app began to search for work in progress, and where nothing finished in the range it is the only view, under the chart's own message.
Each work item is a mark in the column of the status it was in when the chart was built, at the height of its age. An age is counted as a cycle time is: from the work item's first move into a Started status, or its creation in one, to the moment the chart was built, over the same calendar, so weekends and holidays are left out where the chart leaves them out. It is the cycle time the work item will have if it finishes at that moment. The view states that moment, as in Ages as of 01 Jan 2026 09:14, when this chart was built, and the ages are not moved on while the tile is open. The chart is built again at the first view each day, so an age can be up to a day behind, a work item finished since the build is still shown until the next one, and one started since is not yet shown. Two people's charts can show different ages for one work item when they were built at different moments. Tick Measure ages when this view opens, under the note, and they are measured again whenever the view opens (ages measured when the view opens).
The 50%, 85% and 95% lines are the chart's own, and the 70% line with them while Show the 70% line is ticked, drawn at the figures its key prints, rounded up (why), not at the exact percentiles, so the sentence above the chart can name one figure, as in 21 of 50 work items in progress are older than 6.2 days: longer than 85% of charted work items took to finish. A work item older than the printed figure is older than the exact 85th percentile too; one exactly on the line is within it. Work items past the 85% line are drawn solid, over the shaded ground above the line, and the others as rings. Where 6 or fewer work items finished, the 85th percentile is the slowest of them, and the sentence compares with all of them; where none that finished is charted there is no line, and the sentence says so.
A second sentence compares each work item's time in the status it is in with how long charted work items stayed in that status, as in 7 have been in their status longer than 85% of the stays charted work items made there., and List these 7 lists them, the longest in their status first. Where some are in a status with fewer than 7 stays, it says how many more there are, and leaves them out. Under the key, How long work stays in each status states, for each column, how many stays charted work items made in its status, within what 85% of them ended and how many work items in progress have been in it longer now, each count opening its list (how).
The columns are the statuses that hold work in progress, and each of your Started statuses that the chart's finished work passed through, even when it holds none: statuses of the To Do category first, then in the order By status lists them, then any other by name. A status is named as it is now, and two statuses of one name are one column. Each column states how many work items it holds and, where the column is wide enough to print it, how many of them are past the 85% line; its name, read by a screen reader, always states both, and pressing it lists them. A work item moved back to To Do after it started keeps its first start, and the age it has run up, in the To Do column, and the note under the sentence counts such work items. A To Do status you chose as a Started status is where work starts, not where it is moved back to, so it is not counted there. A work item reopened after it finished in the chart's range is both a completion excluded as transitioned backwards after Done and a work item in progress, and each view lists it only as its own. On a chart of a saved filter, the columns can be a board's instead (grouped by a board's columns).
The age axis runs to the oldest work item, or to twice the 95% line where that is lower, so one forgotten work item cannot flatten the others. A work item older than the axis runs is drawn as ▲ in a lane above its column, marked with the axis's top, as in >30 d, and a lane with more of them than it holds shows one ▲ and their count, which lists them. Where the columns would be too narrow, or a status's name would not fit two lines of one, the chart is drawn in rows instead, one status to a row, with age running across.
Show narrows the view to one issue type's or one project's work in progress, against that group's own lines. What the view counts without plotting stays the whole chart's, since the issue type or project of a work item not read, or past the cap, is not known, and it says so.
Pressing a work item's mark opens its arithmetic, with any others drawn at the same spot: its age, and the status it is in with the time it has spent there, then each stretch since it was created. The minutes of the stretches in its age add up to the age, as a finished work item's add up to its cycle time, and the age is the one its mark states. A stretch before its first start is marked before it started and is not in the age; the stretch it is still in is marked still in it, on both its rows where its creation date falls inside it, and ends at the moment its age was measured. Every other list, from the sentence, a column's name or a lane's ▲, has one line a work item, in the order they started, the oldest first: its key, the status it is in (left out where they are all in one), when it started and its age, marked past 85% or past 95%, or past 70% while that line is shown, where the age is past that line, and In it for, the time it has spent in the status it is in, as its arithmetic prints that stretch, marked longer than 85% of stays where it is. Order lists them Longest in status first, ties by age, as the lists of the stays open, or Oldest first; it is the panel's own and is not remembered. Export this list (CSV) gives the listed work items' rows, closing on the chart's lines.
Some work in progress is counted and not plotted, each reason with its list; see what the Aging view does not plot. Every figure the view states can be checked against the ledger export with the recipe.
Grouped by a board's columns
On a chart of a saved filter, the Aging and By status views offer Group by: Status · Board column under their answer. Board column groups the view by the columns of the boards that use that saved filter, as they are set out on those boards: Aging's columns become the board's, each holding the work items of the statuses it holds, and By status's rows stand under the heading of the column holding their status (how). A chart of a project or of a typed JQL query offers no such row, since a board is found by the saved filter it uses. The choice is remembered in your browser for the gadget.
The columns are read as you, when you choose them and each time the tile opens either view with them remembered: the boards that use the saved filter, and the columns of up to five of them. Only boards you can open are used and counted. Where every board you can open sets out its columns alike, the view is grouped by them, and the line under the answer says so, as in Grouped by the columns of the board you can open that uses this saved filter. Otherwise the view stays by status, and the line says why: those boards set out their columns differently, more boards use the saved filter than the tile reads, none you can open uses it, or the columns could not be read from Jira just now, with Try again. The columns are held in the tile while it is open, and never stored.
Only the chart's own statuses are named, those of its By status rows and its Aging columns; while Aging shows the ages measured when the view opens, its columns are read for those ages and name theirs as well, so work that moved into a status after the chart was built is in the column holding that status. A board's column lists statuses by their ids, which are matched to the chart's statuses through the copy of your site's status list the app keeps, and a status of the board that the chart does not hold is never named. A column holding none of the chart's statuses keeps its name and holds nothing: Aging draws it empty, and By status gives it no heading. A status in two columns is in the leftmost. A status of the chart that no column holds is under Not on the board, and so, until the chart's next build, is a status renamed since the chart was built.
Nothing the view counts changes. On Aging, a column's count is the sum of its statuses' counts, since it holds their work items and no other; each work item keeps its own status in its name and tooltip; the lines, the stays and the sentences are the view's own by status. A column's head names the statuses it holds, read by a screen reader and shown in a tooltip on focus as on hover, as in Review holds In Review and Code Review, and pressing it lists its work items. Image or summary draws a grouped view grouped, with its line.
A file exported while the view is grouped reads the columns again, as you, and writes a board_column row for
each of the chart's statuses a column holds, a file of the ages measured when the view opens for each of theirs as
well (the CSV format); A15 gives each column's count from it. Where the columns
changed since the tile drew them for what the file is of, the chart or those ages, the tile draws the new ones and
says The board's columns changed while the tile was open; this view now uses them.
Work in progress the Aging view does not plot
Some work in progress is counted in the line under the Aging view's note and not plotted, because its age is not known. Each reason opens its list, where each work item shows the stretches the app read of it and no age, and the list links here:
- never entered a started status: the search found it, but its history shows no move into one of your Started statuses, and no creation in one, by the moment the chart was built, as when its move into one is stamped later than that moment by a clock ahead of the app's, in which case the next build plots it.
- incomplete history in Jira: Jira did not give the app its whole history, so its first start is not known; see incomplete history in Jira.
- not read before the time limit: the build ran out of time before reading its history; see not read before the time limit.
- the app is not allowed to read: when Jira does not let the app act as you, the app's lookup of it by id returned nothing, usually because an organisation's app access rule keeps it from the app, so it is listed by the key your own search gave it and nothing else; see the app is not allowed to read.
Each is a wip_total row of the ledger export with its reason in exclusion_cause
(A8). Work in progress past the cap is counted on a line of its own,
not among these.
More work in progress than the Aging view plots
The search for work in progress keeps at most 2,000 work items, those created first, of the up to 5,000 ids and keys its one page returns, and the Aging view plots at most 1,000 of them: those that started first, the oldest, since an age runs from the start. The others read with a known age are counted, not plotted, and have no rows in the export. Having started later, they are younger than those plotted but for a second or two of rounding, so the view checks their ages, and where none of them is older than the youngest plotted and that one is within the 85% line, it says none of them is past it, as in none of them is older than 6.2 days. What the search found past the 2,000 it keeps is counted as you, from the search's own page where it holds it and otherwise by Jira's estimate for you, which the view marks About, and it is never read or listed. The sentence above the chart, its lists and every column's count are about the work items plotted; the line under the note says how many more there are.
How long work stays in each status
A stay is one stretch a charted work item spent in a status, in its cycle time: its segment rows
of the ledger export one after another with that status, of a work item that is charted. That is one
row, or two where the work item's creation date falls inside the stretch, as it can for an imported
work item whose status history starts before its creation date: the export splits the stretch there for
lead time, and it is still one stay. A work item that went through In Review twice made two stays there. Stays are counted
on the chart's calendar, as its cycle time is, so weekends and holidays are left out where the chart
leaves them out. Work still in progress made none of them, and a status is named as it is now, two
statuses of one name being one.
For each column of the Aging view, How long work stays in each status states how many stays
charted work items made in its status, and the time within which 85% of them ended: the 85th
percentile, by nearest rank, of their counted_hours cells, rounded up as every
"within" figure is. It is stated from 7 stays; with fewer, the 85th percentile would simply be the
longest of them, so the table shows —. Taken from the cells the export prints, it is reproduced
exactly by A12.
A work item in progress has been in its status longer when its time in it, the cells its export prints for the stretch it is still in, summed, is strictly more than that figure; one exactly on it is within it. That stretch runs from when it entered the status, whatever its creation date. The sentence under the view's answer counts them across the columns that state a figure, says how many more are in a status with too few stays, and lists them, the longest in their status first; each count in the table lists its column's. A work item's tooltip and its name add In it longer than 85% of stays, with the figure. Nothing is added to the chart, whose height is the age since the first start, another clock.
Under Show, nothing is compared: the stays are the whole chart's, and one issue type's or project's work in progress beside them would be compared with work of every other one too, so a line says so instead.
Ages measured when the view opens
The Aging view's ages are measured when the chart is built, at the first view each day. Tick Measure ages when this view opens, under the note, and each time the view opens they are measured again: the app runs your search for work in progress again, as you, reads those work items' histories, and draws their ages as of that moment against the lines of the chart on the tile. No finished work is read. It works on any Date range, and the note gives both moments, as in Ages as of 05 Oct 2026 09:31, measured when this view opened, against the lines of this chart, built 05 Oct 2026 08:02.; the status axis then reads Status when the ages were measured.
They are measured at most once a quarter hour for you and the gadget's settings: opened again within the quarter hour, the view shows the ages already measured, and it does not ask at all when the chart itself was built within the current quarter hour. Nothing is measured on a timer, only when the view opens; while they are read, the ages already on screen stay there, and the line beside the box says how far the reading has got. The ages are drawn only beside the build whose lines they were measured against: if your chart is built again meanwhile, they are measured again for it.
The box is remembered for the gadget in this browser; untick it to go back to the chart's own ages. It is not offered on a chart that includes today, whose ages are already of its quarter hour, nor on the table of saved filters side by side; a saved filter shown on its own offers it.
While they are shown, every list the view opens is of them, and the footer adds Export ages now
(CSV): their own ledger, the work in progress at those ages and no finished work, closing on the
chart's lines, so the recipe reproduces them (A14); it is named for the moment they
were measured, as cycle-time-ages-2026-10-05-0931.csv. The stays compared with are the chart's. If
the ages could not be measured, or are taking longer than expected, the line beside the box says so and
when the ages still on screen were measured: when the chart was built, or when they were last measured.
Ages that could not be measured are measured again the next time the view opens, ten minutes later at
the latest.
Checking the Aging view against the ledger export
Every figure the Aging view states can be reproduced from Export data (CSV) in the steps below,
once the file is imported as the CSV format says. Work in progress has rows of its own,
wip_segment and wip_total, after the finished work, and its lines are the three wip_line
closing rows.
| Step | Recipe |
|---|---|
| A0 setup | Export data (CSV). W = the wip_total rows with a blank exclusion_cause. L85 = the wip_line,p85 hours. |
| A1 in progress | COUNTIFS(row_type,"wip_total",exclusion_cause,"") = the sentence's n. |
| A2 older | COUNTIFS(row_type,"wip_total",exclusion_cause,"",issue_cycle_time_hours,">"&L85), strictly greater = k. |
| A3 a line | L85 = the cycle_time,p85 hours rounded up, in hours; the wip_line row states it. The 50% and 95% lines come from the p50 and p95 rows the same way, and the 70% line, while it is shown, from the 70th, which no row states. |
| A4 a column | Add status,S to A1 and A2. |
| A5 an age | SUMIFS(counted_hours,issue_key,K,row_type,"wip_segment",in_cycle_time,"true") = K's issue_cycle_time_hours. Then ROUND(hours*3600,0) seconds, then minutes = the tooltip. |
| A6 since | K's wip_segment row whose left_at equals its wip_total row's left_at, with the rows just before it of the same status and in_cycle_time: two rows where K's creation date falls inside that stretch, as an import's can. The first one's entered_at is when K entered the status it is in, and their counted_hours, summed, the time in it. |
| A7 as of | left_at of any wip_total row: the moment the chart was built, when every age was measured. |
| A8 not plotted | COUNTIFS(row_type,"wip_total",exclusion_cause,C) for each reason C. Over the cap = the wip_line rows' fifth column minus those. |
| A9 moved back | The W rows whose status is a To Do-category status that is not one of your Started statuses. |
| A10 under Show | With a group shown, keep only the W rows whose issue_type or project is the group's, or, for a parent, a label, a component or a team, whose parent, labels, components or team cell holds it as S10 finds it, and take L85 from the group's finished rows by S3, with S10's condition for those four, rounded up. A1, A2 and A4 then give the group's figures. |
| A11 time in status | A6's summed counted_hours: the figure Order sorts by, longest first, ties by issue_cycle_time_hours, longest first. |
| A12 a status's stays | For a status S: the segment rows with status S and in_cycle_time true whose work item's issue_total row has charted true, one stay each, except that rows of one work item one after another are one stay, their counted_hours summed: two where its creation date, its issue_total row's entered_at, falls inside the stretch. n = the stays' count; with n of 7 or more, the 85th = SMALL(counted_hours, CEILING(0.85*n,1)) over their cells, a cell h. Its bound, from h: under an hour, CEILING(h*60,1) minutes; under a day of D hours, CEILING(h,0.1) hours; under 100 days, CEILING(h/D,0.1) days; otherwise CEILING(h/D,1) days, D as in the rounding recipe; a bound that reaches D hours, or at D = 1 60 minutes, is 1 day. B = the bound in seconds. |
| A13 longer now | For each W row in S, its A11 cell c: longer when ROUND(c*3600,2) > B. Their count is S's In it longer now; summed over the statuses with a bound, the sentence's count. |
| A14 ages measured when the view opens | A0 to A11 and A13 on Export ages now (CSV) for the ages; A12 on Export data (CSV) for the stays. |
| A15 a board column | From a file exported while the view is grouped by board column: each status S of the W rows belongs to the column C whose board_column row has S in its third cell, the column's name in its second; compare the two cells as the file writes them, with EXACT or in a helper column, never as a COUNTIFS criterion, as FL9 does. A status no board_column row names is in Not on the board. C's count = A1 over its statuses: SUMPRODUCT of A4's count for each S of C, the number on C's head. |
A12 and A13 work on the cells as exact decimals. A cell is a number of ten-thousandths of an hour,
not a whole number of seconds, so the rounding recipe's ROUND(hours*3600,0) step does
not apply, and binary floating point, which a script uses unless told otherwise, can land a step off:
33.6/24*10 comes out as 14.000000000000002, which would round the 1.4 days the cell 33.6000 is up
to 1.5. Read the cells as decimals, as Python's Decimal does. A13's ROUND(…,2) is exact, since a
cell is a whole number of 0.36-second units.
The line is the percentile as the chart states it, rounded up, and not the exact percentile: the sentence names one figure, and a work item older than that figure is older than the exact percentile too. A work item exactly on the line is within it. Ages and lines are whole seconds, and the file's hours are never more than 0.18 seconds from them, so A2 always agrees with the chart.
An age is counted as a cycle time is, from the work item's first move into a Started status, or its creation in one, to the moment the chart was built, over the same calendar: it is the cycle time the work item will have if it finishes at that moment. A work item moved back to To Do after it started keeps its first start, so A9 finds it with the age it has run up; a To Do status you chose as a Started status is left out, as the note leaves it out.
A8's reasons are those of why work items are excluded that leave an age unknown: never entered a started status, incomplete history in Jira, not read before the time limit and the app is not allowed to read, as what the Aging view does not plot says. The Aging view plots at most the 1,000 work items that started first; the others with a known age are counted over the cap and have no rows, as have any the search found past what one chart reads.
What the Flow view shows
Flow, the chart view after Aging, shows how many work items were in progress at the end of each day of the chart's range, and how many finished each day: two run charts on one row of days, In progress at each day's end above and Finished each day below. Its headline states the last day's work in progress and how many finished over the days drawn, as in 23 work items were in progress at the end of 4 Oct 2026, and 287 finished over these 90 days., and its note the averages and the lowest and highest day, as in On average 18.4 were in progress at a day's end and 3.2 finished a day. At a day's end there were between 12 and 31. Averages are to one decimal, a half rounded up. It is offered beside the other views on a chart that charts a work item and whose build searched for work in progress; where nothing finished in the range, Aging stays the only view.
In progress, as cycle time counts it. A work item is in progress from the first time it enters one of your Started statuses, or its creation in one, to the last time it enters one of your Done statuses (more), and the view says so under its headline. Work in progress, work finished and cycle time on one tile are then about the same work items, each with one start and one end.
Who is counted. Each day counts the charted work items, the work in progress the Aging view plots, and the work that finished after the range (below), each work item once, by what it is now: one reopened after it finished in the range is counted as in progress from its first start. A work item that starts and finishes on one day is in progress at no day's end, and is counted on the day it finished. Under Show, the group's; the days drawn are the whole chart's.
Days, in the chart's time zone. A day ends at the first instant of the next day in the chart's time zone, so a day the clocks change on is 23 or 25 hours long, and each work item falls on the day its export's stamps begin with. With Include today the last point is at the quarter hour the chart runs to, and the upper panel's title says so, as in In progress at each day's end, and at 15:00 today.
Work that finished after the range. A work item that finished after the range ended, and before the chart was built, was in progress on the range's last days. When the range runs to the day the chart is built for, as a rolling range, This quarter so far, custom dates to today and Include today do, a third search of yours reads those work items, up to 1,000 of them (what is read), and the view counts them on the days before they finished. On a range that ended earlier, a closed month or quarter or past custom dates, they are not read, so the work in progress of each day is not drawn and the view says so; the work finished each day is.
Days not drawn. A day is drawn only when nothing the view knows of could leave it short, and a line above the panels says why when one is not:
- over the 5,000 item cap (why), both lines start on the day after the earliest charted completion, since the cap may have dropped some of that day's; where that completion is on the range's last day, no whole day can be drawn, and the headline says so in place of any count;
- over the Aging view's cap of 1,000 (why), the upper line stops the day before the latest plotted work item started, whatever group is shown, and the days after it are hatched: they could hold some the Aging view does not plot;
- no day's work in progress is drawn when more work items are in progress than one chart reads, when more than 1,000 finished after the range, when more finished in the range than one chart reads (why), since those not read could have been in progress on any day, when Jira did not answer the search for work in progress or for the work finished since the range, or on a range that ended before the day the chart was built for.
Days not drawn are left out of the averages, and the note names the days each line is drawn over when they are not all the range's.
Counted on no day. A line above the panels says how many work items could have been in progress and are counted on no day, so a day may count low: excluded work items whose start is known but whose cycle time is not counted, because they have transitions sharing a timestamp, finished before they started or counted to zero, or whose history was not read (incomplete history in Jira, not read before the time limit, the app is not allowed to read); work in progress the Aging view does not plot for one of those last three reasons; and work that finished after the range whose history the app could not read. Excluded work items are listed under the chart, by reason, and the line's words for them take you there; each other part of the line opens its own list when its work items share one reason. Under Show the line counts the whole chart's work items, as the reasons under the chart do.
Lists. Point at a day, or move along a panel with the arrow keys, Page Up and Page Down for a week and Home and End for the ends, and it states both of that day's figures; click it, or press Enter, and it lists the panel's work items for that day: those in progress at its end, each with when it started and when it finished, still in progress, or after the chart's range, or those that finished that day, each with its arithmetic. A day's work in progress also states, under At the day's end, the status each work item was in at the end of that day (FL8): from 480 pixels wide a column of its own, and narrower a second line under the work item's key, as in At the day's end: In Review. See the 287 finished lists the work finished over the days drawn, and List the 23 in progress at the end of 4 Oct 2026 the last day's work in progress. Every list is checked as you, as every list is, and Export this list (CSV) exports it: the list of a day's work in progress closes on its charted finished work, so FL2 on its file gives the day's figure.
Cumulative flow. Under the warnings, Chart: Run charts · Cumulative flow draws the same days as one panel of bands instead (more): at the bottom the work finished from the first day drawn, and above it, at each day's end, the work in progress in each status. The tile remembers your choice for the gadget in your browser.
The averages and Little's Law. Little's Law relates the average work in progress, the average finished a day and the average time from start to finish, over a stretch in which the work flows steadily. The view states the first two, over the same work items as the tile's cycle times, and no figure from the law: the tile's cycle times are percentiles of counted time, not an average of elapsed time, so a cycle time from the law would be a third figure for one thing, which need not agree with the other two.
Every figure the view states can be reproduced from Export data (CSV) (how). Image or summary, in the footer, copies the view as it states it (how).
What counts as in progress
The Flow view counts a work item as in progress from the first time it enters one of your Started statuses, or its creation in one, to the last time it enters one of your Done statuses: the clock its cycle time runs on, and the Aging view's ages. So:
- a work item moved back to To Do after it started is still in progress, and so is one parked in a status that is neither Started nor Done, such as Blocked: its cycle time, when it finishes, will count that time too;
- a work item reopened after it finished, and still open, is in progress from its first start, every day to now; its excluded completion is not counted again;
- a move from one Done status to another, such as Done to Closed, is not an entry into Done, so it does not end the work item's time in progress.
A board's column count can differ: a board counts the cards in its columns now, by the status each is in, and the Flow view counts by each work item's first start and last finish. A work item back in To Do is on the board's To Do column and in the view's count; one in a status your settings do not call Started, after it first started, is in the view's count and in no Started column of the board.
Cumulative flow
Cumulative flow, the Flow view's second chart, draws its days as one panel of bands, as tall as its two run charts: at the end of each day, at the bottom, the charted work items finished from the first day drawn, and above it a band for each status, how many of the work items in progress at that day's end were in it. Choose it under the view's warnings, in Chart: Run charts · Cumulative flow; the tile remembers the choice for the gadget in your browser, and opens on the run charts until you choose.
What a band holds. In progress means what it means in the run charts (more), on the same days and over the same work items, so on every day the bands above the finished one add up to the upper run chart's figure. Each work item is in the status it was in at the day's end: the status it entered before that instant and left at it or after, so a work item that moved, or finished, exactly at midnight is in the status it left. A work item moved back is counted where it was at each day's end, so a band narrows when work moves out of it, and the top edge, finished and in progress together, never falls: work leaves the bands above only by finishing, into the finished one on the same day. Work not yet started is not read, so no band holds it. A band of a To Do status holds work moved back after it started; a band of a Done status holds work not yet finished, in a Done status that is not one of yours or in one it was reopened from. Statuses are named as they are now, and two statuses of one name are one band. Top to bottom, the bands run as the Aging view's columns do: your To Do statuses first, then the order of By status, then by name; a status that held no work item at the end of any day drawn has no band. From 480 pixels wide a status's name is written at the right end of its band where the band is tall enough for it, and the key names every band.
Never drawn unless it adds up. The chart's build counts the bands, and the tile counts each day's work in progress again from what it holds. Before it draws the bands, it checks that they start on the run charts' first day, cover each day they draw work in progress for, and add up to it on every one of those days; where they do not, it draws the run charts with the line The bands did not add up to the work in progress counted each day, so the run charts are drawn instead. A chart whose work in progress passed through more statuses than it keeps a day for offers no cumulative flow, and the note under the chart says so. Where the run charts draw no day's work in progress, there is none either: on a range that ended before the day the chart was built for, such as a closed quarter or Last closed sprint, and for each reason the view names.
Days. The run charts' days: over the 5,000 item cap from the day after the earliest charted completion, and over the Aging view's cap of 1,000 to the day before the latest plotted work item started, after which the days are hatched and draw no band, the finished one included. With Include today the last day's bands are at the quarter hour the chart runs to, and the panel's title says so, as in At each day's end, and at 15:00 today: finished from 10 Mar 2026, and in progress by the status each was in.
Under Show. The build counts work in progress by status for the whole chart only, so with one group shown there are two bands, the group's work finished and its work in progress, each as its run charts count it, and the line Work in progress is split by status for the whole chart only, so here it is one band. says so.
Reading it. The panel is one slider over the days drawn: the arrow keys move it a day, Page Up and Page Down a week, Home and End to the ends, and each day states its work in progress, each band above zero and the work finished from the first day, as in 4 Oct 2026: 23 in progress at the day's end, 7 in In Review, 12 in In Progress, 4 in To Do; 287 finished from 10 Mar 2026. Press Enter or Space, or click above the finished band, to list the day's work in progress, each with the status it was in at the day's end under At the day's end; press Shift and Enter or Shift and Space, or click in the finished band, to list the charted work items finished from the first day drawn to that day. A band has no list of its own: the day's list holds each band's work items, each named with its band. A hatched day lists nothing. Export this list (CSV) exports either list.
Every band can be reproduced from Export data (CSV) (how), and Image or summary draws the panel and states the last day's bands (how). If its part of the tile cannot be loaded, the tile says Cumulative flow could not be loaded, so the run charts are drawn., with Try again.
Checking the Flow view against the ledger export
Every figure the Flow view states can be reproduced from Export data (CSV), imported as
the CSV format says. A day is the date a stamp begins with, LEFT(stamp, 10), which is the
day in the chart's time zone; do not convert a stamp through its offset.
| Step | Recipe |
|---|---|
| FL0 days | The footer's first day to its last. For a chart that includes today the last is today, to the quarter hour the chart runs to. When the reconciliation line shows work items over the 5,000 item cap, from the day after the earliest LEFT(left_at, 10) of the issue_total rows whose charted is true, even under Show, as in F2; when that is after the last day, there is no day. |
| FL1 starts and finishes | One row a work item, by its latest state: a wip_total row with a blank exclusion_cause (start = its entered_at, no finish); else a since_total row with a blank exclusion_cause (start = its entered_at, finish = its left_at); else a charted issue_total row (start = the earliest entered_at of its segment rows whose in_cycle_time is true, finish = its left_at). |
| FL2 in progress at the end of day d | COUNTIFS over FL1: LEFT(start, 10) <= d, and no finish or LEFT(finish, 10) > d. On the last day of a chart that includes today, by instant: start before T, and no finish or a finish at T or after it, T the footer's time on that day, at the offset its stamps carry. |
| FL3 finished on day d | COUNTIF of LEFT(left_at, 10) = d over the charted issue_total rows, as F3. |
| FL4 averages | The mean of FL2 over the days it is drawn, and of FL3 over FL0's days, each ROUND(x, 1), a half rounded up. |
| FL5 lowest, highest, last | MIN and MAX of FL2 over the days it is drawn; the last is FL2 on the last of them. |
| FL6 days not drawn | When the wip_line rows' fifth column is more than the wip_total rows with an exclusion_cause, the Aging view's cap cut some: FL2 stops the day before MAX(LEFT(entered_at, 10)) of all the wip_total rows with a blank exclusion_cause, even under Show. When the view says the work in progress of each day is not drawn, FL2 has no day. |
| FL7 counted on no day | The issue_total rows whose charted is false and whose exclusion_cause is SAME_TIMESTAMP, ZERO_DURATION, NEGATIVE_DURATION, CHANGELOG_TRUNCATED, TIME_LIMIT or APP_CANNOT_READ; the wip_total rows whose exclusion_cause is one of the last three; and the since_total rows with an exclusion_cause. |
| FL8 a work item's status at the end of day d | For each work item FL2 counts on day d, the rows of the kind its FL1 start came from: segment for a charted one, wip_segment for one in progress, since_segment for one that finished after the range. Exactly one of them has LEFT(entered_at, 10) <= d and LEFT(left_at, 10) > d; its status is the work item's at the day's end. On the last day of a chart that includes today, by instant: entered_at before T, and left_at at T or after it. |
| FL9 the band of a status on day d | How many of FL2's work items on day d have FL8 equal to that status, comparing the status cell as the file writes it, with EXACT or in a helper column; not as a COUNTIFS, SUMIFS or MATCH criterion, which ignores case and reads *, ? and ~ as wildcards (S10). A name that begins with =, +, -, @ or a tab is written with an apostrophe before it, so the tile's -Blocked is the file's '-Blocked. The bands of a day add up to FL2. |
| FL10 the finished band on day d | FL3 summed from FL0's first day to d. |
Under Show, keep only the FL1 and FL3 rows of the group shown: an issue type's or a project's by S1's condition, a parent's, a label's, a component's or a team's by S10's, so a work item with two labels is in both labels' groups. FL0 and FL6 stay the whole chart's. FL8 and FL9 are not split by status under Show: cumulative flow then draws FL10 and FL2.
In Python 3.11 or later, with the file and the footer's first and last day:
python3 flow.py cycle-time-ledger-2026-07-07-to-2026-10-04.csv 2026-07-07 2026-10-04, adding
--over-cap when the reconciliation line shows work items over the 5,000 item cap, --to 15:00 for a
chart that includes today, with the time it runs to, --no-wip when the view says the work in progress
of each day is not drawn, and under Show --issue-type, --project, --parent, --label, --component
or --team with the group's name as the file writes it, as --issue-type Bug or --label api.
It prints each day's work in progress at its end, - where none is drawn, and how many finished, then
the averages and the lowest, highest and last. With --cumulative it prints instead, for each day whose work
in progress is drawn, the finished band, FL10, as 2026-10-04 finished 287, then each status's band, FL9, by
the status's name as the file writes it, as 2026-10-04 band 7 In Review; a leading apostrophe there is the
file's mark, not part of the name. Under Show it prints the finished band and the work in progress, FL2, as
2026-10-04 in-progress 23. It reads every cell as text and rounds in decimals, never in binary floating
point. The face draws the bands top to bottom in the order of the Aging view's columns, which the file does not
hold; the script prints them by name.
import csv, sys
from datetime import date, datetime, time, timedelta
from decimal import Decimal, ROUND_HALF_UP
args = sys.argv[1:]
first, last = date.fromisoformat(args[1]), date.fromisoformat(args[2])
opt = lambda name: args[args.index(name) + 1] if name in args else None
with open(args[0], newline='', encoding='utf-8-sig') as f:
rows = list(csv.DictReader(f))
charted = [r for r in rows if r['row_type'] == 'issue_total' and r['charted'] == 'true']
wips = [r for r in rows if r['row_type'] == 'wip_total']
if '--over-cap' in args and charted:
first = max(first, min(date.fromisoformat(r['left_at'][:10]) for r in charted) + timedelta(days=1))
days = [first + timedelta(days=k) for k in range((last - first).days + 1)]
starts = {}
for r in rows:
if r['row_type'] == 'segment' and r['in_cycle_time'] == 'true':
at = datetime.fromisoformat(r['entered_at'])
starts[r['issue_key']] = min(starts.get(r['issue_key'], at), at)
item = {}
for r in charted:
if r['issue_key'] in starts:
item[r['issue_key']] = (r, starts[r['issue_key']], datetime.fromisoformat(r['left_at']))
for r in rows:
if r['row_type'] == 'since_total' and r['exclusion_cause'] == '':
item[r['issue_key']] = (r, datetime.fromisoformat(r['entered_at']), datetime.fromisoformat(r['left_at']))
for r in wips:
if r['exclusion_cause'] == '':
item[r['issue_key']] = (r, datetime.fromisoformat(r['entered_at']), None)
for option, column in (('--issue-type', 'issue_type'), ('--project', 'project'), ('--parent', 'parent'),
('--team', 'team'), ('--label', 'labels'), ('--component', 'components')):
if opt(option) is not None:
cells = lambda r: r[column].replace('\r', '').split('\n') if column in ('labels', 'components') else [r[column]]
item = {k: v for k, v in item.items() if opt(option) in cells(v[0])}
charted = [r for r in charted if opt(option) in cells(r)]
group = any(opt(o) is not None for o in ('--issue-type', '--project', '--parent', '--team', '--label', '--component'))
kind = {'issue_total': 'segment', 'wip_total': 'wip_segment', 'since_total': 'since_segment'}
stretches = {}
for r in rows:
if r['row_type'] in kind.values():
stretches.setdefault((r['row_type'], r['issue_key']), []).append(r)
line = next((r for r in rows if r['issue_key'] == 'wip_line' and r['row_type'] == 'p85'), None)
over = line is not None and Decimal(line['left_at']) > sum(1 for r in wips if r['exclusion_cause'] != '')
cut = max((r['entered_at'][:10] for r in wips if r['exclusion_cause'] == ''), default=None) if over else None
ref = next((r['left_at'] for r in rows if r['row_type'] in ('wip_total', 'since_total') and r['left_at'][:10] == args[2]), '')
T = None
if opt('--to') and ref:
hour, minute = map(int, opt('--to').split(':'))
T = datetime.combine(last, time(hour, minute), datetime.fromisoformat(ref).tzinfo)
def wip(d):
if '--no-wip' in args or (cut is not None and d.isoformat() >= cut):
return None
if T is not None and d == last:
return sum(1 for _, s, f in item.values() if s < T and (f is None or f >= T))
return sum(1 for _, s, f in item.values() if s.date() <= d and (f is None or f.date() > d))
def mean(values):
return Decimal(sum(values)) / len(values) if values else None
def status_at(k, d):
for r in stretches.get((kind[item[k][0]['row_type']], k), []):
if T is not None and d == last:
if datetime.fromisoformat(r['entered_at']) < T <= datetime.fromisoformat(r['left_at']):
return r['status']
elif r['entered_at'][:10] <= d.isoformat() < r['left_at'][:10]:
return r['status']
def in_progress(d):
if T is not None and d == last:
return [k for k, (_, s, f) in item.items() if s < T and (f is None or f >= T)]
return [k for k, (_, s, f) in item.items() if s.date() <= d and (f is None or f.date() > d)]
drawn, finished = [], []
for d in days:
w = wip(d)
n = sum(1 for r in charted if r['left_at'][:10] == d.isoformat())
finished.append(n)
if w is not None:
drawn.append(w)
if '--cumulative' not in args:
print(d, '-' if w is None else w, n)
elif w is not None:
print(d, 'finished', sum(finished))
if group:
print(d, 'in-progress', w)
continue
bands = {}
for k in in_progress(d):
name = status_at(k, d)
bands[name] = bands.get(name, 0) + 1
for name in sorted(bands):
print(d, 'band', bands[name], name)
if '--cumulative' in args:
sys.exit()
tenth = lambda x: x.quantize(Decimal('0.1'), rounding=ROUND_HALF_UP)
if drawn:
print('in progress at a day\'s end: average', tenth(mean(drawn)), 'lowest', min(drawn), 'highest', max(drawn), 'last', drawn[-1])
if finished:
print('finished a day: average', tenth(mean(finished)))
FL4 rounds a half up in decimals, as ROUND does in a spreadsheet; Python's own round rounds a half to
the even neighbour and works in binary floating point, so it can land a tenth below the view, as it does
for 1.45. FL1 takes a work item's start from its segment rows, not from its issue_total row's
entered_at, which is when it was created.
What the Forecast view shows
Forecast, the last of the chart views, answers two questions about the work ahead from how many charted work items finished on each day of a history the chart holds (which days):
- How many by a date: 85% chance of finishing at least 25 work items by 27 Oct 2026.
- When will this many be done, for a whole number you type from 1 to 9,999: 85% chance of finishing 60 work items by 1 Dec 2026.
The line under each answer gives the 50% and 95% figures, as in 50%: at least 31 · 95%: at least 21 or 50%: by 23 Nov 2026 · 95%: by 6 Dec 2026. A level whose figure is 0 reads not even 1, and a number the forecast does not reach at that level reads not by the last day it reaches. Every date carries its year, so a sentence copied into a plan still says which day it means. The date starts four weeks ahead, counting the day the chart was built, or as far as the forecast reaches; the number starts empty, since any number the view chose would be one nobody asked about. On a chart with work in progress, Use the 50 in progress beside the number puts in it how many work items the Aging view counts in progress, the group's under Show, when you press it and never by itself, and holds it only until the gadget is next opened: your browser keeps a number you type, not one the button puts. The forecast is then of that many finishing, whichever work items they turn out to be.
One chart answers both. For every day ahead, from the day the chart was built, the fan draws the most work items with at least a 50%, 85% and 95% chance of being finished by the end of that day, as three staircases, the band between 50% and 95% shaded. Your date and your number are the blue dashed lines, and they meet the 85% line at the two answers. Point at a day and it states its three figures; click it, or move along the chart with the arrow keys, Page Up and Page Down for a week and Home and End for the ends, and the date asks about that day. A strip under the fan shows how many finished on each day sampled: point at a day, or move to it with Tab, and it says how many; click it, or press Enter, and it lists them. On a tile narrower than 480 px the strip is inside How this is worked out, which also lists the days by how many finished on them.
The model. Each day ahead is taken to go like one of the days sampled, every one of them equally likely, each day ahead independently of the others: the model a Monte Carlo forecast of throughput uses, worked out exactly rather than by drawing trials. Nothing is random, so everyone who views the chart sees the same figures, every time, and the recipe reproduces each one from Export data (CSV). Every calendar day is sampled and forecast, weekends and holidays included, whatever the chart's calendar, and only charted work items count, each on the day it finished in the chart's time zone. Under Show, the forecast is of the group shown, and each count names it.
A forecast, not a promise. It cannot know of holidays or leave ahead, a change in the team, or work added along the way, and the view says so under every forecast. It states nothing from fewer than 30 sampled days or 20 work items, and nothing further ahead than half the days it samples. It warns when the recent pace differs from the rest of the history, when the item cap shortened the history, and when finished work items could not be read (each of these).
See the 400 work items sampled lists the work items the forecast is made from, checked as you, as every list is. Image or summary, in the footer, copies the forecast as the view states it: its answers, what it sampled and how far it reaches, the promise and its warnings (how). History, the date and a number you type are kept by your browser for the gadget, as the view is, and are never sent to the app or to Jira; another browser starts on the chart's whole range, four weeks ahead or as far as the forecast reaches, with no number (privacy).
Which days the Forecast view samples, and how far ahead it reaches
A forecast is made from how many charted work items finished on each day of a history: every calendar day from its first day to the day before the chart was built, in the chart's time zone. It takes each day ahead to go like one of those days, every one of them equally likely, each day ahead independently of the others: the model a Monte Carlo forecast of throughput uses, worked out exactly (how).
Every calendar day. Weekends and holidays are sampled like any other day, whatever the chart's
calendar, because the days ahead hold weekends and holidays too: the calendar decides how cycle time
is counted, not on which days work finishes. A day on which nothing finished is sampled as a day with
none. Only charted work items count, the ones the Trend view's bars count, each on the date
its left_at cell starts with. With working hours, a day is still sampled whole, with whatever finished
in it at any hour; but only charted work items are counted, and work started and finished outside the
hours is counted to zero and not charted, so it is not sampled. The view says so in How this is worked
out.
The history. History chooses how far back the days go: the chart's whole range, or its last 30 or 90 days, each offered only when it is shorter than the range. A chart that includes today samples the days before today: what has finished today is part of the first day forecast, not of the history. Over the 5,000 item cap the chart holds completions only from the day the earliest work item charted finished, and that day may have lost some of its own to the cap, so a history that would reach back to it starts the day after it, and the view says so.
Too little history. A forecast needs 30 sampled days and 20 charted work items finished on them. With fewer, the view states no figure, and says what the history has. Both numbers are a judgement, not a statistical rule: 30 days is the shortest rolling range, and with fewer than 20 completions the statements still came true, 91.8% of the time on the simulated teams below, but too many of them read at least 0.
How far ahead. Half as far as the history goes back, rounded down, and nothing beyond:
| Days sampled | 30 | 90 | 180 | 365 | 366 |
|---|---|---|---|---|---|
| Forecast up to, in days from the day the chart was built | 15 | 45 | 90 | 182 | 183 |
Picking sampled days shows how days vary, but not how unsure the team's pace itself is, and that grows with how far the forecast looks ahead beside how far back it samples. On simulated teams whose pace varied from week to week, the 85% statements came true 87.9% of the time up to a quarter of the history ahead, 86.4% up to a third, 85.3% up to a half, 83.7% up to three quarters and 82.1% at the whole of it, so the view stops at half.
How often it came true. On simulated teams that work weekdays, the 85% statements the view would make came true between 81.9% and 97.2% of the time. The lowest were for a team finishing about 12 work items a weekday at a pace that swung from week to week: from 90 or 365 days of history, its one- and two-week answers came true 81.9% to 84.1% of the time, a little less often than they say. Sampling weekdays and weekends apart, or weekdays alone, keeps the week's shape but came true as little as 65.0% of the time on the same teams, so the view samples every calendar day. These are measurements on models, not on real teams.
A recent pace unlike the rest. The view warns when the last third of the sampled days finished work at a daily pace at least one and a half times that of the days before them, or at most two thirds of it, and the busier of the two holds 10 or more: the history may hold two teams, as when people join or leave, and a shorter history samples only the recent one. The one and a half and the 10 are a judgement, not a statistical test.
Work items not counted. Work items not read before the time limit, or that the app is not allowed to read, finished on no day the chart knows, so the view warns that the forecast may count low. Every other excluded work item is left out of the history too, as the reconciliation line states, and if some of them were real deliveries, the forecast leans low.
A range that has ended. A forecast starts on the day the chart was built and samples the days before it, so a range that ended before yesterday gets no forecast: the last full month or quarter on any day but the first of the next one, or custom dates that ended earlier. The days between would be sampled by no one.
Checking the Forecast view against the ledger export
Every figure the Forecast view states can be reproduced from Export data (CSV), imported as the CSV format says. Nothing in it is drawn at random, so the same file always gives the same figures.
| Step | Recipe |
|---|---|
| F1 rows | Keep the rows whose row_type is issue_total and whose charted is true. For each, D is LEFT(left_at, 10), the date it finished in the chart's time zone, as in the Trend recipe. Do not convert left_at through its offset. |
| F2 days | L, the last day sampled, is the footer's last day, or the day before it for a chart that includes today. The forecast starts on L + 1, the day the chart was built. The first day sampled is the footer's first day, or L − 29 or L − 89 for a history of 30 or 90 days when that is later. When the reconciliation line shows work items over the 5,000 item cap, it is also no earlier than the day after the earliest D of all the F1 rows, even under Show: the cap kept the chart's newest completions, whatever their issue type or project. |
| F3 each day | COUNTIF of D for every calendar day from the first day sampled to L. A day with no row counts 0. Under Show, count only the group's rows: those whose issue_type is the issue type shown, or whose project is the project shown, as in S1. |
| F4 days by count | How many days had 0, 1, 2 and so on. The view lists the same, and the forecast depends on nothing else. With fewer than 30 days or 20 work items there is no forecast. |
| F5 the chances | For each day ahead h, from 1 to half the days sampled rounded down, count the ways each total t can be reached: the ways of t − k a day before, times the number of days that had k, added up over every k, starting from one way of 0. With n days sampled, a level is reached at the largest t whose ways of t or more, divided by nʰ, are at least the level less 10⁻⁹. |
| F6 the answers | How many by a day T: day h = T − L of F5. When will this many be done: the first day whose figure at the level is the number or more. |
| F7 the pace | Split the days at n − ⌊n / 3⌋: the earlier part has a days and A work items, the recent part b days and B work items. The warning shows when the larger of A and B is 10 or more and 2 × max(A × b, B × a) ≥ 3 × min(A × b, B × a). |
The tolerance in F5 counts a chance of exactly a level, such as 17 days of 20 at 85%, which a sum in decimals can land a hair under. The view works in decimals, with that tolerance, and leaves out totals less likely than 10⁻¹⁸ at either end of the totals, which can only make a figure lower, never higher.
In Python 3, with the file, the footer's first day and L:
python3 forecast.py cycle-time-ledger-2025-09-30-to-2026-09-29.csv 2025-09-30 2026-09-29, adding
--history 30 or --history 90 for a shorter history, --over-cap when the reconciliation line shows
work items over the 5,000 item cap, and under Show --issue-type Bug or --project PAY for the
group shown (--issue-type '' for No issue type). It prints the days by count, then one line for
each day ahead: the date, and the most work items with at least a 50%, 85% and 95% chance of being
finished by the end of it. How many by a date is that date's line; when will this many be done is
the first line whose figure is the number or more. It counts in whole numbers, so nothing is rounded,
in a few seconds for most teams, and for longer where some day finished hundreds of work items at once.
import csv, sys
from datetime import date, timedelta
args = sys.argv[1:]
first, last = date.fromisoformat(args[1]), date.fromisoformat(args[2])
with open(args[0], newline='', encoding='utf-8-sig') as f:
rows = [r for r in csv.DictReader(f) if r['row_type'] == 'issue_total' and r['charted'] == 'true']
if '--history' in args:
size = int(args[args.index('--history') + 1])
first = max(first, last - timedelta(days=size - 1))
if '--over-cap' in args and rows:
first = max(first, min(date.fromisoformat(r['left_at'][:10]) for r in rows) + timedelta(days=1))
for option, column in (('--issue-type', 'issue_type'), ('--project', 'project')):
if option in args:
rows = [r for r in rows if r[column] == args[args.index(option) + 1]]
dates = [date.fromisoformat(r['left_at'][:10]) for r in rows]
days = max(0, (last - first).days + 1)
per_day = [0] * days
for d in dates:
if first <= d <= last:
per_day[(d - first).days] += 1
counts = {}
for c in per_day:
counts[c] = counts.get(c, 0) + 1
print('days by count:', ' · '.join(f'{k} on {counts[k]} days' for k in sorted(counts)))
if days < 30 or sum(per_day) < 20:
sys.exit(f'too little history: {sum(per_day)} work items on {days} days')
print('date', '50%', '85%', '95%')
ways = {0: 1}
for h in range(1, days // 2 + 1):
ahead = {}
for total, w in ways.items():
for k, m in counts.items():
ahead[total + k] = ahead.get(total + k, 0) + w * m
ways, tail, row, whole = ahead, 0, {}, days ** h
for total in sorted(ways, reverse=True):
tail += ways[total]
for level in (50, 85, 95):
if level not in row and 10**9 * tail >= (level * 10**7 - 1) * whole:
row[level] = total
if len(row) == 3:
break
print(last + timedelta(days=h), row[50], row[85], row[95])
A spreadsheet cannot hold numbers that large, but it can come close. Put the F3 counts in one column;
in each of 10,000 rows, add h picks of INDEX(counts, RANDBETWEEN(1, n)); then the 85% figure is
LARGE(totals, 8500), the 50% LARGE(totals, 5000) and the 95% LARGE(totals, 9500). That is a
Monte Carlo simulation of the same model, so its figures move each time the sheet recalculates, and
land further from the view's the busier the team and the further ahead. On simulated teams sampling a
year, all three of a sheet's figures were within one work item of the view's in at least 92.5% of
sheets for a team finishing 4 or fewer work items a weekday, up to half a year ahead. For a team
finishing 12 a weekday, half a year ahead, that held in 32.5% of sheets, typically 2 off and as much
as 4; for one finishing 40 a weekday, four weeks ahead it was typically 2 off and as much as 7, and
half a year ahead typically 6 and as much as 15. For a busy team, or a date months ahead, check with
the Python above, which is exact.
Why the totals do not match a calendar
Because a day here is 24 counted hours, or, on a chart counting only working hours, one working day of counted hours, the average one where each weekday has its own. Three counted days can span a fortnight if most of that fortnight was weekends and holidays, and three working days of 8 hours a week of evenings and nights. The drill panel shows the arithmetic for any work item, line by line, including what was excluded and why; on a chart counting only working hours it says under its heading what d is, as in d is a working day of 8 h, 09:00–17:00., or, where each weekday has its own hours, d is 7.2 h, the average working day of Mon–Thu 09:00–17:00, Fri 09:00–13:00., so that a work item's 1 d 4 h counted beside 64 h excluded adds up to the 76 hours from its start to its end. Its times are shown to the minute, and each line's minutes are rounded as a set so that a work item's lines add up to its totals, so a line can differ by a minute from its exit time minus its entry time; the CSV export has the seconds.
The reconciliation line
Directly under the headline, or under the chart title when nothing is charted and there is no
headline, is a line reading, for example, 142 work items charted · 11 excluded, itemised under the chart. While a chart is drawn, the reasons, each with its count, and any note about how the chart was
read follow on a line under the chart and its key, always shown and never collapsed; press the words
after the count to go straight to them, past the chart's bars and dots. With one group
shown, the line under the headline names that group instead and says the counts are below. When
nothing is charted there is no chart to be under, and the reasons follow the count on the one line.
Those two numbers add up to every work item that counts as completed
in the selected range, by the rule below, with two exceptions the chart tells you about when they
apply: work an organisation's app access rule keeps from the app's searches
(the app is not allowed to read), and, past 10,000 search results, counts that
are Jira's estimate (over the 5,000 item cap). Nothing else in that population is
dropped silently, with two exceptions the app cannot see: a work item imported straight into a Done
status and reopened since, because Jira's search does not know the status it was imported in; and a
work item whose move into Done came from an import, when it is not in a Done status now, whatever its
creation or resolution date, or when it was created before the range and its resolution date is not in
it (history that came from an import).
The population is not everything the filter matches. A filter can match thousands of work items; this chart is about the work that finished in the window you chose — see Date range. Jira is asked, as you, for the work items your filter returns for you that entered one of your Done statuses during the range, or were created or resolved during it and are in one of them now: the same work items the filter would list for you in Jira. The last two parts also return work that finished outside the range, such as work created in it and finished since it ended, which the app reads and then leaves out. A second search of yours reads the work in progress for the Aging view. When the range runs to the day the chart is built for, a third reads the work that finished after the range ended and before the chart was built, up to 1,000 of them, which the export lists after the work in progress (the CSV format), no figure of finished work counts, and the Flow view counts in progress on the days before they finished. Nothing else is read.
A work item it reads counts as completed in the range when:
- it is in a Done status now, and its most recent entry into Done falls inside the range; or
- it has been reopened and is not in a Done status now, and any of its entries into Done falls inside the range. It appears in the excluded count as transitioned backwards after Done: it did finish in your window, and dropping it silently is exactly what this chart exists not to do.
An entry into Done is a move into one of your Done statuses from a status that is not one, or the creation of a work item in a Done status. A move from one Done status to another, such as Done to Closed, or the Done to Done change Jira records when finished work moves to another project, is not a new entry: the work item was already done, and keeps the completion date it had.
Other work items the search returns are discarded before counting, apart from the exceptions below. Discarded work includes work that finished inside the range, was reopened, and was completed again after it, which is judged by its latest completion, and work whose only move into a Done status in the range was from another Done status. Work that has not finished has no end, so it has no cycle time, and none of the figures above counts it. The Aging view reads it with a second search of yours and shows how long each work item has been in progress against these same percentiles.
The exceptions, stated rather than guessed around. For four kinds of work item the app cannot tell when the item finished, so it counts them under their own reasons rather than dropping them:
- items whose history it could not read in full — not read before the time limit and incomplete history in Jira;
- items your search returned that the app is not allowed to read — the app is not allowed to read;
- items whose history has no completion among your Done statuses — still open;
- when Jira's search returns more than 10,000 work items, the ones beyond the 10,000 last updated, which are counted as over the 5,000 item cap without their histories being read.
So a few of these may be items last completed after the range, which the rule above would have discarded had the app known.
Click any reason to see exactly which work items it covers, except over the 5,000 item cap, which has no list. The list it opens has a Why is this excluded? link to that reason's section of this page, and the item cap, having no list, links to its section itself. Click any bar, dot or By status row to see the arithmetic behind it; point at a bar or a dot, or move to it with Tab, and it first says what it holds. On the scatter, time runs across the chart's whole range, its dates marked at midnight in the chart's time zone, and cycle time up its side, in days, or in hours where none took more than a day, as its title says; a dot drawn on top of others opens every work item at that spot, its heading saying how many more there are. Export data (CSV), in the footer, gives you the same figures as a file, the ledger, one row per status segment plus one row per work item, finished or in progress, plus closing rows restating the 50th, 85th and 95th percentiles of cycle time and the 50th, 85th and 95th of lead time, and the Aging view's three lines — so you can check the chart in a spreadsheet without trusting this app at all.
The CSV format
Twenty-three columns, RFC 4180, UTF-8 with a byte-order mark so Excel reads the characters correctly.
Every hours figure has exactly four decimals, a full stop as the decimal mark and no thousands
separator: 4.6157, 0.0000. If your spreadsheet uses a comma as the decimal mark or a semicolon
as the list separator, double-clicking the file will not read it correctly. Import it instead:
- Excel: Data › From Text/CSV, choose Comma as the delimiter, then Transform Data, select the hours columns and use Change Type › Using Locale with the type Decimal Number and the locale English (United States), and set the type of issue_key to Text.
- LibreOffice Calc: in the Text Import dialog, tick Comma as the only separator, set Language to English (USA), and in the preview set the type of the issue_key column to Text.
Skip that step and a spreadsheet may read 1.2500 as something other than one and a quarter
hours, or leave it as text. A work item key that reads like a date, such as MAR-12 or DEC-25,
can also become a date when the file is opened by double-clicking it, or imported with that column
left to be detected; MAR-1 and MAR-2026 can then become the same date. Setting issue_key to
Text keeps every key as Jira wrote it.
Export saved filters (CSV), on a tile of several saved filters side by side, is
another file, made in your browser from the rows on the tile, so nothing more is asked of Jira or the
app. It has a line per saved filter you can open, in the settings' order, and eleven columns:
filter_place, its place in the settings from 1, which tells two of one name apart; filter_id;
filter_name, as Jira names it to you; charted, excluded, and also_in_another, how many of its
charted work items another row charts too; p50_hours, p85_hours and p95_hours, its own export's
cycle_time closing rows' exact hours, whether or not the table states them; max_hours, its slowest
charted cycle time; and stated, 50,85,95, 50,85 or none, which of them the table states. Hours
are written as this file writes them, and are blank where nothing is charted. On a tile counting only
working hours the file ends with one more line, working_day, the window in filter_name, as
09:00 to 17:00, or the week, as Mon-Thu 09:00 to 17:00 and Fri 09:00 to 13:00, and the working day in
hours in stated, as 8.0000, or the average working day, as 7.2000, every other cell blank. It is named after the
days its rows cover and never after a saved filter, as
cycle-time-saved-filters-2026-07-02-to-2026-09-29.csv. While the table is set beside the period
before, once every row's period before is in, it has six more columns: before_first_day and
before_last_day, the period before's days; before_charted and before_excluded, its counts;
before_p85_hours, its own export's cycle_time 85th; and verdict, the verdict its own chart
states against the period before, capped, few, faster, slower or same; all six are blank
for a saved filter that charts nothing, and on the working_day line. It is then named after both periods, as
cycle-time-saved-filters-2026-07-02-to-2026-09-29-vs-2026-04-03-to-2026-07-01.csv.
With four quarters shown, once every row's quarters are in, it has fifteen more columns, sixteen with verdict
while the table is set beside the period before too: the period before's five, before_first_day to
before_p85_hours, and, beside the period before, verdict; then the same five for the second and third quarters before,
before2_first_day to before2_p85_hours and before3_first_day to before3_p85_hours, each that quarter's days,
its counts and its own export's cycle_time 85th; all are blank for a saved filter that charts nothing, and on the
working_day line. While a target is shown, target_hours and within_target come last. It is then named with
-since- and the first quarter's first day after any -vs-, as
cycle-time-saved-filters-2026-07-01-to-2026-09-30-since-2025-10-01.csv.
The recipe checks it against the saved filters' own exports. A saved filter shown from a tile of several adds its
place in the settings to every file it gives, as cycle-time-ledger-filter-3-…, the filter_place of
Export saved filters (CSV).
To compare an hours figure with the minutes on the chart or in a panel, round it to the second
first, ROUND(hours * 3600, 0) / 60, then to the minute. Both are roundings of the same whole
second, so rounding the four-decimal hours straight to minutes lands a minute away about once in 180
values.
Any text that begins with =, +, -, @, a tab or a carriage return, after any spaces, is
written with a leading apostrophe, so a spreadsheet shows it as text instead of running it as a
formula. A field containing a comma, a semicolon, a tab, a quote or a line break is quoted. A
spreadsheet that splits the file on semicolons or tabs ignores those quotes and still splits such a
field across cells — the Polish holiday Święto Państwowe; Święto Pracy lands in two, and every
cell after it moves along one — so an apostrophe is also written after each comma, semicolon, tab
or line break inside a field that one of those characters, or a quote, follows, spaces or not.
Split on commas, semicolons, tabs or line breaks, with or without trimming spaces, no piece of a
field runs as a formula; to keep the columns in place, import with the comma as above.
Each work item contributes one segment row for each stretch between its status changes, so a
status it entered twice has two rows, and a stretch that spans its creation date is split there into
two rows; then one issue_total row. A work item the reconciliation line counts without the app having read its
history, one not read before the time limit or one
the app is not allowed to read, has its issue_total row only. Work items over
the 5,000 item cap have no rows. A segment row's excluded_reason names every calendar that removed time from
it: weekend, then each public holiday as holiday:, the code of the list it is on and the holiday's name,
the code being the country's, as DE, or a state's or region's, as DE-BY for Bayern,
then each day the whole team is off that is not such a holiday as team-day-off: and its date, as
team-day-off:2026-12-24, then, on a chart counting only working hours, off-hours for the time outside them,
joined by +, as in weekend + holiday:DE:Tag der Deutschen Einheit or weekend + off-hours. The drill panel
says the same in words, as in 3 d excluded (weekend, public holiday Tag der Deutschen Einheit) or 1 d excluded
(team day off 24 Dec 2026), with a holiday's name in quotation marks where it holds a comma or an and, so that
it reads as one name.
On a chart counting only working hours it writes the time outside them last, and writes excluded time in
hours and minutes, which a working day does not measure, as in 64 h excluded (weekend, outside working
hours). A work item
still open, or moved back after Done, has a last row that has not
ended: its left_at is the end of the chart's range, in the gadget's time zone, not a status
change. For a range that runs to yesterday that is the start of the day the chart was built; for one
that ended before, the start of the day after its last; and for a chart that
includes today, the quarter hour it runs to. If the work item changed status since
then, its last row ends at that change instead, and the status it is in now has no row. For a range
that runs to yesterday its hours grow once a day, with each day's chart, not at each rebuild.
Neither total uses that row.
Work in progress, which the Aging view plots, follows the finished work in rows of its own: for each
work item, one wip_segment row for each stretch between its status changes, two where its creation
date falls inside one, then one wip_total row. Those plotted come first, in the order they started, then those counted and not plotted. A
wip_segment row's in_cycle_time is true for the stretches its age is counted over, and its
in_lead_time is blank. Its last row ends at the moment the chart was built, not at the end of the
range. On a wip_total row, status is the status the work item was in at that moment, entered_at
its first move into a Started status, left_at that moment, and issue_cycle_time_hours its age;
charted and the lead time are blank, and exclusion_cause is blank when it is plotted and names the
reason when it is not. One not read before the time limit, or one the app is not allowed to read, has
its wip_total row only, and work in progress over the Aging view's cap has no rows. No recipe for
finished work uses these rows: each selects segment or issue_total rows by name.
Work that finished after the chart's range and before it was built, which a third search reads when
the range runs to the day the chart is built for, follows the work in progress in rows of its own: a
since_segment row for each stretch between its status changes that began, from its first move into a
Started status, before the range ended, then one since_total row. A since_segment row's status,
entered_at and left_at are the stretch's, the last of them ending when the work item left that
status, after the range ended; its in_cycle_time is true, and every other cell is blank but
issue_type, project and the last four columns, as on its since_total row. No hours are counted for
these stretches, and no recipe sums them: they say which status the work item was in at the end of
each day of the range. On a since_total row, status is the Done status it was in when it was read,
entered_at its first move into a Started status and left_at its last move into a Done status. Those
whose start is known come first, in the order they started. One whose history the app did not read,
because it was not read before the time limit, the app is not allowed to
read or Jira withheld part of it, has its entered_at and
left_at blank, its reason in exclusion_cause and no since_segment row. Every other cell of the row
is blank but issue_type and project. These rows are neither finished work nor work in progress: no
recipe for either selects them, and they change no other row of the file; the Flow
recipe reads them. A work item that finished after the range with no move into a Started
status, or that finished before the range ended, has no row of these kinds.
The columns issue_type and project are filled on every segment, issue_total,
wip_segment, wip_total, since_segment and since_total row. issue_type is the name of the work item's issue type when the chart was built, so a work item
whose type changed during the range has the type it had then; it is blank for a work item the app
did not read, one the app is not allowed to read. project is the part of the
work item's key before its first hyphen, LEFT(issue_key, FIND("-", issue_key)-1), which is the
project the key names; nothing about the project is read from Jira. Both are written as any other
text is, as described above.
The two columns after project, sprint and sprints, are filled on a finished work item's segment and
issue_total rows where your site has a Sprint field: sprint is the id of the sprint it counts in,
blank when it counts in none, and sprints the ids of its sprints the chart keeps, ascending, separated
by spaces (which sprint). They are blank on every other row. After the work items' rows and
before the closing rows comes one sprint row for each sprint those cells name: its id in sprint, its
name in status, as Jira named it to you when you exported and blank where it did not
(why), when it started in entered_at and when it closed in left_at, each blank
when Jira holds none, and its state, future, active or closed, in exclusion_cause; every other
cell is blank. Where the chart's sprints could not be read, or it holds more than 100, one sprint row
with a blank sprint cell says so in exclusion_cause, sprints_not_read or sprints_withheld, and
the sprint and sprints cells of every row are blank. Checking the sprints shows
how to audit them.
The last four columns, parent, labels, components and team, are filled on every row
issue_type is filled on. parent is the key of the work item's parent, its epic for a standard work
item or its parent for a sub-task, blank when it has none and blank when you cannot open the parent in
Jira: when you export, the app asks Jira, as you, which of the parents you can open, and names only
those. labels holds its labels and components the names of its components, and team the name of
its team in Jira's Team field, where your site has one, each blank for none. A chart whose build could not
read your site's list of fields reads no team, so every team cell of its file is blank, and its sprint
row says sprints_not_read, as for the sprints above. A cell holding several
values, as two labels, has each on a line of its own: the values are separated by a line feed alone
(CHAR(10)) inside the quoted cell, while every row of the file still ends in a carriage return and a
line feed. Each value is written as any other text is, so one that begins with =, +, -, @ or a
tab has an apostrophe before it, first in the cell or after a line break. Import the file as above and
each cell stays one cell, its lines kept; a spreadsheet shows them stacked in the cell. A value holding
a line break of its own, which Jira's names do not, is never written: the app leaves it out of that
work item. One parent, label, component or team shows how to take a group of them
from the file.
The file ends with nine closing rows, then, from a view grouped by board column, its board_column rows, then
one started_status row for each of the chart's Started statuses that its charted work items spent cycle time in,
then, on a row of sources side by side counted in its holiday list's own time zone,
calendar_zone, then, on a working-hours chart, working_day. The nine are one for each percentile the chart states and each line the
Aging view draws: three cycle_time rows, for its 50th, 85th and 95th percentiles (p50, p85 and
p95 in the second column), then a lead_time row for its 85th (p85), then three wip_line rows,
p50, p85 and p95, then two more lead_time rows, for its 50th and 95th (p50 and p95), last so that
no row a spreadsheet already refers to moves. Each of the first four and the last two holds the percentile in hours,
the number of work items it was computed over, and the number it left out, all of them finished work; the three
lead_time rows have the same two counts. Each wip_line
row holds its line in hours, which is the percentile as the chart states it, rounded up, then how
many work items in progress are plotted and how many are not, those over the cap included; those
counts are over the wip_total rows, and no since_total row is among them. When the
search for work in progress, or the app's read of what it found, failed, the file has no work in
progress and no wip_line rows: the first four are followed by the two lead_time rows, then the started_status
rows, and the calendar_zone and working_day rows where there are those. A started_status row names one Started status in its second
column, written as the file writes any status, in the order the By status view lists
them, its counts blank; the file of a list, of finished work or of work in progress, names the chart's
Started statuses too. The file of ages measured on their own, Export ages now (CSV), and its lists have
no started_status rows. A file exported while the Aging or By status view is
grouped by board column, the whole ledger, a list or the ages measured when the view opens, has
one board_column row for each of the chart's statuses a column of the board holds: the column's name in its
second column and the status in its third, each written as the file writes any status, in the board's order,
its counts blank. A status of the chart no row names is in Not on the board; a column holding none of the
chart's statuses has no row (A15). A calendar_zone row names, in its second column, the time zone a
row of sources side by side was counted in, as America/Chicago, where its holiday list names one other than the
gadget's: its weekends, holidays, team days off and working hours fall by that zone's clock, while every time in the
file is in the gadget's zone. Its counts are blank, and no recipe reads it; every other file has no such row. On a chart
counting only working hours one more closing row follows, always last: working_day, the window in
the second column, as 09:00 to 17:00, and the working day in hours in the third, as 8.0000, its
counts blank. It is the D every recipe divides by; a chart counted every hour or on weekdays has no
such row, and D is 24. On a chart counting working hours that differ by weekday its second column is the
week, each run of weekdays with one window, as Mon-Thu 09:00 to 17:00 and Fri 09:00 to 13:00, with no
comma or semicolon, and its third the average working day, as 7.2000.
When a line has nothing to compute over, its percentile cells are blank, not zero. The closing rows are the rows whose exclusion_cause is
chart_total; their issue_type, project, sprint, sprints, parent, labels, components and team are blank, so
chart_total is not their last cell.
Why a "within" figure is rounded up shows how these hours become the figures on the
chart.
The two metrics close over different populations, and a number you cannot reproduce is the thing this app exists to avoid:
cycle_timecloses over the rows wherechartedistrue.lead_timecloses over the rows wherechartedistrueorexclusion_causeisNEVER_STARTED, ignoring any row whoseissue_lead_time_hourscell is blank — a work item that never entered a started status has no cycle time but usually does have a lead time, and a blank cell means the app is declining to state one for the reasons above. All three of its rows, the 85th, 50th and 95th, close over that one population. The chart states that population beside the number too, so in the ledger export your count should match its N exactly. With Lead time chosen the view draws that population, and checking lead time against the ledger export reproduces each of its figures.
A list exported from a panel, with Export this list (CSV), holds only the work items listed, and
its closing rows are computed over those alone: their percentiles and counts belong to the list,
not to the chart. Only Export data (CSV) reproduces the chart's numbers. A list of finished work closes on the
six rows for finished work, the first four and the two last, and no wip_line row. A list of work in
progress closes with the six rows for finished work blank, at 0 and 0, and with the wip_line
hours of the lines its panel drew beside the list's own counts: the chart's, or, opened with a
group shown, that group's, as the split recipe gives them.
To group the rows by the week, fortnight, month, quarter or sprint they finished in, as the Trend view does, see checking the Trend view against the ledger export. To group them by issue type or by project, see checking one issue type or project against the ledger export. To check the Aging view, see checking the Aging view against the ledger export. To check a comparison with the period before, which is two charts and so two files, see checking a comparison with the period before against the ledger exports.
The identity that must always hold: for any work item, the sum of counted_hours across its
segment rows where in_cycle_time is true equals its issue_cycle_time_hours, to the fourth
decimal. If it ever does not, the file is wrong and you should say so. The same holds for
in_lead_time and issue_lead_time_hours, and for a work item in progress over its wip_segment
rows and its wip_total row; each closing row recomputes, to the fourth decimal,
from the population named above; and on every segment row, counted_hours is elapsed_hours
minus excluded_hours.
The figures are rounded so that all of this is exact. Each stretch between two status changes is
first measured in whole seconds, and a work item's cycle and lead time are built from those. Its
two totals are those times rounded to the nearest ten-thousandth of an hour (0.36 seconds), and its
segment figures are rounded up or down, as a set, to add up to them. Jira records status changes to
the millisecond, and entered_at and left_at show those milliseconds, so a segment's
elapsed_hours can differ from its left_at minus its entered_at by up to 0.00024 hours
(0.86 seconds): up to half a second from the whole-second measurement, the rest from the rounding.
Where both timestamps are whole seconds, the difference is under 0.0001 hours.
The chart as an image or a summary
Image or summary, in the footer beside Export data (CSV), opens a panel under it with the chart as an image and its answer as a few lines of text, for a slide, a page or a message. A tile of several saved filters side by side offers both for the table of all of them, once every row is ready, with every saved filter you can open by name, and for a saved filter shown on its own, by pressing its row, with its name. Your browser makes both from what the tile shows you: nothing is asked of the app or of Jira to make them, nothing about them is sent anywhere or stored, and no event is recorded. The clipboard is written only when you press a copy button, and never read.
The image is made as the panel opens, and the panel shows it before you take it. It is a PNG
1,920 pixels wide, always on a light background whatever your Jira theme. It shows what the tile shows
for the view you chose, in the tile's order, with the chart first: the filter's name as its title, the view and the range
with its first and last day, the headline, how many work items are charted, the view's own sentences,
the chart, its key or the comparison with the period before, the reconciliation line with every reason for
exclusion and every note about the data, the footer's two lines, the tile's footer with Time zone, build
time and method open, which name the filter, the range,
whether weekends and holidays are counted, the time zone and when the chart was built, and a last line
naming the app and where its rounding is explained. Download PNG sends it to your browser's
downloads, named after the view and the range's first and last day in the chart's time zone, as
cycle-time-histogram-2025-01-01-to-2025-12-31.png. With one group shown the name
adds it, as cycle-time-histogram-type-bug-… or, for a parent, by its key, as cycle-time-histogram-parent-pay-12-…,
never its summary, and a name in a script a file name cannot hold adds a
six-character code made from it instead; while the tile compares with the period before, it ends
with -vs- and that period's days; with four quarters, then -since- and the first quarter's first day; for a
chart that includes today, the days are followed by the time
it runs to, as -1500. A saved filter shown from a tile of several adds its place, as
cycle-time-histogram-filter-3-…; the table's is cycle-time-saved-filters-…. The filter's name is
never in the file name. Copy image puts
the image on the clipboard. It is offered only where your browser can copy an image and the
dashboard's frame lets it, and is not shown otherwise.
The summary is one paragraph and a line saying where its figures come from. Its first sentence stands alone: the 85th percentile of cycle time over the charted work items, how many they are, which days it does not count, the filter and the days. The rest is the tile's own words: the line under the headline while it compares with the period before, the 50th percentile from 7 charted work items and the 95th from 20, and the 70th beside them while the key states it (the 70% line), the view's sentences, on By status its flow efficiency as in Flow efficiency: 62% of cycle time was in your Started statuses, marked below, and 38% in other statuses between start and finish., or under Show that it is stated for the whole chart only, lead time's 85th from 7 work items as the key states it (beside the period before, the table that takes the key's place states it, in the Markdown only), the target while one is shown on a view that draws it, as in Target 5 days: 18 of 23 finished within it (78%)., or on Aging Target 5 days: 6 of 14 work items in progress are past it., on Scatter the line of its natural process limits while they are shown, as in Natural process limits of the 287 cycle times shown, taken in the order they finished: average 4.2 d, upper limit 13.6 d. 6 took longer than it., the reconciliation line, and each note that marks a limit of the chart; the note that history was read one work item at a time, which leaves the numbers unaffected, is left out. Under nearest rank a percentile of fewer work items is the slowest of them, so the summary leaves it out rather than state it with no chart beside it. Copy text copies it as plain text. Copy Markdown copies it as Markdown, which sets the figures in bold, adds the table of Compare's rows, of each status's stays on the Aging view, or of the chart beside the period before, where the tile shows one, each with its Within column or row while a target is shown, a share with its count beside it, as in 78% (18 of 23), and links the method to this page. The image draws the target's rule and states its sentence where the face does, and its tables' shares with their counts; on Scatter it draws the natural process limits' rules and rings, keys their figures after the target's and states their line under the key. The box under Summary shows what was copied.
On the Aging view both state the ages the view shows, the chart's own or those measured when it opened, with the note that says when, and the sentence on the stays, or under Show the line that says why there is none; the image draws the table of each status's stays under the key, as the tile does.
On the Flow view both state the headline, the definition of in progress while a figure of
work in progress is stated, and the note with its averages, in the view's words. Its warnings, and the
line of work items counted on no day, follow the reconciliation line and its notes, as the Forecast
view's do. The image draws the two run charts as the tile draws them 640 pixels wide, and its file is
named cycle-time-flow-…. In its cumulative form, both state the form's note after the definition, under
Show the line that says it is one band, and the last day's bands, as in At the end of 4 Oct 2026, 23 were in
progress: 7 in In Review, 12 in In Progress, 4 in To Do; 287 finished from 10 Mar 2026., and the image draws the
bands and their key. Every figure in either is the view's, which the recipe
reproduces from the ledger export.
On the Forecast view both state the forecast as the view does, in its words: each
answer it gives, with the line of 50% and 95% under it, which days it sampled, the day it starts on and
how far ahead it reaches, and that it is a forecast, not a promise. Its warnings follow the reconciliation line
and its notes, so the reasons for exclusion the warning of work items not read points to come first.
The image draws the fan with your date and your number on it, and the strip of the days sampled under
it, as the tile draws them 480 pixels wide and
wider, and its file is named cycle-time-forecast-…. Neither states an answer the view does not: none for
a number the field does not take or a date it cannot answer, and, where the view forecasts nothing, its
reason instead. Every forecast figure in either is the view's, which the recipe
reproduces from the ledger export.
Every "within" figure in either is the tile's, rounded up, so the ledger CSV reproduces it. Neither names a work item but a parent the chart shows, by its key and, once you have chosen Parent, its summary, and any a JQL query's text names, which a copy states whole: the image draws no drill panel and no tooltip, and nothing a screen reader reads on the chart, which names each scatter dot by its work item's key; the summary states counts and figures. Once you paste or send either outside Jira, though, Jira's permissions no longer decide who sees it: anyone who sees it can read the figures, the filter's name or the query's text, the dates, the calendar, the time zone, and the status, issue type, project, parent, label, component and team names on it, and a parent's summary, as with a screenshot.
When it does not work:
- This browser could not make the image. The summary below still works. The browser refused to draw the image, and nothing was saved or copied. Copy the summary instead, or take a screenshot of the tile.
- This list is too long for one image. … A Compare list shown in full, at about 240 groups or more, would make an image taller than a browser can draw, so none is made. Show fewer makes an image of its first rows and how many more there are; Copy Markdown lists every row.
- This browser did not let the tile copy the image. Use Download PNG instead. The clipboard refused the image. Download it, and add the file to your slide or page.
- This browser did not let the tile copy. The summary is selected in the box above: press Ctrl+C, or ⌘C on a Mac. The clipboard refused the text, which the panel selects for you to copy yourself; after Copy Markdown, the Markdown is selected.
- Image sent to your browser's downloads as … says the file was handed to your browser. A browser set to block downloads blocks it without telling the tile, so if no file arrives, look at its download settings.
The chart on the whole screen
Full screen, the last action in the footer, fills your screen with the tile, for a retro or a review. The tile is drawn 1,155 pixels wide and enlarged to fit your screen, up to three times; on a screen narrower than 1,219 pixels it is drawn 616 pixels wide, and on a phone as wide as its screen allows. A view taller than the screen scrolls. Everything on it works as on the dashboard, and asks and records what it does there. Press Exit full screen or Escape to leave. On a classic dashboard the tile reloads every hour; on a new dashboard the tile does not refresh its chart until you leave. Going into or out of full screen stores nothing and records no event, and asks nothing of the app or of Jira but what a view drawn at the wider width asks there: the Trend view by sprint, chosen in full screen where the dashboard's tile is too narrow for it, reads its sprints' names as you, as it does on a dashboard wide enough for it. What you put on a shared screen can be read by everyone in the room, whatever Jira lets them open. Where your browser cannot fill the screen from inside Jira's frame, Full screen is not offered.
If your browser refuses, the footer says Your browser did not let the tile fill the screen. Press Full screen again; a browser asks for a press of your own each time, and a frame's settings or the browser's own can forbid it.
A summary on a schedule, through Jira Automation
Two actions put a chart's summary into a Jira Automation rule, for the rule to send on its schedule. Write a Stintwise summary writes the summary that Copy text and Copy Markdown give for a tile set up in the action's form, on its first view: the histogram's for one source, the table's for several. Write a Stintwise comparison writes the same, set beside the period before, as Compare with … states it. The app sends nothing; your rule sends it, by the step you add after the action. Jira Automation's editor, and Atlassian's newer pages, call a rule a flow.
The action's form is the tile's settings, with this paragraph above them:
This action writes the summary of the chart that the person whose connection it uses would see on a tile set up like this, counted as them. Only settings that person saved can run: if anyone else saves these settings, the action stops until that person saves them again, and if a saved filter's query changes, it stops until they save them again. A saved filter whose query names another saved filter or uses a function an app adds to Jira cannot be a source, since either could change what it returns while its query stays the same. Whoever the rule sends the summary to, and anyone who can add a recipient to the rule, can read what it states whether or not Jira lets them open its sources: the figures, each source's name, the sprints' names, each source's holiday country or region, the time zone, when the chart was built, and how many sources that person cannot open.
A saved filter or a project can be a source; a JQL query cannot, and the form's sources field is
Saved filters or projects. A query among the sources is answered under them with A summary this action sends
would state a JQL query's whole text to everyone the rule sends it to, so a JQL query cannot be a source here.
Save it as a filter in Jira and choose the filter. Nor can a saved filter whose query holds filter, request,
savedFilter, searchRequest or issueFunction anywhere, in capitals or not and inside quotes too, so
issuetype = "Service Request" among them, or calls a function that is not one of Jira's own. The first four can
name another saved filter, which Jira reads when it searches; issueFunction and a function that is not Jira's are
an app's, and the app decides what they return. Either could change what the filter returns while its query, which
the action checks at every run, stays the same. When the form saves one, nothing is handed to the rule, and the
form says under the sources A saved filter chosen here has a query that holds the word filter, request,
savedFilter, searchRequest or issueFunction, in capitals or not and even inside quotes, or calls a function that is
not one of Jira's own. Such a word can name another saved filter or an app's field, and such a function is an
app's: either could change what the summary states while the query stays the same, which this action could not
notice, so choose another saved filter. A run that finds one stops, as for a changed query. Where the charts
of several sources list more work items between them than one run can check in time, counted as that person when the form saves them, the form hands
the settings to the rule and says under the sources This table is too large for one run of this action: its charts
list more work items than a run can check in time, so its summary would not be ready. Choose fewer sources, or
sources with fewer work items. Settings too large for the rule are not handed to it, and the form says These
settings are larger than a Jira Automation rule can keep. Choose fewer sources. Where a
tile's summary speaks of you, the action's speaks of the person whose connection this action uses
(who can read it).
What the action hands the rule. Four outputs, by these names. The rule editor offers Write a Stintwise
summary's as the smart values {{fetchedStintwiseSummary.ready}}, {{fetchedStintwiseSummary.text}},
{{fetchedStintwiseSummary.markdown}} and {{fetchedStintwiseSummary.note}}, and Write a Stintwise comparison's
as {{fetchedStintwiseComparison.ready}}, {{fetchedStintwiseComparison.text}},
{{fetchedStintwiseComparison.markdown}} and {{fetchedStintwiseComparison.note}}.
ready: true when every chart the summary states is built; false while one is being built or waits its turn, or when the table is too large for one run to check.text: the summary as plain text, empty whilereadyis false.markdown: the summary as Markdown, empty whilereadyis false.note: why the summary is not ready, in the tile's own words, such as This chart is being built. or This chart is waiting its turn to be built., or, once your site's new charts this hour, at tiles and by rules together, have used half your site's part of Jira's hourly limit, or once Jira says less than a fifth of the app's hourly limit, which every site shares, is left, Stintwise leaves the rest of this hour's Jira limit to people at their tiles, so this summary's charts wait until HH:MM (zone)., or, for a table whose charts list more work items than one run can check, This table is too large for one run of this action: its charts list more work items than a run can check in time. Choose fewer sources, or sources with fewer work items.; empty when it is ready.
A run that is not ready is not a failure, and the rule goes on. A run fails, and the rule stops with the action's sentence in its audit log, when someone must act first, or when a read or a chart's build failed. Settings the action's form did not write or someone else saved, a saved filter whose query changed since they were saved, and a person who has not allowed Stintwise to read Jira as them wait on the person whose connection the action uses, and the sentence says what they do. The one source, or every source of several, that person cannot open waits on whoever can let them open it, or on that person choosing other sources. A site where Stintwise is not licensed waits on whoever manages your site's apps, though its sentence, Stintwise is not licensed on this site., names no one. A read or a build that failed names no one, and the next run tries again: a read that failed during the run, with Something went wrong or a sentence such as A chart in these settings could not be built: Jira is rate limiting or unavailable, at once; a chart whose build failed, with a sentence such as A chart in these settings could not be built: Something went wrong, at the first run ten minutes or more after it failed. One that failed for its source, such as A chart in these settings could not be built: Jira rejected the filter query, fails again until someone fixes the source (how). Of several sources, those that person cannot open are counted, not named.
The recipe. A chart is built once a day for each person, and building one takes longer than a run of the action waits, so the run that sends a summary finds it ready only when an earlier run that day started its charts. Every summary needs two rules, each with the action, the same settings saved by the same person, and that person's connection:
- A warm-up rule: a Scheduled trigger, then the action alone. It runs on the day of the send, in the time zone
of the action's settings, at a minute neither on the hour nor on the half hour in UTC, when many sites' rules run
at once, which in some time zones, such as Nepal's, are a quarter to and a quarter past: for one source,
once in the hour before the send, or twice on a morning when people at their tiles start large charts; for several
sources or a comparison, as many times as the estimate below gives; 15 minutes or more apart, the last in the hour
before the send and, where there are two or more, the first more than an hour before the last, such as 07:35 and
08:50 for a send at 09:00. Stintwise counts the hour whose half a chart's start can use up by the clock in UTC, so
in some time zones, such as India's or Nepal's, that hour begins at half past or a quarter to, and warm-ups more
than an hour apart fall in two such hours in every zone. A chart whose start the hour's half refuses waits until
that hour turns, at the time the run's
notenames, and another warm-up before then does not start it. - The sending rule: a Scheduled trigger at the time of the send; the action; an If condition that
readyis true, then the step that sends the summary; Else, Log action withnote, so the rule's audit log says why nothing was sent that day. Jira Automation's Comment on work item has Prevent duplicates by only adding this comment once to a particular work item ticked by default, which adds the comment only once to a work item, so untick it for a summary posted as a comment each time.
How many warm-up runs. Counted on the test site once, for six sources compared, whose twelve charts each charted 27 to 149 work items, in runs about a minute apart: four warm-ups, each starting three charts, each period before started after its source's chart, and the summary ready on the fifth run, as the estimate below gives. Every other figure here is an estimate: a run starts at most three charts, and none after one of more than 1,000 work items, each built before the next run 15 minutes later; the period before starts only beside a ready chart; and once the charts your site started this hour, at tiles and by rules together, have read about 6,000 work items between them, half your site's part of Jira's hourly limit, the rest wait for the next hour. So one source needs one warm-up and its comparison two, and several sources one for each source of more than 1,000 work items and one for every three others, rounded up, and their comparison twice as many; a comparison or several sources need at least one for every 1,500 work items their charts read, more in an hour when people at their tiles start charts: ten for one source of 7,000 compared, two for six sources of 400 work items, four for six of 400 compared, six for six of 1,200, twelve for six of 1,200 compared, fourteen for twenty of 400 compared, twenty-seven for twenty of 1,000 compared, thirty-four for twelve of 2,100 compared. Every warm-up falls after midnight in the settings' time zone, since one before it starts the charts of the day before: thirty-six fit before a send at 09:00, thirty-two on a day the clocks go forward an hour before the send. Settings whose estimate is larger, such as twenty sources of 1,200 compared, which need forty, may not be ready at that time: choose a later send, fewer sources, or Write a Stintwise summary, without the comparison.
Sending it. The names a summary states are written by other people, and a channel can read them as formatting. Send the output under which a name shows as typed:
- by email,
textin a plain-text email, ortextthroughhtmlEncode()in an HTML email; - to Microsoft Teams,
markdown, in which the app escapes the characters Teams reads as formatting; - anywhere else that shows Markdown,
markdown, and anywhere that shows plain text,text; - to Slack: not yet checked, so this page names no output for it;
- as a comment on a work item: not yet checked with a source whose name holds formatting, so this page names no output for it.
None of these has yet been sent from the test site, where a summary has so far been posted only as a comment on a
work item, from text.
What it costs your site. Every run of either rule counts as steps in your site's Automation usage, the warm-ups' included (how Atlassian counts them). A rule has 60 minutes of processing time per 12 hours (Atlassian's limits), and a run of the action ends within a minute. On a plan with Delay steps, a delay between two runs of the action in one rule can take the place of the warm-up rule for a small table, but the time a delay pauses counts toward those 60 minutes, so one long delay can spend them in a single run.
A wrong number. While a view a summary states is withdrawn for a wrong number
(what that means), every run of the action is not ready, and
its note says Stintwise has withdrawn this summary while a wrong number in it is fixed:
https://stintwise.adigium.com/status. A summary already sent cannot be recalled.
Why work items are excluded
Ten reasons, and the chart names whichever applies.
still open
Jira returned this work item because its history shows it entering one of your Done statuses during the window, but the history the app read has no completion among your Done statuses selection that is still in place: none by the rule for what counts as completed. Without one there is no end, so there is no cycle time. It is counted in the excluded total and nowhere else.
This should be rare, because work that has not finished is never returned in the first place — see the reconciliation line. If you see it, open the work item's History tab in Jira and compare the statuses it moved through with your Done statuses selection.
never entered a started status
The work item reached Done without ever being in a Started status — typically closed as a duplicate, or moved straight from the backlog. There is no start, so there is no cycle time. A work item created in a Started status is not one of these: its cycle time starts when it was created. The exception is a work item whose status history in Jira starts before its creation date: the app cannot tell when its work started, so unless it later moved into a Started status it is counted here. A work item whose status changes came from an import is measured from them, except in the one case described there. Lead time is usually still available for these. Of the reasons described above, three can leave it blank here: the work item's whole status history predates its creation, so its lead window is empty; the calendar you chose excluded every hour of that window, see how days are counted; or it was finished the moment it was created.
If you see many of these, your Started statuses selection is probably too narrow. Check the edit view against the statuses your team actually uses.
transitioned backwards after Done
The work item entered a Done status and then left it again, and has not re-entered one. Its end has been cleared, so it is treated as still in flight. When it is completed again it will appear in the chart with the later completion date.
transitions sharing a timestamp
Two or more status changes carry the identical timestamp, so the order of events is genuinely ambiguous and any cycle time computed from them would be a guess. This is almost always caused by an automation rule or a bulk edit moving items through several statuses at once.
The app refuses to guess. If this affects many work items, the automation is writing history that cannot be measured, and the fix is in the automation rule rather than here.
finished before they started
The end is earlier than the start. Jira's own history cannot cause it, because the app puts status changes in time order before measuring, imported or backdated ones included. It happens when one status is chosen both under Started statuses and under Done statuses in the settings. The settings do not let you choose a status in both lists, but a gadget saved with one before they refused it still charts, with these work items excluded rather than charted as a negative duration. Its settings name the status, and cannot be saved again until it is unticked from one of the two lists.
counted to zero
The work item has a valid start and end, but every hour between them was excluded by the calendar you chose — it was started and finished within a single weekend, inside a public holiday or a day the whole team is off, or outside your working hours, such as one evening. Its counted time is zero, which is not a meaningful point on a cycle-time chart.
Whichever calendar removed the time is the one to change, in Time counted: Weekdays counts the
evenings that Working hours on weekdays leaves out, Every hour counts weekends too, or clear the
holiday region or the day off. The exported CSV tells you which — the excluded_reason column on that work
item's segment rows names it: weekend, a holiday, a day off, or off-hours. A team that often starts and finishes
work out of hours, on call or through an automation that runs at night, charts fewer work items with
Working hours on weekdays than with Every hour: the count line, the percentiles, the Trend view's
bars and the Forecast's daily counts are of the work items charted, and the line under the chart
counts the rest here.
This cause means the calendar removed the time, and nothing else. The app measures each stretch between two status changes in whole seconds, rounded to the nearest, and the part of the stretch your calendar excludes the same way. So a work item whose every stretch from a Started status on to Done is under half a second — an automation rule that moves it through them in one run — is charted, at zero, in the first bucket, whatever your calendar excludes. Once any of those stretches comes to a second or more, the seconds your calendar counts are charted, and if it excludes them all, the work item is counted to zero here. One created and closed in one run without ever being in a Started status never started, and is counted under never entered a started status. It is a real measurement and hiding it would tell you nothing about work your team is actually doing that way.
incomplete history in Jira
Jira did not give the app this work item's complete change history, so its timeline cannot be reconstructed. That happens in these ways:
- The history is very long. Jira reported more change history than it returned.
- Jira refused the work item. When history is read one work item at a time, Jira can answer that a work item its search listed moments earlier is not found, or not open to the app. That usually means it was deleted, or hidden by issue security, while the chart was being built.
- The histories read with it ran past the most pages the app reads for one batch, so its latest changes were not read.
- Its first recorded status change does not say which status it came from, so the status it was created in is unknown.
The chart says so rather than charting a partial timeline as if it were whole.
Because the missing part may be exactly where the item finished, the app cannot tell whether it was last completed inside the range or after it. It counts the item here rather than guess; see the reconciliation line.
not read before the time limit
The app ran out of time before it could read this work item's history, so it knows nothing about when the work item started or finished. Jira withheld nothing. This happens only when history is read one work item at a time, or read again whole because it may have come from an import.
A build may read for at most ten minutes. Forge stops a build outright at fifteen, and a stopped build reports nothing at all, so the app stops first and reports what it has: the work items it read are treated as usual, and the ones it did not reach are listed here rather than left out. A note on the reconciliation line says so too. The app cannot tell when an unread item was last completed, so a few items listed here may have been completed again after the range; see the reconciliation line.
Each build sends at most ten requests a second, so ten minutes covers at most about 6,000 work items. Up to three builds run at once on a site, each at its own ten a second. It covers fewer when Jira answers slowly, when a work item's history needs more than one request, or when Jira asks the app to slow down: a request Jira refuses is retried after the pause Jira asks for, and the pause counts against the ten minutes. If Jira asks for a pause longer than the time left, the app does not wait; it stops there. When Jira says the app's hourly limit is used up, the build ends instead (why). At 0.3 seconds per request, ten minutes covers about 2,000. To get every work item charted, narrow the saved filter or shorten the date range so that fewer work items need reading.
the app is not allowed to read
Your search returned this work item, so you can open it, but Jira would not let the app read it. This arises only when Jira does not let the app act as you, so that the app reads your work items as itself: an organisation administrator can keep Marketplace apps away from some projects with an app access rule. The app knows nothing about it beyond its key, so it counts it here and lists it by key rather than leaving it out. To have it charted, ask an administrator whether an app access rule covers its project.
An app access rule can also hide work from the searches the app makes for you. When Jira says the site has content the app may not read, the chart says so on the reconciliation line: work in those projects may be missing from the chart without being counted anywhere.
over the 5,000 item cap
More than 5,000 work items in this filter completed in the range, or Jira's search for them returned more than 10,000. The app keeps the 5,000 with the most recent completion: those with no other reason to be excluded are charted, the rest keep their own reasons, and any further completions are counted here. A work item the app read that has no completion in the range, such as one reopened after finishing, or whose history Jira withheld, keeps its own reason and is never counted here. Search results past the 10,000 last updated are counted here without their histories being read, whatever they would have turned out to be; how many there are is Jira's estimate, so the chart says its counts can be too high or too low. Narrow the saved filter — by project, by date, or by team — to bring the whole set into range.
The work items over the cap are not kept, so this reason opens no list: on the reconciliation line it is a link to this section instead, and the CSV export has no rows for them. Only the ids of those the cap dropped past the 5,000 it keeps are kept, for the check, each time the chart is shown, that you can still open every work item it counts (see Who sees what); search results past the 10,000 last updated are not kept, so not even their ids are known when the chart is shown.
The completion date used here is the real one, read from each work item's history — not the date it was last edited. A ticket closed in March and re-labelled yesterday still counts as a March completion.
Because the cap keeps the most recent completions, it cuts the chart by date: nothing before the earliest completion charted is on it. The Trend view marks the periods it cuts, and compares the halves of the days it holds, not of the range (how).
One limit worth stating: this holds while Jira's search for work items in your filter that entered a Done status during the range returns up to 10,000. Beyond that, the app cannot read every work item's history within one build, so it falls back to Jira's own ordering — which is by last edit — to decide which 10,000 to examine. If your filter is that large, the honest advice is to narrow it; the chart will be both faster and exactly right.
Messages the app can show
That saved filter is not available
The saved filter was deleted, or it is no longer shared with you. Jira gives the app the same answer in both cases, so the app cannot tell you which one it is. Renaming a filter does not cause this. Open the gadget's own menu at the top right of the tile, choose Edit, and pick a filter you can open, or ask the filter's owner to share it with you.
On a tile of several saved filters side by side, one you cannot open has no row and no name: the line under the table says only how many of the tile's saved filters you cannot open, and the others are shown as usual. When you can open none of them, the tile says None of these saved filters is available: pick others in the settings, or ask their owners to share them.
That project is not available
The tile is built from a project that Jira's project search no longer lists to you: it was deleted or archived, or you cannot browse it in Jira. The app asks Jira, as you, for the projects you can browse, so a project you can only administer is answered the same way. Open the gadget's own menu at the top right of the tile, choose Edit, and pick another source, or ask a Jira administrator for access. On a tile of several sources side by side, a project you cannot open has no row and no name, as a saved filter you cannot open has none.
Jira does not accept this tile's JQL from you
The tile is built from a JQL query typed into its settings, and Jira's own strict check of the query, made as you, answered an error or a warning: the query names something Jira does not let you see, such as a project or a work item, or one that no longer exists. Nothing of the query is shown to you. Ask whoever set up the tile, or open the gadget's own menu at the top right of the tile, choose Edit, and pick another source. Someone Jira accepts the query from sees the chart as usual. The same answer comes when Jira accepted the query but then refused to run it for you. On a tile of several sources side by side, a query Jira does not accept from you has no row and no name.
This tile's JQL can no longer be read
The settings hold a JQL query sealed with a key only the app holds, kept in the app's own storage for as long as it is installed, and sealed for the site it was typed on. This answer means the app cannot open it here: the app was reinstalled since the query was saved, and a reinstalled app is a new installation with a new key, or the settings were copied from another site. Nothing is read from Jira for it. Open the settings, where the query is listed as A JQL query you cannot open: remove it with ✕ and type the query again. Atlassian relinks a reinstalled app to its old data only when asked within 21 days of the uninstall, as its data lifecycle page says, and that request is the site administrator's to make.
Jira rejected the filter query
The saved filter contains JQL that Jira will not run for you — usually a field or a project that
has since been removed, one you cannot see, or another saved filter it refers to that you cannot
open. Open the filter in Jira and fix the query there; the next view then builds the chart from the
fixed query straight away. Until it is fixed, each view runs the search again and shows this
message again. This app cannot edit filters. It does add
conditions of its own when it runs the filter for you: the Done statuses chosen in this gadget and
the date range, as filter = <id> AND (status CHANGED TO (<Done statuses>) DURING (<range>) OR (status in (<Done statuses>) AND created >= <start> AND created < <end>) OR (status in (<Done statuses>) AND resolved >= <start> AND resolved < <end>)).
For the Aging view it runs the filter a second time with the Started and Done statuses, as
filter = <id> AND status not in (<Done statuses>) AND (status in (<Started statuses>) OR status CHANGED FROM (<Started statuses>) OR status CHANGED TO (<Started statuses>)) ORDER BY created ASC;
when Jira rejects only that search, the chart is built without the work in progress, and the Aging
view says so (why).
Who sees what
A chart is built from one person's search: the work items its source, a saved filter, a project or a JQL
query, returns for them in Jira, searched as them, and from nothing else: the app then reads, as them, or as
itself when Jira does not let it act as them, the status histories of exactly those work items. So it lists
only work items they could open when it was built. Another person is shown it only when Jira, asked as them a
moment before, confirms that the same searches return them exactly the same work items, that they can open
every one, and that its issue types, sprints and teams read to them as the chart states them; otherwise a chart
is built from their own search, so colleagues who can open different work items each see a chart of their own,
and their numbers differ where their access does. Whoever can edit the saved filter or the dashboard is always
shown a chart of their own search, and their chart is shown to nobody else; so is everyone, when the saved
filter or the query names another saved filter or uses a function an app adds to Jira. Once you are shown a
chart, it is the one you are shown that day, and every figure in it is as of when it was built, which the chart
shows. A chart that includes today is built when its viewer ticks the box, to that quarter
hour, and is shared only as every chart is. The ages in the Aging view are measured when each chart is
built, or, with Measure ages when this view opens, when each person's view opens, so two people's
charts show one work item at ages that differ by the time between their measurements. A filter or a query that
uses currentUser(), lastViewed or another part of JQL that Jira answers differently for each person means,
for each person, what it means to them in Jira, so each is shown a chart of their own. What a chart shared this
way can tell you about someone else's search is on the
privacy page.
Before anything of a chart is shown, the app checks, as you, that you can open its source: a saved filter as Jira lets you open it, a project as Jira's project search lists it to you to browse, and a JQL query as Jira's strict check accepts it from you, with no error and no warning, which it does not when the query names a project or work item you cannot see. That check does not look at the people a query names, its labels, its text searches or what it passes to a function: those words are shown to everyone Jira accepts the query from. A query is the words of whoever set up the tile, and can name people as JQL can.
On a tile of several sources side by side, each source's row is built and shown the same way, and only for a source you can open; the line under the table counts, by kind, those you cannot open.
Before your chart, a drill panel or an export is shown, Jira is asked, as you, how many of the chart's own work items, named by their ids, you can open. If you have lost access to any since it was built, it is built again from a fresh search of yours. Each row of saved filters side by side is checked the same way before its figures are shown. Jira describes these counts as estimates that may miss the latest changes, so access lost a moment ago can be noticed late; an answer that lets you see the chart is reused for up to five minutes.
Jira refused access
Jira answered that a request was not allowed (HTTP 401 or 403). The one cause Jira's documentation gives for that answer is credentials that were missing or not accepted. When Jira refused the build itself, the first view of the dashboard at least ten minutes after the failure builds the chart again, and refreshing sooner shows this message again; when it refused the check made as you, a refresh asks again straight away. If it keeps happening, ask a Jira administrator to check that the app is still installed and allowed to read the site.
A filter you cannot open gives a different message. Before any chart is shown, the app checks, as you, that you can open the saved filter the chart is built from. When Jira says you cannot, you see That saved filter is not available, and no chart.
You are shown a chart built from your own search, or one Jira confirms, as you, holds exactly what your search returns. See Who sees what, and, in full, Who can see a chart.
Reading the change history
The first view of the day builds a chart, unless one built from the same search is already there. The build asks Jira, as you, for the work items your saved filter returns for you that entered one of your Done statuses during the range, or were created or resolved during it and are in one of them now, and, in a second search, for those in progress, and, when the range runs to that day, in a third, for those that finished after it ended, each with its creation date, status, issue type, sprints, parent, labels, components and team; it then reads, as you, their status histories, up to three blocks of 1,000 at once, in that order: the finished work's first, then the work in progress, then the work finished after the range. When the app reads them as you, it reads the second search beside the first, and a first search of more than 200 work items, and up to 18,000, from its oldest and its newest work items at once. When Jira does not let the app act as you, your view runs those searches as you instead, and the app reads the rest as itself. The counter shows how many histories it has read out of how many it will read: at first out of how many Jira expects, then out of how many its search found, which is at most 13,000: 10,000 finished, 2,000 in progress and 1,000 finished after the range (see over the 5,000 item cap). It moves once per 1,000 work items, so a smaller filter shows 0 until it is done. The bar above it fills to the whole percent read, rounded down, so it never shows more read than has been. A work item two of the searches return, such as one finished in the range and reopened since, counts in each, and its history is read once, unless that read was cut short or the site's status list was read again in between.
A chart built again within 97 hours of an earlier build of the same settings, such as the next quarter hour of a chart that includes today, a colleague's next chart of the day, the next morning's first or the first after a weekend, starts from what that build's searches returned. It asks Jira, as you, how many work items each search returns that were updated since about an hour before that build, and then only for those; it checks with counts, as you, that each block of up to 1,000 earlier work items is still returned by your search, and with searches, as you, that no work item joined it without being updated, and searches a block again where a count falls short; and it reads again one work item for each project, status, issue type, sprint, parent, component and team, because their keys, names and sprints' dates can change without the work item being updated. A search these checks cannot settle, such as one where more than half the work items changed or a sprint closed since, is read in full, as above. So is one whose checks would use more of Jira's hourly points than reading it again, at a point for each search and for each work item it returns and two for each count, such as a search of seven work items or fewer; one whose changes, once counted, would take its checks past that; and one whose checks would ask Jira more than 100 times, such as one spread over 50 projects or more. Once the checks have taken a minute, every search is read in full. The search of work that finished after the range is checked after the work in progress has been read, and runs to that moment. Every status history is read again. The chart is the one a full search would build at that moment.
A chart is built at the first view each day, unless one built from the same search is already there, on the first view after an app update that changes how charts are built or stored, and on the first view after the filter's query changes; and again, to the quarter hour, when a viewer ticks Include today, at most once a quarter hour. The ages of a viewer's work in progress are measured on their own, at most once a quarter hour, when their Aging view opens with Measure ages when this view opens ticked: a build that reads the work in progress alone, whose counter counts those histories. Builds on one site run three at a time, so at a busy moment yours may wait its turn; the tile waits with it. When Jira says little of the app's hourly limit is left, or your site's new charts have used their part of it, a chart not yet built waits until the hour turns, and the tile says until when (why). A tile of several saved filters side by side builds each one's chart as a tile of that filter alone would, three of its rows at a time, or one at a time while one holds more than 1,000 work items, and, when you have it compare them with the period before, each one's period before after them, the same way. Each row says how far its own build has got.
While a colleague's chart of the same settings is being built, and it may turn out to hold exactly what your search returns, the tile says only This chart is being built., with no count and a bar with no value, since the count would be of their search. It asks again within half a minute, then checks, as you, whether your search returns exactly that chart's work items, and builds a chart from your own search when it does not, or when it has waited five minutes. A row of saved filters side by side waiting so says Waiting its turn, with no count, and is asked after with the tile's other rows.
How long it takes depends on how many work items match, and on whether Jira lets the app read their histories in bulk; see read one work item at a time. If the build has been running for five minutes without finishing, the tile says so.
This is taking longer than expected
The first build for a configuration reads the full change history of every matching work item, and that did not finish within five minutes. Refresh the dashboard to try again. If it recurs, the filter is probably very large — narrowing it is the reliable fix.
Jira is rate limiting or unavailable
Jira kept turning the app's requests away, asked it to pause for longer than a chart build may run, or the app is keeping the rest of Jira's hourly limit for charts already built and for the other sites with the app. There are three usual reasons:
- Jira's quota for this app is used up. Atlassian limits how much each app may ask of Jira in an hour, and by default that limit belongs to the app as a whole: one quota, shared by every Jira site that has the app installed. A busy hour elsewhere can use up what your chart needed. The quota resets at the top of each hour (UTC). When Jira answers that the app's hourly limit is used up, the tile says until when, and the app asks Jira nothing more for your site until the limit resets; each tile then asks again within five minutes, at a moment of its own, so that every site does not ask at once.
- Nearly used up, or used by your site's new charts. So that the last of the hour serves charts already built, the app starts no new chart on any site once Jira says less than a tenth of the app's hourly limit is left. And so that one busy site does not use up every site's hour, a site whose new charts have used a fifth of it, as the app counts it from what Jira's searches returned, starts no new chart until the hour turns; once what its new charts have used and what those still being built are expected to use come to that fifth, its next ones wait their turn while they are built. Charts already built, their lists and their exports are served as usual; a tile of several sources gives its answer, its file, image and summary, and its period befores and four quarters once every row is built. The tile says until when, and asks again by itself.
- Your Jira site is briefly unavailable. That usually clears within minutes.
Each of them is temporary. Try again later.
While a chart is being built, a retry waits at least as long as Jira's Retry-After header asks,
and longer when the app's own spacing between attempts — two seconds, doubling each time, give or
take a little — is longer. The one exception is a wait longer than the time the build has left:
Forge stops a build after fifteen minutes and records nothing when it does, so the app does not
start such a wait. When
history is read one work item at a time, the read stops there and lists what it did
not reach as not read before the time limit. The check whether Jira keeps content
from the app is skipped instead, and the chart then says nothing about it. Any other read ends the
build with this message. Jira's answer that the app's hourly limit is used up is not waited for: the
build ends with this message at once, and the chart is built at the first view after the limit resets.
Retries on the read that checks you can open the saved filter are shorter, because a request from the tile has only seconds to answer. If they still fail, the tile shows this message and asks again when you refresh the dashboard, or, when Jira said the app's hourly limit is used up, by itself once the limit resets, as above.
History was read one work item at a time
Some Jira instances do not allow the bulk change-history endpoint. When that happens the app falls back to reading each work item's history individually. Every history it reads is read in full, so for those work items the numbers are exactly the same — the build just takes longer.
Reading one at a time is slow enough that a large filter may not finish within the build's time limit. Any work item the app did not reach is excluded and listed on the reconciliation line as not read before the time limit, and a note on the reconciliation line then says how many, in place of "The numbers are unaffected". When that note does not appear, nothing was missed.
"In full" is meant literally: the per-item endpoint cannot be asked for status changes only, so Jira sends every change to every field. The app keeps the status changes and discards the rest in memory. Nothing extra is stored — see the privacy page.
This is different from incomplete history, which is reported separately and lists the affected work items with a reason. See work items with incomplete history.
History that came from an import
Jira's JSON importer keeps the status changes it imports without the field id that Jira's bulk history read filters on, so a read that asks for status changes only leaves them out. Other imports and migrations may do the same; that is not known. So the app reads a work item's whole change history, every field's changes, when either of these is true:
- the app's first read found no status change for it;
- the first status change that read found comes from one of your Started or Done statuses, or from a status outside your site's To Do category, or does not say which status it came from.
When one of those whole histories holds a status change without the field id, the app reads the whole history of every work item of the chart, before it measures any of them. Every status change Jira holds for a work item then counts, with or without the field id, and the work item is measured from its history as its History tab shows it.
One case the app cannot see: on a chart where none of those whole histories holds such a change, take a work item whose imported history started it and then moved it back to a To Do status. If it was started again in Jira, it is measured from that later start; if it went to Done without being started again, it is counted under never entered a started status. Its History tab shows the earlier start. Ages measured when the Aging view opens decide this from the work in progress alone, so such a work item can show a different age there than on the chart's own Aging view.
Whole histories take longer to read, and Jira sends every field's changes with them, which the app discards as it reads them (privacy). When the build runs out of time during such a read, the work items it did not finish are listed under not read before the time limit.
Jira's own search does not see status changes that came from an import (checked 7 October 2026). So a chart also asks Jira for the work items in one of your Done statuses whose resolution date falls in the range, a date Jira's JSON importer keeps when the import gives one. A work item whose move into Done came from an import is still not found when it is not in a Done status now, whatever its creation or resolution date, or when it was created before the range and its resolution date is not in it, and is then in neither count of the reconciliation line. Nor does the Aging view find a work item whose moves into and out of your Started statuses all came from an import, unless it is in one of them now, and a work item whose move into Done after the chart's range came from an import is not read as work that finished after it.
The counts are estimates
When your search returns more than 10,000 work items, the app keeps the 10,000 most recently edited and counts the rest over the 5,000 item cap by Jira's estimate for you, without reading their histories. A note on the reconciliation line says so. Those unread work items are counted whatever they would have turned out to be, some may have been reopened or still be open, and the number is Jira's estimate, so the number over the cap and the number excluded can be too high or too low. The number charted, and the numbers never entered a started status, transitions sharing a timestamp, finished before they started and counted to zero, can be wrong either way too: the 5,000 work items the app keeps are chosen from the 10,000 it kept, so a complete read could have kept others. The numbers still open, transitioned backwards after Done, incomplete history, not read before the time limit and not allowed to read can only be too low: those work items never compete for the 5,000 places, so their counts only miss what was not read.
Narrow the saved filter — by project, by date, or by team — until the note disappears. The counts are then exact.
The chart was redrawn
When you click a bar, a dot or an exclusion reason, or export, the app reads the list from the stored copy of the chart the tile is showing. That copy can be replaced while the tile is open: a chart is built afresh on the first view each day, on the first view after an app update that changes how charts are built or stored, and when the filter's query changes; a stored chart the app finds damaged is dropped and built again, and so is one listing a work item you can no longer open. The list would then belong to a different chart from the number you clicked, so the app draws the tile again from the current copy and says which of two things happened:
- The chart was rebuilt and what it shows has changed, so it has been redrawn. The new copy shows different numbers or settings. Most often a range that runs to yesterday has moved: it ends at the start of the day the chart is built, so a chart rebuilt a day later covers a range a day later, and work items that finished at its far edge drop out even when nothing in Jira changed. A range whose days no longer move, a last full quarter or custom dates in the past, covers the same days, read from Jira again. The work items in Jira may also have changed, or an app update may have changed how charts are built. Read the new chart and click again.
- The stored copy of this chart was rebuilt. The numbers did not change; click again. No number on the tile changed, so the same click now opens the list; the scatter's dates may have moved on with the range.
If the new copy is still being built, the tile shows its progress first. A chart that includes today is a day old after midnight, so a click on it then draws the tile again with the chart of the days before today, and the box unticked.
A request did not complete
Seven messages mean one request from the tile or the settings did not complete:
- This part of the tile could not be loaded. The settings and the Image or summary panel load the first time they open, and that load did not complete. Press Try again.
- The target could not be loaded. Show a target's field loads the first time the box is ticked, and that load did not complete; the chart is drawn without a target meanwhile. Press Try again.
- The export failed. No file was saved.
- The next page could not be loaded. The rows already in the panel are unaffected.
- Your settings could not be saved. The gadget keeps the settings it had.
- Filter search failed. The list of filters could not be fetched.
- This gadget could not load its settings. Jira did not return your site's statuses, or, for a gadget not configured yet, your time zone. The gadget keeps the settings it had; press Cancel and open the settings again.
Usually the connection dropped, or Jira or Forge did not answer in time. Nothing already on screen is affected: do what the message says and try again. If the same request keeps failing after you reload the dashboard, it is a bug worth reporting: write to stintwise@adigium.com with the saved filter the gadget points at, which is the one detail that identifies it, and the time you saw it (what else helps).
Jira did not answer the search for work in progress
The Aging view says this when the chart was built without its work in progress: Jira turned the search for work in progress away, or the app's reads of the work items it found failed, or did not finish in the time a build has. The other views are built from the finished work as usual, and their numbers are unaffected. The Aging view is tried again when the chart is next built: at the first view each day, and when the filter's query or the gadget's settings change.
When Jira was only rate limiting the search, or was briefly unavailable, or said the app's hourly limit is used up while the app read the work items it found, the chart is not built without the work in progress. The tile shows Jira is rate limiting or unavailable instead, and asks again when you refresh the dashboard, or, when Jira said the app's hourly limit is used up, by itself once the limit resets.
This app is not licensed
The trial has ended or the subscription has lapsed. Start a trial or subscribe from the Atlassian Marketplace listing; the chart returns immediately afterwards, and no configuration is lost.
Something went wrong
The app hit an error that no message above describes, or it could not read its own stored data.
- If a build failed, refreshing straight away shows this message again. The app waits about ten minutes before building the same settings again, so that a failing configuration is not rebuilt on every view. Refresh after that.
- If stored data could not be read, a refresh a minute later is enough. Forge limits how much an app may read from its storage each minute.
Stored charts belong to you, the gadget's settings, the filter's query and the day, and a chart that includes today to its quarter hour too, not to the gadget; a chart shown to more than one person belongs to its dashboard and its gadget as well. Removing the gadget and adding it again with the same settings on the same day brings back the same stored result, including a failure. Changing any setting, or the filter's query, starts a fresh build straight away, and an app update that changes how charts are built or stored starts one on the next view. Otherwise a chart is built afresh at the first view each day, unless one built from the same search is already there, and a stored chart the app finds damaged is dropped the next time it is read, so the view after that builds it again.
If it keeps happening after all that, it is a bug worth reporting: write to stintwise@adigium.com with the saved filter the gadget points at, which is the one detail that identifies it, and the time you saw it (what else helps).
Configuration
Six controls, and there will never be a seventh — every additional setting is another way to get a number you cannot explain. The team's days off are part of Public holidays, under its select, not a seventh control.
Saved filters, projects or JQL. One list of up to 20 sources, each a saved filter, a project or a JQL query. Type in Add a saved filter or project, or type JQL: the box lists the saved filters you can see whose names contain what you type, and the projects you can browse whose name or key holds it, each marked Project. Pick one from the list under the box: it goes to the end of the sources above the box, each marked Filter, Project or JQL, and the box empties. With something typed, Enter adds the one source listed whose name is exactly that, or else moves to the first one listed; it never saves the settings. One source is a chart of it. Two to 20 are shown side by side, one row each, in the order of the list, all on the Started and Done statuses, Date range and calendar below. ↑ moves a source up the list and ✕ removes it. A source can be in the list once, and the list holds at most 20; settings that list one twice, or more than 20, say so and cannot be saved until one is removed. A team's filter can be its board's filter, or one that picks out a component, a label or the Team field. A company-managed board's own filter is the one its Configure board page names under Saved Filter: the chart is what that filter returns, without the sub-filter a Kanban board can add to hide released work. A team-managed board has no saved filter; its project can be picked instead, though a board can show less than its project holds. With several sources, include each team's started statuses among the Started statuses: a work item that never enters one is excluded, and its row says so. Each source is a chart of its own, built at the first view each day, so that first view waits for all of them (building).
A JQL query is typed into the same box. Text that holds =, !=, ~, < or >, or the words in (
or in and a function, is empty, is null, was, changed or order by, is read as JQL and searched as
nothing else, so a saved filter whose name holds one is found by typing a part of its name without it. Jira checks the query as you, strictly:
when it answers no error and no warning, Use this JQL offers it, with the query under it, and pressing it, or
Enter, adds it; otherwise the settings quote Jira's first error or warning, which only you see. A query is the
condition of a search: an ORDER BY is left out, since the chart orders work items itself, its brackets and
quotation marks must close, and it can hold at most 1,000 bytes, about 1,000 letters of English and fewer in
other scripts. A JQL query is kept unreadable in the dashboard's settings and shown only to people Jira lets run
it; a saved filter remains the way to share a query with its own owner and permissions. Jira's check refuses a
query that names a project or work item you cannot see, but does not look at the people it names, its labels, its
text searches or what it passes to a function, so those words are shown to everyone Jira accepts the query from
(who sees what). The settings hold the query sealed with a key only the app holds, so
reinstalling the app makes it unreadable (why).
When you open the settings of a tile with sources chosen, the app reads, as you, the names of those you can open, and Jira's check of each JQL query among them, and nothing else about them; one you cannot open is listed as A saved filter you cannot open, A project you cannot open or A JQL query you cannot open, never by its name or its text, and ✕ removes it like any other. The box then searches only for what you type in it, never for an empty box, so opening those settings reads no list of saved filters or projects; it lists the saved filters and projects you can see on opening only while none is chosen. No source's name and no query's text is saved with the settings: they hold a saved filter or a project by its id and a query sealed, the tile reads each one's name as each person who sees it, and names it only to someone who can open it. Settings saved before the update of 8 October 2026 also hold the first one's name until they are next saved.
When no saved filter you can see has a name containing what you type, and no project you can browse has it in its name or key, the settings say so: save the search as a filter in Jira first, or ask the filter's owner to share it with you.
Started statuses and Done statuses. Preselected from Jira's own status categories, which is right for most teams. Change them if your workflow does something more specific. A long list scrolls, and says so under it. The Started statuses are also the ones By status counts as working time (flow efficiency). A status is matched by its id, not its name, so renaming it in Jira changes nothing on the chart's numbers; each is shown under the name Jira gave it when the app last read the site's status list, at most an hour before the chart was built. A status added later under a chosen name, such as a new project's own Done, counts in every chart built once work has moved into or out of it: a build that meets a status the app's copy of the list does not hold reads the list again. A status renamed to a name you chose counts in the next chart built once work has moved into or out of it since the rename, or once a work item the chart reads is in it, and otherwise in charts built from an hour after the rename. A chart built before keeps its numbers for the rest of its day.
A status is one or the other, never both: once it is ticked in one list, the other list shows it greyed out and marked chosen as started or chosen as done until it is unticked where it is ticked. Settings saved with a status in both lists say so, and cannot be saved until it is unticked from one of them; finished before they started says what it does to the chart. A saved status the site no longer has is named under its list but has no box, so it cannot be unticked, and it does not hold the settings back.
Date range. Filters on completion date, not creation date. A work item completed inside the range is charted however long ago it started. Every range but Last closed sprint is whole days in the gadget's time zone; a sprint's chart runs from the instant it started to the instant it closed, as Jira holds them. Under the select the settings say which days your choice covers today, before you save it. The select offers four kinds:
- Days before today: the last 30, 90, 180 or 365 days, which move on a day each day. On 30 September 2026 the last 90 days are 2 July to 29 September.
- Calendar periods: Last full month and Last full quarter, the last whole calendar month or quarter, which move on when the next one ends: on 30 September 2026 the last full quarter is April to June, and July to September becomes it on 1 October. This quarter so far runs from the quarter's first day.
- Sprints: Last closed sprint, the sprint that closed last before today, of the sprints this saved filter's work was in, found among the work it finished in the 90 days before today and its work in progress. It moves on the day after the next sprint closes, and the tile names it. It charts one saved filter: the settings will not save it beside others. Where there is no sprint to chart, the tile says why in the chart's place: no Sprint field found, no closed sprint, a last closed sprint that started more than 90 days before today, more than 10,000 work items finished in those 90 days, or sprints Jira returned in a form the app does not read (how).
- Custom dates: a first and a last day, both included, from 1 to 366 days, each between 1 January 2015 and 31 December 2032, the years the holiday tables cover. A first day in the future is allowed. Move both dates on by 14 days moves both on by the range's own length, as from one sprint to the next of the same length.
A day is charted once it has ended. A range that runs into today, This quarter so far or custom dates whose last day is today or later, is charted to the end of yesterday, and the footer says so, as in Custom dates, 17–30 Sep 2026, charted to 29 Sep 2026. So today's completions are charted from tomorrow, and a chart does not change during the day, unless you include today on the tile. A range with no day before today, This quarter so far on a quarter's first day or custom dates starting today or later, has nothing to chart yet: the tile says No complete day in this range yet and on which day its first chart is built, and nothing is read from Jira for it until then.
The footer under the chart names the range and states its days, as in Last 365 days, 30 Sep 2025 – 29 Sep 2026 on a chart built on 30 September 2026, or Last full quarter, Q2 2026, 1 Apr – 30 Jun 2026; Time zone, build time and method, at the end of that line, shows the chart's time zone and when the chart was built in it, as in Europe/Belgrade · built 30 Sep 2026 00:05, and how its figures are worked out. A calendar period or custom dates also lead the headline, as in In Q2 2026, 85% of charted work items finished within … or From 14 to 27 Sep 2026, …, so a screenshot still says what it is about a day later. A chart is built afresh each day whatever its range, so a range whose days no longer move, a last full quarter or custom dates in the past, is read from Jira again at your first view each day: a work item reopened and finished again since then moves into the period it last finished in. To keep a period's figures as they stood when it closed, export its ledger then.
Sprints. Last closed sprint charts the sprint that closed last, and the ledger export names the
sprint each finished work item counts in (how). For a sprint further back, set custom dates
to its first and last day; Move both dates on reaches the next one of the same length, and compared
with the period before it is set beside the same days of the sprint before, for sprints of
one length back to back. A saved filter whose JQL names a sprint, such as
sprint in openSprints(), charts only that sprint's work; Jira answers that clause for the sprints
open when your chart is built. A short sprint can have fewer than 20 charted work items, so the
comparison then states the figure before it without a verdict.
So a filter can match hundreds of work items and still chart nothing: if none of them completed inside the selected range, there is nothing to measure. That is not an exclusion — those work items were never candidates — and the tile says so rather than listing causes it does not have. A longer range, or a filter that covers finished work, is the usual fix.
Time counted. Which hours of the week count, one choice of four. A new tile's settings ask, with none chosen, and save once you choose, so nothing is quietly removed from the first chart you see and nothing is quietly counted in it: until then the field says Choose which time is counted, then save. Settings saved before this was asked keep the choice they were saved with, and a configuration that leaves the choice out is charted with every hour counted.
- Every hour: nights and weekends included. A day on the chart is 24 hours.
- Weekdays: Saturdays and Sundays are not counted. A day on the chart is 24 counted hours.
- Working hours on weekdays: only the time from From to To on Monday to Friday counts, and a day on the chart is one working day, as many hours as it holds: 8 for 09:00 to 17:00 (one day). Choosing it fills in 09:00 and 17:00, which you change before saving.
- Working hours that differ by weekday: Monday to Friday each count only the time from their own From to To, and a day on the chart is the average working day, a fifth of the week's working hours: 7.2 for Monday to Thursday 09:00 to 17:00 and Friday 09:00 to 13:00 (one day). Choosing it fills each weekday with the third choice's times, or 09:00 and 17:00. Every weekday works at least an hour; Saturday and Sunday never count.
The working day is one stretch, the same on every working day: both times on the hour or the half hour, from 00:00 to 23:30, at least an hour apart and on the same day, so a lunch break inside it counts and no shift runs past midnight. With the fourth choice each weekday's working day is such a stretch of its own. The times are in the gadget's time zone, which the settings name under the field: someone in another zone who changes the settings types the hours in that zone, not their own. A work item started and finished outside the hours, such as an evening fix, is counted to zero and not charted. Times that cannot be saved say why under the field: Choose when the working day starts and ends., Choose times on the hour or the half hour, such as 08:30., or The working day must end at least an hour after it starts, on the same day. With the fourth choice they name the first weekday refused: Choose when Friday's working day starts and ends., Choose Friday's times on the hour or the half hour, such as 08:30., or Friday's working day must end at least an hour after it starts, on the same day.
Public holidays. Available with Weekdays, Working hours on weekdays or Working hours that differ
by weekday, because a holiday is a
kind of non-working day; excluding holidays while counting Saturdays produces a number nobody can
explain. Twenty countries and 219 of their states and regions are available, covering 2015 to 2032. A
state's or region's list is the public holidays the open-source date-holidays library lists for it,
which can differ from local law; one whose list is its country's is not offered. A few of its country's
holidays that the library leaves out of a region's list are kept there as the country's: in a Swiss
canton, a day the library marks only as optional or as a bank holiday, such as Easter Monday in Lucerne
and St Stephen's Day in Geneva, since most people there are off, which gives Grisons Switzerland's list,
so choose Switzerland there; in Amazonas, Mato Grosso, Rio de Janeiro and São Paulo, 20 November from
2024, Brazil's national holiday since; and in Tasmania, New Year's Day on the Monday after a Sunday, and
Easter Sunday from 2027. Where a list differs from the law, as far as known: the United States' list,
and so each state's, has Veterans Day only on 11 November, never on the Friday before or the Monday
after that federal law observes when it falls on a weekend, as on Friday 10 November 2023; Washington's,
Oregon's and South Carolina's lists keep Columbus Day, which is not a holiday in any of them;
Washington's misses the Friday after Thanksgiving, Native American Heritage Day there; South Carolina's
keeps Juneteenth, there only a day of observance, and misses that Friday, 24 December, except in a year
when it is Christmas Day's substitute, and the weekday to which its law moves a holiday falling on a
weekend, such as Friday 9 May 2025 for Confederate Memorial Day; Ontario's adds Easter Monday, not a
holiday there, and the Northwest Territories' adds Easter Monday and Boxing Day, neither a holiday
there; the lists of British Columbia, Manitoba, Prince Edward Island, the Northwest Territories and
Nunavut miss 30 September, the National Day for Truth and Reconciliation, now a holiday in each, and
Nunavut's misses Nunavut Day, 9 July. The drill panel and the CSV export name each holiday that removed
time from a work item, as holiday:DE-BY:Fronleichnam (the CSV format), so a day a list
misses is one they never name. Each is listed under its country, after the country's own list, by its
own name first, as Bayern, Germany after Germany: national holidays only, so typing its name finds
it (type the comma after Sachsen, Tasman or Mato Grosso, which begin other names), and the chart
names it after its country, as Germany (Bayern). Part-day holidays, such as Christmas Eve evening in
South Australia, are not removed.
A list for each source. On a tile of 2 to 20 sources side by side, with any choice but Every hour, Public holidays offers The same for every saved filter and Each saved filter's own (source in place of saved filter where a project or a JQL query is among them). With the second, each source has a select of its own, named for it, in the order the sources are listed; a source added starts on the list chosen above, one moved keeps its own and one removed takes its list with it. Each row is counted in its list's time zone: a state's or region's, its main one where it spans several, as America/Chicago for Texas; a country's where it has one, as Asia/Tokyo for Japan; otherwise the gadget's, as for the United States' national holidays only or None. Each choice that sets a zone names it, as Texas, United States (America/Chicago) or Japan (Asia/Tokyo), and the rows' hint says so. Everyone who can see the gadget is sent each source's holiday list with its settings, also for a source they cannot open; on a source of one person's work, it says where that person works. Down to one source, the list chosen above takes the remaining source's, and if that source was counted in a zone of its own the settings say so until they are saved: a tile of one source is counted in the gadget's zone (saved filters side by side).
Days the whole team is off. Under the Public holidays select, with any choice but Every hour: the days your
whole team does not work, one date per line, such as 2026-12-24, or separated by commas or spaces. Each is a
weekday from 2015 to 2032, at most 60 of them; a day listed twice is kept once, and they are saved in date order.
Each is left out of every chart of the gadget whole, like a public holiday, on every row of sources side by side
too, whether a holiday list is chosen or not; a day that is also a public holiday of the list is left out once, as
that holiday. The chart says team days off not counted, never how many, and the drill panel and the CSV export
name each listed day that removed time, as team day off 24 Dec 2026 and team-day-off:2026-12-24
(the CSV format). Everyone who can see the gadget is sent these dates with its settings
(privacy), so list only days your whole team does not work, never one
person's leave. A list that cannot be saved says why under the field, naming the first day refused: Write each
day as a date, such as 2026-12-24: “24.12.2026” is not one., 2014-12-31 is outside 2015 to 2032, the years the
holiday lists cover., 2026-12-26 is a Saturday, and weekends are already left out., or List at most 60 days;
this lists 61.
More saved filters match than are listed
The list under the filter box holds the 50 saved filters you can see whose names contain what you typed, the most favourited first. When more than 50 match, the app also looks for a filter named exactly what you typed, among the first 250 whose names contain it, and lists it first. If that lookup did not read every one of them, or failed, the note says a filter of that exact name may not be among those listed. Type more of the name to narrow the list.
Time zone
The time zone is frozen when the gadget is configured, taken from the person configuring it. It decides where each day begins, and, unless a source side by side is counted in its holiday list's own time zone, where its weekends, holidays and working hours fall. Where each day begins decides the range, which is the same for every viewer wherever they are. The tile names it under Time zone, build time and method, at the end of its footer's first line, with when the chart was built; every image and summary of the chart names it too.
Sample data
Stintwise's sample data is made-up work items. No real team's work is in them. The try page shows them. The listing's images and its sample export are drawn from them. A program makes them from a fixed starting number, so they are the same every time: six teams: Checkout, Mobile and Platform, starting about 8, 5 and 10 work items a week, and three smaller ones, Payments, Search and Data, at about 4, 3 and 2; stories, bugs and tasks, each with its own typical cycle time; a waiting status, Ready for Review, between work and review, which the sample's charts do not count as Started; two-week sprints for Checkout, Mobile and Platform; epics, labels, components and five teams that cut across the projects; a few work items of five of the kinds the chart leaves out (never started, reopened after Done, two changes in one instant, a weekend's work with weekends not counted, and history that starts part-way, for work that was in flight when the teams moved to the site on 1 April 2024 and for one Task of each team each half-year that arrived moved from another project); and work still in progress. Checkout's 365 days to 30 September 2026, weekends not counted, draw a cycle-time histogram of 2-day bars: the longest cycle time among them is under 48 days; their lead time draws 5-day bars, and 85% of it is within 32 days. Still open does not appear in the sample's charts: a work item reopened inside a chart's range and finished again after it is not in that chart at all, as on any site (the reconciliation line). The other four kinds cannot be carried by work items: they come from how a site or a chart is set up, or how a chart is read. Everything is in UTC, and nothing happens after 14:30 UTC on 1 October 2026.
Privacy
The app stores no summary, description, comment, attachment or custom field value but a sprint's id, board, state and dates and the name of the team in Jira's Team field, and no account id; a work item's labels, its components' names and its team's name, which the CSV export writes, are the only words of a work item it keeps. It reads status change history to compute durations, builds a chart once a day for each group of viewers whose searches return the same work items, and again when someone asks the tile to include today, at most once a quarter hour, and can no longer read a chart 73 hours after its build, at the latest. A chart built from your search that only you are shown, and which chart you were shown, are marked by a key made from your account with a secret the app keeps, which cannot be turned back into your account without it; the key goes when the chart does. It never asks Jira for descriptions, comments or assignees, and asks for summaries only of the parents you can open, as you, when you split a chart by parent; a test on every outgoing request enforces both, and it stores none of them. Jira does attach the identity of whoever made each change to every history record, and when history is read one work item at a time, or read again whole, it sends the whole history. It also sends the saved filter's owner and sharing with the filter, and the configuring person's whole profile with their time zone. The app keeps what it needs and discards the rest in memory as the response is read. The full list is on the privacy page.
Who can see a chart. A chart is built for one person, from the work items the saved filter returns for them in Jira, searched as them by the app acting as them, and is shown to someone else only when Jira confirms, as them, that their own searches return exactly its work items. The app reads, as them, or as itself when Jira does not let it act as them, the key, creation date, issue type, current status, sprints, parent, labels, components, team and status history of exactly those work items (on a chart of the last closed sprint, the status history of the sprint's work only), and asks Jira nothing else about them; when history is read one work item at a time, or read again whole, Jira sends each one's whole change history and the app keeps only the status changes. Before a chart, a drill panel or an export is shown, the app checks, as you, that you can open each saved filter, project or JQL query the tile is built from, and asks Jira, as you, how many of the chart's own work items, named by their ids, you can open; if you have lost access to any since the chart was built, it is built again from a fresh search of yours. So a chart never lists a work item you could not open when it was built, and access you lose is noticed at the next view, or within five minutes of it. Jira describes these counts as estimates that may miss the latest changes. Work items beyond the 10,000 last updated that your search returns are counted, by Jira's estimate for you, but never listed. A summary a Jira Automation rule sends is the exception: it states what the chart of the person whose connection the rule's action uses states, to whoever the rule names, whatever Jira lets them open (how).