Stintwise

Privacy

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:

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.

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

Analytics

The app records four product events in a PostHog project hosted in the European Union:

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.