Applies to: Stintwise — Cycle Time & Lead Time Chart for Jira.
Every statement on this page about the app describes what its code actually does; statements about other companies rest on their published documentation, quoted where the exact wording matters. Some claims name the automated test that enforces them. Where something is a limitation rather than a guarantee, it says so.
What the app reads
To compute how long work items take, the app reads, from your Jira site:
each saved filter, project or JQL query the tile is built from: a saved filter's name and the JQL it contains, and whether you can edit it, a project's name and key, through Jira's project search, which lists a project only to someone who can browse it, and Jira's check of a query, which it accepts only with no error and no warning. They are read as you each time a chart, drill panel or export is served, and in one request for each kind each time a tile showing several side by side asks after them, because that read is also the permission check described under Who can see a chart below. On such a tile, a saved filter whose chart you have not yet been shown that day is also read on its own, with whether you can edit it, before a chart of it built from someone else's search is checked for you or one is built from yours. Whether you can edit it is used only to decide whether you may be shown a chart built from someone else's search, and is never stored
whether you can edit the dashboard the tile is on, read as you once a day, and once a quarter hour for a chart that includes today, and, on a tile showing several side by side, at most once each time it asks after them, used only to decide whether you may be shown a chart built from someone else's search, and never stored
when you open the settings of a gadget with no filter chosen, and again as you type in their filter box, the names of up to 50 saved filters you can see that match what is in the box, and the names and keys of up to 50 projects you can browse that match it, so that you can pick one, and, when what you type is JQL, only Jira's check of it, as you. When more than 50 match, the app also looks up the filters named exactly what you typed, which reads the names of up to 250 more. Nothing else about those filters or projects is requested until you pick one, which is then read as the first item above describes. When you open the settings of a gadget or widget with sources chosen, the app reads the names of those you can open, and Jira's check of each JQL query among them, so that they can be listed
the list of statuses in your site, and their categories, read as you in the gadget's settings, and as the app about once an hour, when a chart is built: a build reads it when the copy the app keeps is an hour old, or when a work item's history, or the status it is in now, names a status the copy does not list, or names one by another name than the copy, and builds that start together may each read it. Jira sends each status with its description, its icon and, for a status that belongs to one project, which project; only the name, the id and the category are used
when your chart is built, the app searches, as you, while you need not be looking at the tile (see the app acting as you), for the work items your filter returns for you that entered one of your Done statuses during the chart's range, or were created or resolved during it and are in one of them now, with each one's id, key, creation date, when it was last updated, the status it is in now, the name and id of its issue type, its parent, labels, components and team and, on a site with sprints, the sprints it was in; for Last closed sprint, over the 90 days before today, of which the chart keeps the work that counts in the sprint. It keeps up to 10,000, those last updated, reading up to 20,000 to choose them, and, when there are more, how many there are in all, counted as you. When there are more than 20,000, or when your view of the tile, which counts them as you before the build, counts more than 18,000, the app searches instead for the ids and keys of the 10,000 last updated, and then reads those by id
when your chart is built, the app searches, as you, while you need not be looking at the tile, for the work items your filter returns for you that are in progress: not in one of your Done statuses now, and in one of your Started statuses now or moved into or out of one at some time, oldest created first, with each one's id, key, creation date, when it was last updated, the status it is in now, the name and id of its issue type, its parent, labels, components and team and, on a site with sprints, the sprints it was in, and keeps the first 2,000; when there are more, it reads the ids and keys of up to 5,000 of them in one page to count the rest, and, when there are more than that page holds, how many there are in all, counted as you; and again, as you, without the sprints and after your view counts them as you, when the Aging view opens with Measure ages when this view opens ticked, at most once a quarter hour
when your chart is built over days that run to today, the app searches, as you, while you need not be looking at the tile, for the work items your filter returns for you that moved into one of your Done statuses after the chart's range ended and are in one of them now, having been in one of your Started statuses: work that finished after the range and before the chart was built, which the Flow view counts as in progress on the days before. Oldest created first, with each one's id, key, creation date, when it was last updated, the status it is in now, the name and id of its issue type, its parent, labels, components and team and, on a site with sprints, the sprints it was in, of which the app keeps the first 1,000; when there are more, it reads the ids and keys of up to 5,000 of them in one page to count the rest, and, when there are more than that page holds, how many there are in all, counted as you; never for Last closed sprint
when you have the tile compare your chart with the period before it, or, on a tile showing several sources side by side, each of them, or show each of them over four quarters, as you, the work items the first of those searches finds, over the period before's own days, or each earlier quarter's, instead of the chart's, up to the same limit and counted the same way past it; for the sprint before the last closed sprint, over the same 90 days, of which it keeps the work that counts in that sprint. The period before, and each earlier quarter, is a chart of its own, and no work in progress is searched for it
for each of them, as you: its status change history — that is, which status it moved to and when — except on a chart of the last closed sprint or the sprint before it, where only the work in that sprint's list is read. Of what the searches return with each work item, its creation date is used for lead time; when it was last updated to keep and order the work items as your own search would, and, stored with the chart, so that its next build searches only for what changed since; the status it is in now for a work item with no status change, whose status then tells whether it was created in Done or in a Started status, and, stored with the chart, for its next build; the name of its issue type to split the chart by issue type, to show beside each work item in the drill panel and to write in the CSV export, and its id, stored with the chart, so that its next build gives a renamed issue type its new name; its parent's id and key, its labels and the names of its components, and, where your site has Jira's Team field, the name of its team, each to split the chart by it and to write it in the CSV export, and the team's id, in memory only, so that a chart's next build tells two teams of one name apart; and, where your site has a Sprint field, the sprints it is or was in: each sprint's id, its board's id, whether it is future, active or closed, and when it started and when it closed, used to divide the Trend view by sprint, to chart the last closed sprint and to write them in the CSV export. The app asks about no other work item. When Jira does not let the app act as you, these searches run as you while you view the tile, and the rest is read as the app, as it was before. A work item's project is the part of its key before the hyphen; a project is read only when the tile is built from it, as the first item above says
to check that you can still open what your chart lists, how many of the chart's own work items, named by their ids, you can open, counted as you. Only the numbers come back; they are compared in memory and discarded, and an answer that lets you see the chart is reused for up to five minutes (why)
when a chart built from someone else's search could be shown to you, whether your own searches return any work item that chart does not list, and whether they return every work item it lists, in the project its key names, asked as you: searches that name the chart's work items by their ids and come back empty when your searches return nothing more, and counts of how many of its work items your searches return. Only whether each search is empty, and the counts, are used. A search that is not empty returns at most one work item, which is discarded in memory. One work item of the chart for each issue type, sprint, team and project is also read as you, with its issue type, sprints and team, to check they read to you as the chart states them; what is read is compared in memory and discarded
when a chart is built again within 97 hours of an earlier build of the same source and settings, its own or, for a chart that may be shown to more than one person, a colleague's, the app starts from what that build's searches returned (see What the app stores), all of it asked as you: how many work items each search returns that were updated since an hour before that build, and then those work items, with the fields above; how many of the earlier build's work items each search still returns, counted in blocks of up to 1,000 in one project, and the work items each search returns in a block's range, or in a project the earlier build found none in, that the earlier build did not and that were not updated since, with the same fields; where a count falls short, the ids and keys of that block's work items your search no longer returns, then two counts, and, where they do not agree, that block's work items again, by their ids, with the same fields; and one of the earlier build's work items for each project, status, issue type, sprint, parent, component and team they hold, with the same fields, to see whether a key, a name, a sprint's state or dates, or a parent's key changed, and, in the same reads, each work item a block begins with that the counts did not find still in its project, to see where it is now. A search none of this can settle is read in full, and so is one these checks would spend more of Jira's hourly points on than reading it again, or ask Jira more than 100 times for, and every search once the checks have taken a minute; every work item's status change history is read again; all as above
at a build, as the app, when the copy the app keeps is an hour old, the list of your site's fields, to find its Sprint fields and its Team field by their types: only those fields' ids are used
when a chart whose work items have parents is shown to you, and when you export it, as you, which of those parents you can open, named by their ids: only that answer is used, and a parent you cannot open is not named on the tile and is left blank in your file. The answer, ids only, is reused for up to five minutes
when you choose Parent under Show or Compare, as you, the summaries of up to 200 of those parents that you can open. They are shown on the tile and in an image or summary you take, and never stored, kept, logged or sent anywhere else
when the tile names a sprint, as you, the Sprint field of one work item of your chart for each sprint it names: when a chart of the last closed sprint, or of the sprint before it, is served to you, when its Trend view is divided by sprint, and when your CSV export lists sprints. The names are shown to you, or written in the file you export, and never stored; a sprint Jira does not name for you is shown without its name (why)
when you choose Group by: Board column on the Aging or By status view of a chart built from a saved filter, each time the tile opens either view with that choice remembered in your browser, and when you export that view, as you, the boards that use that saved filter, and for up to five of them the names of their columns and which statuses each holds. Only the chart's own statuses are named. They are shown to you, or written in the file you export, and never stored; a board you cannot open is neither used nor counted
at each build, as the app, whether your site has content Jira keeps from apps (Jira's data policy): a single yes or no
when you open the settings of a gadget that has not been configured yet, your own Jira profile's time zone, so the date range and the day boundaries default to the zone you already work in rather than to UTC. This is read only while those settings are open, it is read for the person configuring the gadget and nobody else, and the only field used is the time zone
when a Jira Automation rule runs Write a Stintwise summary or Write a Stintwise comparison, the reads a tile's first view makes, as the person whose connection the action uses, for each source its settings name, and, for the comparison, for the period before; and when someone changes the settings in the action's form, or the rule editor asks the form for them, each saved filter among them, read as that person in one request, so that its JQL can be sealed with the settings, as What the app stores says; and, for the comparison's settings of five or more sources, or the summary's of nine or more, each project among them, read as that person in one project search, and a count, as that person, of the work items of each source they can open, in the chart's range and, for the comparison, in the range before, used only to say under the sources whether one run of the action can check the table, and never kept
what Jira sends along with those reads, which the app does not ask for and cannot refuse:
- Jira's change history records who made every change — their account id, display name, avatar, time zone and, depending on that person's Jira profile visibility settings, email address — and neither of the endpoints the app uses offers a way to leave it out.
- A change record can also carry metadata written by the tool that made the change: the name, id, avatar and profile link of another person or system involved, free-text descriptions, and any other data that tool chose to attach.
- When Jira does not allow the batch endpoint (see history read one work item at a time), the per-item endpoint has no filter at all, so Jira returns each work item's whole change history, including changes to fields such as the summary or the assignee.
- Jira's JSON importer, and possibly other imports, keep status changes without the field id the batch endpoint filters on (see history that came from an import). For a work item that may have such changes, the app asks the batch endpoint again without its filter, and Jira then returns that work item's whole change history too; once one has such a change, the app asks for every work item of that chart this way.
- A work item's issue type comes back with its id, description, icon, level in the issue hierarchy and, for a team-managed project, that project's id; only its name and its id are used.
- Each sprint comes back with its name, its goal and the day it was planned to end. Read with a work item, as the app or as you, all three are discarded; read as you for its name, only the name is used. The field list comes back with every field's name, description and where it is used; only the Sprint fields' and the Team field's ids are used.
- A work item's parent comes back with its summary, status, priority and issue type, each component with its id and link, and a team with its id, its avatar and whether it is shared and verified; only the parent's id and key, the component's name and the team's name and id are used.
- A project comes back with its avatar, type, category, whether it is private, and more; only its name and key are used.
- Jira's check of a query comes back with its errors and warnings and, for a query it accepts, the query's structure; only whether it has any error or warning is used, and in the settings the first of them is shown to the person who typed the query, about their own query, and to no one else.
- The saved filter comes back with its owner — account id, display name and avatar — and with the groups, projects, roles and people it is shared with or editable by. It also carries its description, whether you and how many others have marked it a favourite, and when it was last used.
- The dashboard comes back with its name, its owner and the groups, projects, roles and people it is shared with or editable by; only whether you can edit it is used.
- The boards that use a saved filter come back with their names, and Jira may include boards you cannot open. A board's configuration comes back with its name and type, where it is kept (a project, or a person's profile, which names that person), its saved filter, a Kanban board's sub-query, its estimation field by id and name, its rank field and its columns' limits. Only the boards' ids, the columns' names and their statuses' ids are used.
- Your own profile comes back whole — account id, display name, avatar, locale and, depending on your profile visibility settings, email address — although only the time zone is used.
In every case the app takes out the one thing it needs — the status changes, the issue type's name and id, when a work item was last updated, the sprints' ids, boards, states and dates, each work item's parent, labels, components and team, the team's id, each filter's name and JQL, whether you can edit it or the dashboard, each project's name and key, whether Jira accepts each query, the Sprint and Team fields' ids, a parent's summary, a board's id, its columns' names and their statuses' ids, or the time zone — and discards everything else in memory as the response is read. Nothing it discards is stored, logged or sent anywhere. Of what it keeps, the status changes, the issue type's name and id, the sprints, the parents, labels, components and teams, the Sprint and Team fields' ids, and the status each work item is in now and when it was last updated become the records listed below, the time zone is saved with the gadget's settings (also below), each filter's and project's name is shown only to the person it was read as, a query's text only to someone Jira accepts it from, a team's id is used, in memory, to tell two teams of one name apart, and the JQL is used, in memory, to tell one version of the filter or query from the next; neither the name, a team's id nor the JQL is stored by the app; when a work item was last updated is stored with its chart, as the table below says. A sprint's name, read as you, is shown or written to your file and discarded, a board's columns, read as you, are shown or written to your file and discarded, and a parent's summary, read as you, is shown and discarded. The build is given the source, a saved filter's or a project's id or a JQL query sealed with a key only the app holds, the chart's settings and your account id, sealed the same way; it finds the work items itself, as you. It is given a digest of the query that keys the chart too, a saved filter's JQL or the JQL query, as the chart's key already holds one, so that it builds nothing from a query the chart's key does not name, such as a saved filter you have edited since you viewed the tile. When Jira does not let the app act as you, it is given the ids and keys your searches returned instead.
It reads nothing else. It does not request, and its Atlassian scopes do not permit, write access to
anything in Jira. The one scope that writes, storage:app, reaches only the app's own storage,
described below.
Its scope to read Jira work, read:jira-work, is also declared for
Atlassian's offline user impersonation, which lets the app read Jira as any person of your site who
has access to the app, even while that person is not using it, and Jira then shows it only what that
person may see. The app reads that way for every build of your chart, including a build a Jira Automation
action starts as you: a saved filter, the searches of
the chart's source and each work item's history are read as you. Your account id then goes with the
queued job that builds it, sealed with a key only the app holds, as does a JQL query the chart is built
from, and the app never stores either or writes it to its logs. In its
development environment it also reads that way when the developer prices a lookup of a chart's work
items made as the person viewing it (see Logs).
What the app stores
Only this:
| Stored | Why |
|---|---|
| Work item id and key | To list them in the drill panel and the CSV export, and to check, as you, that you can still open every work item your chart lists and every completion the 5,000 cap drops and every work item in progress the 1,000 cap drops, and every work item that finished after the chart's range that the Flow view counts; the part of the key before the hyphen is the work item's project, by which the chart can be split and which the CSV export writes in its project column |
| While your chart is being built, the ids and keys your searches returned, only when Jira does not let the app act as you | For the build to read, and for nothing else; deleted when the build finishes, and otherwise expiring as a chart does |
| That Jira did not let the app act as you for a chart, and when | So that its next build searches while you are looking at the tile instead; it expires as the chart does |
| A key made from your site and your account with a secret the app keeps, and that secret | To mark a chart built from your search that only you are shown, and to remember which chart you were shown today. It is not your account id, and cannot be turned back into it without the secret; it expires as a chart does |
| For a chart that may be shown to more than one person, the id of every work item its searches returned, including those it does not chart, with its key's project prefix, in the order of its key's number; for one work item of each issue type, sprint, team and project, its issue type name, its team's name and its sprints' ids, boards, states and dates, with the ids of the Sprint and Team fields they were read from; when its search of work finished after the range ran to; and how many charts were built from the same settings that day, and when each was started | To check, as each person it could be shown to, that their own searches return exactly these work items and that their issue types, sprints and teams read the same to them, and to start one build where two people's first views come together; it goes with the chart |
| For each chart, every work item its searches returned: its id, key, creation date, the status it is in now, its issue type by id and name, the sprints it was in, its parent, labels, components and team, when it was last updated, which of the searches returned it, and how many of its label, component and team values were left out because they held a line break; when its searches began, when its search of work finished after the range ran to, and the ids of the Sprint and Team fields they read; and, for each chart's settings, its own or shared as above, which of its builds are the last three | So that the chart's next build searches again only for the work items updated since; it is kept 97 hours, so that the next morning's first view, or the first after a weekend, starts from the last chart built before it, and deleted sooner once three later builds of the same settings replace it |
| A key, made at random when the app first seals a query, kept in the app's own storage | To keep each JQL query typed into the gadget's settings unreadable to anyone but the app. It never leaves the app's storage, and goes with the app's other records when the app is uninstalled, as How long data is kept says; a reinstalled app makes a new one, so queries saved before cannot be read and are typed again |
| Work item creation date | To compute lead time, and to show it in the drill panel and the CSV export |
| Each work item's issue type, by name; its parent's id and key; its labels; its components' names; its team's name; and, for each issue type, project, parent, label, component and team, the counted time its charted work items spent in each status | To split the chart by any of them, to show the issue type beside each work item in the drill panel, and to write them in the CSV export. A work item's project is the part of its key before the hyphen; nothing about a project is stored |
| For each finished work item, by id, the sprint it finished in and its sprints the chart keeps: the sprints its finished work or its work in progress was in whose time overlaps the chart's range, and those without dates its finished work was in, each with its id, its board's id, whether it is future, active or closed, when it started and when it closed, and one work item of the chart that was in it; the ids of the Sprint fields the build read; and, for a chart of the last closed sprint, which sprint it charts and the sprint before it on its board, each by id, start and close | To divide the Trend view by sprint, to chart the last closed sprint and the sprint before it, to read a sprint's name as you when the tile or your CSV export names it, and to write them in the CSV export. A sprint's name and goal are never stored |
| Status names | To show where time was spent |
| Status change timestamps | To compute durations, and to count work in progress on each day, and in each status at its end, in the Flow view |
| Computed durations and exclusion codes, which name each public holiday, with its country or region, and each day the whole team was off that removed time and say when time outside the working hours was removed; and, for each status, how many stays charted work items made in it and within what 85% of them ended, as the CSV export prints them; for each status, the counted time charted work items spent in it during their cycle time, as the CSV export's cells add it up, and whether it is one of your Started statuses; and, for each day the Flow view draws work in progress, how many work items in progress were in each status at its end | The numbers on the chart |
| For each work item in progress: when it first entered a Started status, the status it was in, since when and for how long, counted as its age is, and its age — the counted time since it started, measured when the chart was built, or when its Aging view measured them for you — with the status stretches that age is counted over | To plot work in progress against the chart's percentiles in the Aging view, and to list it in the drill panel and the CSV export |
| For each work item that finished after a chart's range and before the chart was built: when it first entered a Started status, where its history was read, the statuses it was in from then until the range ended, when it entered each, and when it left the last of them, with no counted time, when it last entered a Done status, and that status | To count it as in progress on each day it was, and in the status it was in at each day's end, in the Flow view, and to list it there and in the CSV export |
| For each chart, a short copy of its figures: the slowest cycle time, and each charted work item's cycle time in whole minutes, with no id or key; and, for a tile showing saved filters side by side, how many of their charted work items more than one of them returns, as counts only | To draw saved filters side by side without reading each chart's full statistics, to say how many work items they share, and, while you show a target, to count the work items within it in each period before; the copy goes with its chart, and the count expires 25 hours after it is written |
| The start and end of the date range each chart was built over | To date the scatter's time axis with the range its dots come from, to divide the Trend view into its weeks, fortnights, months, quarters or sprints, and to state the range's first and last day under the chart; for the last closed sprint, the instants it started and closed |
| Whether Jira keeps some of the site's content from the app | To say so on the chart |
| The site's status names, ids and categories, read from Jira about once an hour and again when a build meets one the copy does not hold; and the ids of statuses a work item's history names that the site no longer lists, and the names a work item's history or its current status gives a status that the site's list does not | So each build matches statuses by id and labels them, and does not read the list again for a status that is gone, or for a name the list does not give, and so the tile can place a chart's statuses in a board's columns when you group by them |
| The ids of your site's Sprint fields and of its Team field, read from Jira about once an hour | So each build reads the Sprint and Team fields without reading the site's field list again |
| When Jira says the app's hourly limit is used up for your site, until when, and Jira's reason | So that the app asks Jira nothing for your site until then |
| How much of Jira's hourly limit for this app your site's new charts have used this hour, as the app counts it from what Jira's searches returned; and, for each chart whose build started in about the last 40 minutes, the first 16 characters of the hash that names it in the app's storage, what its build is expected to use and when it was started, and, for a minute after each build ends, the same 16 characters and when it ended; each is removed when its build ends, or by the app's next write after that time, and otherwise expires with the count | So that one site does not use up the hour that every site with the app shares; the count starts again at 0 each hour |
| For each build, bookkeeping: its progress, any error code and when it failed, when it started and was built, the names of the records it wrote, how each was compressed, and the sizes and positions needed to read its ledger a page at a time, the version of the app's arithmetic, whether any history was read one work item at a time or was incomplete, and whether any count is Jira's estimate, and whether a chart's counts by status for each day were too large to keep; and, for ages measured on their own, the quarter hour they were measured to and which build's lines they are compared with | To show the tile's progress and errors, to find and delete a build's records, to rebuild charts when the arithmetic changes, and to say on the chart how it was built |
| The gadget's settings: the first source the tile is built from, and up to 19 more it shows side by side, in the order the tile lists them, a saved filter or a project by its id and a JQL query sealed with the app's key, so Jira holds it unreadable, the Started and Done statuses (their names and ids), the date range (for custom dates, its first and last day), the calendar choices: whether weekends count, the working hours, the same on every weekday or each weekday's own, when only those count, a public-holiday country or one of its states or regions, the days the whole team is off, and, for sources side by side, a public-holiday country or region for each, and the time zone of the person who configured it | Saved by Jira with the gadget on your dashboard, not in the app's own storage, and kept until the gadget is removed. Everyone who can see the gadget receives them, and each source's holiday list, also for a source they cannot open; on a source of one person's work, that list says where the person works. That includes the days the whole team is off. The app cannot tell a team's days off from one person's: a list of one person's leave would tell everyone who can see the gadget when that person was away, and the drill panel and CSV export name each listed day that removed time. Settings saved after the update of 8 October 2026 hold no saved filter's name; settings saved before it also hold the first filter's name until they are next saved. The tile names a saved filter on its face only to someone Jira lets open it, by the name Jira gives them. A JQL query's text is shown only to people Jira accepts it from |
| The settings of a Stintwise action in a Jira Automation rule, and a seal that ties them to the person who saved them and to each saved filter's query as they read it | Saved by Jira Automation with the rule, not in the app's own storage, and kept until the rule is changed or deleted. Whoever can see or edit the rule receives them. They hold what a gadget's settings hold, above, but no JQL query and no saved filter's name; the seal is a keyed hash, with one keyed hash for each saved filter's query, that names nobody, and only this installation can check it |
| In your browser, which view you last chose on each gadget (Histogram, Scatter, Trend, By status, Compare, Aging, Flow or Forecast), the period you last chose in its Trend view (Week, Fortnight, Month, Quarter or Sprint), whether Compare lists issue types, projects, parents, labels, components or teams, whether you last had it compare the chart with the period before, the history, date and number you last chose in its Forecast view, whether you chose to have its Aging view measure ages when it opens, whether you chose to show the 70% line, whether you last chose cycle time or lead time on its Histogram, Scatter and Trend, whether you chose to show natural process limits on its scatter, whether its Flow view draws run charts or cumulative flow, whether you last grouped its Aging and By status views by board column, and the target you last set, a number and its unit, each under the gadget's own id | So the gadget opens on that view, period, grouping, comparison, forecast, ages, lines, measure, limits, Flow view's chart, grouping by status or board column and target next time. Another browser, or this one with its site data cleared, starts on the histogram in cycle time with no comparison, the Trend view on its range's own period, Compare on the kind of group the chart has more of, the Forecast view on the chart's whole range, four weeks ahead or as far as it reaches, with no number, with ages as of each chart's build, no 70% line, no natural process limits, the Flow view as run charts, the Aging and By status views by status and no target. They are kept by your browser for the gadget, never sent to the app or to Jira, and hold no work item, filter, issue type, project, parent, label, component or team, and no figure the chart states; which group you chose to show is not kept at all |
What the app never stores
Summaries. Descriptions. Comments. Attachments. Custom field values, but for the sprint ids, boards, states and dates above and the name of the team in Jira's Team field. Sprint names and goals. Assignees. Reporters. Changelog authors. Any Atlassian account id. Any name or email address of any person.
This is not a policy statement, it is a property of the code, and it is checked by an automated test on every commit: the test feeds the app work items carrying a summary, a description, a comment, an assignee display name, a reporter email address, an account id, a custom field, a sprint with a name and a goal, a parent with its summary, a component with its description and a team with its avatar, then asserts that none of those values appears in anything the app writes to storage or sends to analytics. The fields of every stored record are additionally allow-listed, so adding a new field to a stored record fails the build.
(The tests are packages/ports/test/privacy.test.ts, "the app stores no issue content and no user
identity", which runs a build, and packages/app/test/resolvers.test.ts, "what the app stores",
which runs every path that writes — a chart request, a build, a build Jira refuses, a queue that
refuses the job, the drill panel, both exports and the side-by-side view — and checks every stored
field, reading each record as the app reads it back: joined where it was stored in parts, unpacked
where it was stored compressed, and each ledger row read back into its fields; and that no filter
name, query or account id is kept in the app's own storage. Every other test in that file checks the
fields of what it wrote, too, among them a run of a Stintwise action in a Jira Automation rule, which stores
what a tile's first view stores.)
Who can see a chart
A chart is built from one person's search: the work items the saved filter, project or JQL query returns
for them in Jira, searched as them by the app acting as them — the work that finished in the chart's range
or since it, and the work in progress now. The app reads, as them, the creation dates and status histories
of exactly those work items, and asks Jira about no other; when Jira does not let the app act as them, their
view searches as them, the app reads those as itself, and that chart is shown to nobody else. Another person
is shown a chart built from someone else's search 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 the
work items' issue types and sprints read to them as the chart states them; otherwise a chart is built from
their own search. 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 JQL 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. Every figure in it is as of when it was built, which the chart shows, and that can be earlier
than your first view; the ages of work in progress in it were measured then, or when your own Aging view last
measured them. A filter or a query that uses currentUser() or another part of JQL that Jira answers
differently for each person means, for each person, what it means to them in Jira, and Jira then returns them
different work items, so each is shown a chart of their own.
What a shared chart can tell you. Whether a chart appears at once or is built for you can tell you whether someone who opened the same tile before you that day had searches that return exactly what yours return. If you also know who that was, it can tell you that their search and yours differ, so that one of you can open work items the other cannot. How long you wait for it, and how long a chart of your own then takes, can show roughly how much larger or smaller their search was; and the time the chart says it was built is when someone first opened it that day. It never shows you a work item, a key, a name or a count from their search. Because whoever can edit the saved filter or the dashboard is never shown someone else's chart, and a filter that names another filter or uses an app's function is never shared, nobody can both choose the query and see this answer; two people acting together, one who can edit the filter or the dashboard and one who cannot, could learn it about the first person to open the tile that day, and so could someone who can change what the filter names without editing it, such as the members of a group it names.
What a wait for Jira's hourly limit can tell you. A new chart that waits until the hour turns because your site's charts have used their part of it, or waits its turn, tells you that new charts other people on your site started this hour, or are building now, are large together. Someone who can edit a saved filter, and who first uses about a fifth of the app's hourly Jira limit with charts of their own, can learn from whether their next chart waits whether colleagues' new charts earlier that hour were large together. The app adds a random amount of up to 100 points of that limit, about what a search of 100 work items uses, to every chart it counts, so one such answer cannot reliably tell whether a colleague's search of that filter found a few work items or none, though it can tell none from several hundred; repeated on a few days, it can show how many it found to within about a hundred, on about a hundred days to within about ten, and more closely the more days it is repeated. It never says whose chart, or which one, and never names a work item.
Before any chart, drill panel or export is served, the app makes these checks as you, using your own Jira permissions. If any fails, you are not served its data.
- That you can open each source the tile is built from: each saved filter, as Jira lets you; each project, as you can browse it; each JQL query, as Jira accepts it from you, which it does not when the query names a project or work item you cannot see, or one that no longer exists. A source you cannot open has no row and is not named; the tile says only how many there are, by kind.
- That you can still open every work item the chart lists. The app 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 dropped and built again from a fresh search of yours. Of the work items it counts as over the item cap, those it dropped past the 5,000 it keeps are checked the same way; search results past the 10,000 last updated, which it counts without reading their histories, are not. Work in progress is checked the same way, including what the Aging view counts over its 1,000 cap; what its search found past the 2,000 it keeps is counted as you, and never listed or checked. Work that finished after the chart's range is checked the same way; what its search found past the 1,000 it keeps is counted as you, and never listed or checked.
- For a chart built from someone else's search, that your own searches return exactly its work items, as the bullet under What the app reads describes, and that you can open every one of them.
A work item's parent is named only where Jira, asked as you, returns it: the tile and your CSV export name a parent only when your own search of the parents' ids returns it. A work item whose parent you cannot open is shown under No parent you can open, with those that have none, and its CSV cell is blank, as for a work item with none; nothing says how many such parents there are.
A work item's team is named as Jira's Team field gives it to the app, on work items you can open: whether Jira would show you that team is not checked, and has not yet been tried on a real site with two accounts.
A JQL query is checked by Jira's own validation, which does not check the people it names, free text, labels or what a query passes to a function: those words are shown to everyone Jira accepts the query from. A query is the configuring person's text, and can name people as JQL can.
Please read this part carefully, because these are real limitations. Jira describes the counts it gives as estimates that may miss the latest changes, so access you lost a moment ago can be noticed late, and an answer that lets you see a chart is reused for up to five minutes. Work items beyond the 10,000 last updated that your search returns are counted, by Jira's estimate for you, and never listed. An organisation's app access rule can keep the app from some projects: when the app reads as itself, work the app is not allowed to read is counted and listed by key, and if the rule also hides work from the searches made for you, that work can be missing from the chart without being counted; the chart says so when Jira reports that such a rule applies. A JQL query sealed in the settings still tells everyone who can see the dashboard roughly how long it is. Jira's search can take a moment to reflect a change of access: a person whose access to a work item was removed seconds before they opened a shared chart may be shown that work item's dates in it, read by the person whose search built it, for the rest of the day.
We would rather state this plainly than imply something stronger.
An image or a summary you take from a chart. The Image or summary panel of a chart, or of saved filters side by side, draws the chart or the table on your screen as a picture, and writes its figures as text, a few lines for a chart and a line for each saved filter for the table, in your browser. To make them the app reads nothing more from Jira; nothing about them is sent to the app or stored by it, and no event is recorded. The clipboard is written only when you press a copy button, and is never read. 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. Both state the saved filter's or project's name or the JQL query's text, or on a tile of several the name of each one you can open and how many you cannot, the date range, the calendar, the time zone, when the chart was built, the counts and figures on the chart, and the status, board column, issue type, project, parent, label, component, team and sprint names it shows, and a parent's summary, and the target you show, so a copy says whose line it is. Once you paste or send either, it is outside Jira and its permissions: anyone who sees it can read those, as with a screenshot. Unlike a CSV you export, it holds no work item key but a parent's and any a JQL query's text names. (how)
A summary a Jira Automation rule sends. When a rule runs a Stintwise action, the app writes the summary that Copy text and Copy Markdown give for a tile set up as the action is, on its first view: the histogram for one source, the table for several, and, from Write a Stintwise comparison, set beside the period before. It is counted as the person whose connection the action uses, and states only what that person's own chart states, in words about that person rather than about the reader. Only settings that person saved can run: if anyone else saves the action's settings, or a saved filter's query changes, it stops until that person saves them again; someone who can edit the rule can put back settings that person saved before. A saved filter whose query names another saved filter or uses a function an app adds to Jira cannot be the action's source, since either could change what the summary states while the filter's query stays the same. The rule's later steps send it to whoever the rule names, outside Jira and its permissions, on the rule's schedule, without anyone pressing a button, and anyone who can edit the rule can add a recipient. It states what a copy states, above, as that person's chart states it: each source that person can open by its name, the sprints' names, each source's holiday country or region, the time zone and when the chart was built, and it counts, without naming, the sources they cannot open. The app adds no work item key of its own; a name is stated as its author wrote it, and can name a work item, a person or a label. The app sends nothing itself. (how)
Where data lives
Inside your own Atlassian cloud instance. The app runs entirely on Atlassian Forge and stores its computed numbers in Atlassian's own storage, in the region Atlassian allocates to your site. The app operates no servers, no database and no infrastructure of its own. Apart from the product events described under Analytics, and the log lines described under Logs, which Atlassian shares with the app's author unless an administrator turns off "Logs access", nothing it computes reaches the app's author.
How long data is kept
- A chart is built at the first view each day of someone not shown one already built that day from the same settings and searches that return the same work items, over the days before today, and the age of work in progress is measured at that moment; and again, up to the start of the current quarter hour, when you tick Include today on the tile, at most once a quarter hour. When you ask the tile to compare it with the period before, that period is a chart of its own, built and kept the same way. A tile showing several sources side by side builds and shows each one's chart as a chart of the tile is built and shown, three at a time, or one at a time while one holds more than 1,000 work items. When you have it compare them with the period before, each one's period before is built or shown after them, three at a time, or one at a time while one holds more than 1,000 work items, and none beside a source that charts nothing. When you have it show four quarters, the three quarters before each one's are built or shown after them, the nearest first, the same way; the nearest is its period before, built once for both; and none beside a source that charts nothing. The ages of work in progress are measured again, as you, when the Aging view opens with Measure ages when this view opens ticked, at most once a quarter hour; those ages are a record of their own, kept the same way.
- Everything the app writes for a chart but what its next build starts from (the next item) expires 25 hours after it is written: the chart, the record of the build that produced it, the keys that mark it as yours or remember which chart you were shown, the work items its searches returned, that Jira did not let the app act as you for it, and the count of work items several charts share. Atlassian's storage removes an expired record later, and its documentation says "Expired data is not removed immediately upon expiry. Deletion may take up to 48 hours. During this window, read operations may still return expired results." So 73 hours after a chart was built, at the latest, the app can no longer read it. The app deletes the ids and keys your searches returned, when it keeps them for a build, when the build finishes, and otherwise they expire the same way.
- What a chart's next build starts from, every work item its searches returned with what was read of it, and the record of which builds of the same settings are the last three, expire 97 hours after they are written, so that the next morning's first view, or the first after a weekend, can start from the last chart built before it; the app can no longer read them 145 hours after they are written, at the latest, and a build deletes them sooner once three later builds of the same settings have replaced them.
- The site's status list, and the ids and names it keeps of statuses it no longer holds or names otherwise, and its Sprint and Team fields' ids, are read from Jira again when a build finds them an hour old, and expire the same way: 73 hours after the last time they were read, at the latest, the app can no longer read them.
- Until when Jira's hourly limit is used up, and Jira's reason, expire the same way: 73 hours after Jira last said so, at the latest, the app can no longer read them. They keep the app from asking Jira only until the time they name.
- This hour's count, and what it keeps of the charts being built, expire the same way: 73 hours after they were last written, at the latest, the app can no longer read them, and the count counts for nothing once its hour has passed.
- Expiry is done by Atlassian's storage itself; the app does not have to run for it.
- The secret the per-person keys are made with is one random value for the installation, kept for as long as the app is installed, and so is the key JQL queries are sealed with, made the first time one is.
- What Atlassian keeps after the app can no longer read a record is Atlassian's, and this page promises no deletion beyond what Atlassian states. Of data an app deletes, Atlassian's data lifecycle page says: "When your app deletes data through a storage API, that data is removed from primary storage and your app can no longer read it. Atlassian keeps a soft-deleted copy so the data can be restored after an accidental deletion, then destroys it at the end of the retention period described in the Atlassian SOC 2 report." An app's developer can ask Atlassian to restore data the app deleted by mistake "within 21 days of the deletion". The page does not say whether a record that expires is kept the same way.
- On uninstall, the app can no longer run, and what happens to its storage is Atlassian's. The same page says that "the data is first 'soft deleted' and then retained for the rest of the retention period as outlined in the Atlassian SOC 2 report", and that "if a request is made within 21 days of uninstallation, the new installation can be relinked to the old data". Atlassian's storage overview states that "Forge hosted storage retains data for 28 days after uninstallation", and its page on managing an installed app says: "After the app is uninstalled, the app data is retained for a limited period (30 days) before being permanently deleted."
Analytics
The app records four product events in a PostHog project hosted in the European Union:
- that a chart was built, with the number of work items it accounts for (those it charted and excluded together) as one of four bands (under 100, 100 to 999, 1,000 to 4,999, or 5,000 or more), and whether any history was missing or read the slow way;
- that a stored chart was shown on a dashboard;
- that the exclusion ledger was opened, and for which exclusion reason or for a mark on the chart;
- that a CSV was exported, and whether the whole ledger or the list in the panel.
A Stintwise action in a Jira Automation rule records no event of its own; a chart it starts records that a chart was built, as every build does.
Each event carries a salted SHA-256 hash of your site's cloud id and nothing else that could
identify anyone. That hash identifies an installation, never a person. No Atlassian account id,
no name, no email address, no issue key, no issue type and no project name is ever sent. Automated tests check this
against what is actually sent: packages/app/test/resolvers.test.ts ("what reaches the analytics
processor") runs a build and every action that sends an event, and checks each event and property
against the list above and each event's text for issue keys, the filter's name and query, and the
cloud id; packages/ports/test/privacy.test.ts checks the build's event for the issue content
described above.
PostHog keeps events available for a year on the free plan this project uses, and for seven years on its paid plans. Its documentation (posthog.com/docs/data/events-retention) does not say they are deleted after that, and says a shorter period cannot be set. The events carry nothing that identifies a person or a work item.
Turning analytics off. An administrator of your site can stop the app sending these events,
without uninstalling it. In Atlassian Administration, select Apps, then Sites and your site,
then Connected apps; select this app's action button, and in its Details tab, under "Analytics
access", disable the setting. The Settings tab of Connected apps sets the same for apps installed
later, under "Access to analytics and logs on installation". Atlassian's pages for
one app
and for
all apps
say: "Disabling access to analytics only disables the sending of data to domains that are
categorized as analytics in the app. Apps may continue to send data to domains not categorized as
analytics." This app declares one outside host, PostHog's, as analytics, and no other. Atlassian adds
that after a change "it may take a few minutes for the app to either start or stop sending data to
analytics domains". A send that is refused is dropped, and the chart, its lists and its exports are
the same either way: packages/app/test/resolvers.test.ts ("a send the analytics host refuses at
once") compares every answer the app gives with a run whose sends are accepted.
Logs
The app writes a line to Atlassian's Forge logs when a chart's build is queued, starts and finishes, when a build read some history whole, when a build reads the site's status list again, when a chart is served after asking Jira whether you can still open its work items, when a chart built from someone else's search is checked against your own searches, when a chart's build reads a search in full where it could have started from an earlier build, when Jira asks a build to slow down, when Jira's search returns work items out of the order a build asked for, when Jira says the app's hourly limit is used up or that little of that limit is left, when the app holds a new chart back so as not to use up Jira's hourly limit, when Jira would not let the app act as you for a chart's build, when a saved filter was edited between your view and its chart's build, when something fails, and, in the app's development environment only, when it prices a kind of request: a search or a lookup of work items, made as the app or as the person viewing, a count, or a search that finds nothing. A line holds an event name or an error code and, depending on the event, the hash that names the chart in the app's storage, the version of the app's arithmetic, how many work items were charted and excluded, how many of their histories were read whole, whether any held a status change without its field id and the size of the largest page of them, how long the build took, how long it waited in the queue, how many lookups of work items and batches of histories it read and how long each took, how many pages the build's searches made as you read and how long they took, whether the build started from an earlier one, and then how many work items were updated since it, joined its searches or left them, how many blocks of work items it searched again and how many work items it read again to check their names, keys and sprints, and, for a search it read in full instead, which search and why, how long writing its records took, how long the searches made as you and the queuing took, how long counting your first search as you took and how many work items that count expected, whether your view searched as you because Jira would not let the app act as you, which copy of a shared chart a build is, or why a chart was built from your search alone where it could have been shared, for each check of a shared chart against your searches which copy it was, how many copies the view had tried, how many searches, counts and representative work items the check took and how long, whether your searches return its work items exactly and, if not, where it stopped, how long reading the chart and checking what you can open took, how many work items the searches made as you and the lookups returned, how many status changes the history reads returned, how many lookups returned none, how many label, component or team values were left out because they held a line break, and, when Jira says how much of the app's hourly limit is left, how much each of those and checking what you can open used, with which limit, how many statuses a build met that the site no longer lists, how much of Jira's hourly limit your site's new charts used this hour, as the app counts it, until when Jira's hourly limit is used up and the reason Jira gave, how much of the app's hourly limit Jira says is left, which kind of request was priced, how many work items it named and how much it used, how far apart Jira's figures for what was left lay around it and whether they lay close enough to price it, an error's type, its HTTP status, or the app's code for what Jira answered, or why it held a new chart back. When a build fails for a reason that did not come from Jira, such as a fault in the app's own code, the line also holds the error's message, cut to 300 characters, and the first 8 lines of its stack. The app never writes the message of a failure Jira reports, because it carries up to 200 characters of what Jira answered. An error the app does not catch is logged by Forge: Atlassian's page on app logs says that "Unhandled errors are assigned the Error level, and include both app errors and platform errors". When the gadget's settings cannot read your filters, projects, statuses or time zone, or check a JQL query, the message of the error they pass to Forge is the app's code for the failure, never what Jira answered, and no line holds a query. The same page lists what Atlassian shows beside each line, among them the name of the site it came from, and says "Logs are only available for the past 30 days". Atlassian's page on managing an installed app says that turning log access back on "will give vendors access to logs for up to 60 days ago". Neither page says when Atlassian deletes a log line.
Stopping the app's logs being shared. In the same Details tab, under "Logs access", disable the setting. Atlassian says that the vendor then "will no longer be able to see any logs that have been created inside your site". The setting "Access to analytics and logs on installation" covers logs too, for apps installed later.
The try page
stintwise.adigium.com/try runs the gadget's own code in your browser, on made-up work items. It reads nothing from any Jira site. It loads its own files from this site when it opens, and its Content-Security-Policy then allows it no connection of its own, so what you do inside it reaches none of the app, Atlassian or PostHog. A link you open from it, such as the documentation or a work item's key in a new tab, is a request for a page of this site like any other. It sends no analytics event: the app's four events are sent by the app's server, which the try page does not have. What the gadget keeps in a browser, listed above, the try page keeps the same way, in this browser's storage for stintwise.adigium.com, under the try page's own ids. Like every page of this site, it is served by Cloudflare Pages, which receives each request for a page or file of the site with your IP address and your browser's description, as any web server does. Cloudflare also asks browsers that support it to report a request to this site that failed (Network Error Logging), outside any page's policy.
Sub-processors
| Sub-processor | Purpose | Region |
|---|---|---|
| Atlassian | Hosting, storage, billing | Per your Atlassian site |
| PostHog | Product analytics (pseudonymous installation id only) | European Union |
There are no others for the app. Support email is separate: mail to stintwise@adigium.com is delivered by Cloudflare Email Routing to a Gmail mailbox, so Cloudflare and Google handle what you choose to write there.
A summary a Jira Automation rule sends goes by the channel the rule names; the app takes no part in sending it.
Support, and why it is written
Support for this app is written documentation and written correspondence only. There is no chat widget, no phone number, and no live support session — by design, not by omission. A written-only support channel is also a privacy property: nobody screen-shares your Jira instance to a stranger, and no support session ever grants a third party access to your data.
Contact
Write to stintwise@adigium.com. It is a written inbox, and the only support channel (see the section above for why that is deliberate); a security problem goes to its own address, as the security page says. The support address will be given on the app's Atlassian Marketplace listing.
For a question about your own data — what is held, or a request to delete it — say so in the subject line. Note that the app keeps nothing that names a person: its own storage holds what is derived from work item ids, keys, issue types and creation dates, status names and status timestamps, and the ids, boards, states and dates of sprints, expiring on the schedule above; the keys made from a viewer's site and account with a secret, which mark a chart as theirs or which chart they were shown, which cannot be turned back into the account and go with the chart; that secret, one random value per installation; and the key the JQL queries typed into the settings are sealed with, another. The gadget's settings, including the configuring person's time zone, are kept by Jira with the gadget and go when the gadget is removed.
Changes
Material changes to this page will be noted on the app's Marketplace listing.