Version 1.1 · Effective 23 October 2026
This policy explains what data ReqDrift for Jira (Excel Requirement Changes) (the "app", or ReqDrift) reads, writes, stores and logs, and how it is secured. The app is published on the Atlassian Marketplace by Myriastra Studio ("we", "us"), and is built on Atlassian Forge. The security disclosures are in section 8, Security. The data residency declaration is in section 6.
The app runs entirely on Atlassian's Forge platform, and Atlassian's eligibility check reports the released version as meeting the technical requirements for Atlassian's Runs on Atlassian program (see section 8). We operate no servers, no database and no analytics infrastructure of our own for this app. The app's manifest requests no permission to contact any host outside Atlassian, the app makes no network requests to such a host, and we operate no system that receives your data. The weekly email is delivered by Jira's own notification service — see section 3.
Jira tells the app about each new attachment on your site. If the attachment is not an .xlsx file on the issue of a registered table, the app stops there; it writes the attachment's ID and size, the ID of its issue and the result of that check to its log (section 5), not the attachment's name or author.
When an .xlsx file is attached to the issue of a registered table, the app downloads that file and the last confirmed version, reads the first sheet of each, and compares them row by row. The files are held in memory only while that comparison runs.
To find the issues that match each changed or removed row, the app searches the table's project and reads, for each issue: its ID, key, project, summary, issue links, parent and sub-tasks, whether it has an issue security level, and the value of the REQ ID field if you chose one. It also reads the issues named in the key column, the list of Jira fields (to learn the type of the REQ ID field), whether the app itself can browse the project, and your site's base URL (to build links). Summaries are used to look for REQ IDs and are not stored. These reads use the app's own identity, so they reach only projects the app is allowed to browse.
When a person opens the app's panel or project page, or confirms a version or closes a mark, the app reads on that person's behalf: which of the issues and attachments involved they can see, so that it shows only those, and whether they hold the Jira permission the action needs (section 8). If an earlier attempt to post a comment may have been interrupted, the app reads the properties of the comments already on that issue before posting again, so that it does not post the same comment twice.
This app writes to your Jira site in three ways: it adds the label reqdrift-open to each issue it marks and removes it when no marks are open, posts one comment naming the REQ ID for each confirmed change, and, while a table has open marks, asks Jira's notification service to email the person who registered the table at most once a week. It changes no other field and attaches no files. A project administrator can turn off the label and comment per table; marks inside the app remain, also if Jira refuses a write.
Each comment has three paragraphs: a fixed sentence saying whether the requirement row was changed or removed, the REQ ID (cut at 500 characters), and a line asking the reader to open the app's project page. It does not include cell values, file names, the table's issue key or anyone's name. Each comment also carries two properties that are not shown in its text: one holding the app's internal ID for the change, made of the attachment's ID and the full REQ ID, so that the same comment is not posted twice, and one asking Jira Service Management to treat the comment as internal.
The weekly email goes to one person: the account that registered the table. Each table has its own email, so a person who registered two tables can receive two. Its subject gives the table's issue key and the number of open marks. For each open mark on an issue that person can see, the body gives the issue key, the REQ ID, whether the issue was matched directly or through a link, the number of changes and a link to the issue; marks on issues that person cannot see are counted, not named. It does not include cell values, issue summaries, file names or anyone's name. Jira queues the message and delivers it to the email address on that person's Atlassian account.
The app stores data inside Atlassian (Forge storage). For each registered table: its settings (column names, link types, and whether Jira writes are on) and the account id of the person who registered it. For each compared version: the REQ ID and key column value of each changed, added or removed row, the old and new values of the watched cells that changed, and the issues each row points to; for rows and columns it could not compare, their row numbers, duplicated REQ IDs and column names. For each mark: the issue, the REQ ID, the tables it came from, whether it was matched directly or through a link, the changes, and the decision (Reflected or No impact, an optional memo, the account id of the person who closed it, and the time). It also keeps the account id of the person who confirmed each version, the REQ IDs they unticked, and a record of each week the app checked a table for the weekly email, whether or not an email was sent. It does not keep a copy of the spreadsheet file; the versions stay as attachments on your Jira issue. Stored data does not expire while the app is installed. The app does not send data to any server outside Atlassian; the weekly email is delivered by Jira's notification service to the mailbox of the person who registered the table.
The app also keeps bookkeeping records for its own processing: for each version and each processing step, how many times it was tried, whether it finished, and its outcome; for each issue and change, whether its comment was posted and when (a change is named by the attachment's ID and the REQ ID). If reading a version or collecting its issues failed, the record keeps the error text as it was returned (up to 1,000 characters), and for a failed read the table's status keeps it too; for applying marks it keeps a short error code only.
The app does not store issue summaries, display names or email addresses of its own accord. Error text kept as returned (above) could contain such a value if Jira, Forge or the spreadsheet reader included one in it. Where the app shows a person's name, your browser looks it up from the account id when the page is shown.
The app writes one line to Forge's application log each time one of its background steps runs (noticing an attachment, reading a version, collecting its issues, applying marks and handling the weekly email); opening the app's screens or acting on them writes no line. Each line gives which step ran, the IDs it worked on (an attachment ID, a Jira issue ID or a week label), the outcome, counts and timing. Apart from error text (below), these lines do not carry REQ IDs, cell values, issue keys, summaries, file names, display names or email addresses.
When a step fails, the line also carries the error. For the weekly email and for applying marks, that is a short error code only. For noticing a new attachment, reading a version and collecting its issues, it is the error text as received (for the last two, the first 200 characters), which can come from Jira, Forge or the spreadsheet reader. When asking Jira to send the weekly email fails, the app writes a warning with the table's issue ID and either the HTTP status and the error messages Jira returned, or, if no response arrived, the connection error text. We do not write summaries, display names or email addresses to the log ourselves; error text returned to us is recorded as we receive it. Forge logs are held on Atlassian's infrastructure and are retained according to Atlassian's platform policy; we read them only to diagnose faults, and we do not copy them anywhere else.
Atlassian asks each app to define and publish what it treats as in scope and out of scope for data residency. This section is that declaration. It adds no new processing — it restates what sections 2 to 5 already describe.
In scope: everything the app writes to Forge hosted storage, as listed in section 4 — the account IDs, the REQ IDs and cell values from your tables, memos, settings and bookkeeping records. All of it is held exclusively in Forge hosted storage, which Atlassian operates. We operate no storage of our own, so where that data physically sits is determined by the Atlassian platform for the site the app is installed on, under Atlassian's data residency policy rather than under any arrangement of ours.
Read "exclusively" as: this app writes in-scope data to no store other than Forge hosted storage. It does not mean the values in section 5 appear nowhere else on Atlassian's infrastructure — see Platform logs below.
Out of scope:
Your Jira data. The spreadsheet versions stay as attachments on your issue, and the labels and comments the app writes become part of your Jira site. Jira holds them under its own data residency, not this app.
Data read but not stored. Issue summaries, the list of Jira fields, your site's base URL and the contents of the spreadsheet files are used while a step runs and discarded with it.
Messages between the app's own functions. These carry only IDs, an attachment's size, a week label, a hash of a REQ ID and progress counters, and are passed through Forge's event queue.
Platform logs. The lines described in section 5 sit on Atlassian's logging infrastructure. Their location and retention are managed by Atlassian, not by this app, so we cannot offer a residency commitment over them. If your organisation needs a residency commitment that reaches platform logs, this app cannot give you one — please write to us before you buy rather than after.
Delivered email. Once Jira's notification service has sent the weekly email, the message sits in the recipient's own mailbox with whatever provider they use. We did not hold it, and we cannot recall it.
The app has no sub-processors. It shares data with no third party, and it contains no analytics, advertising or tracking code. It reads spreadsheets with the open-source ExcelJS library, which runs inside the app on Forge and sends nothing anywhere. The icon of the app's issue panel is loaded from an Atlassian address. This page itself loads a web font from Google Fonts; the rest of the page is served by Cloudflare Pages.
This section is the security policy for ReqDrift. Myriastra Studio is a one-person studio, and this app's security rests on how little the app is able to do, rather than on a formal security program. Most of what follows is a property of the app rather than a promise about us; the commitments we make are under Reporting a vulnerability.
Who is responsible for what. Atlassian provides the platform the app runs on: the infrastructure, tenant isolation, TLS in transit, encryption at rest for Forge storage, and the authentication of the people involved. We are responsible for the app itself: the permissions it asks for, what it does with them, what it writes to logs and storage, its dependencies, and fixing it when something is wrong. Nothing below asks you to take Atlassian's certifications as ours.
The app has no server or endpoint of its own. There is no Myriastra Studio server, database, queue or endpoint anywhere in this app. It exists only as functions running on Atlassian's Forge platform, and its manifest requests no permission to contact any host outside Atlassian. This is why Atlassian's eligibility check reports the app as eligible for Atlassian's Runs on Atlassian program; that is a check on where data can go, not Atlassian vouching for the rest of our code. There is no web trigger and no URL of ours that anyone can call: the app's functions are run only by Atlassian, on Jira events, on a schedule and from the app's own screens inside Jira, and each action on those screens checks the person's Jira permission (below).
We do not receive your credentials. The app does not ask for, receive or store any API token, password or shared secret belonging to you or to anyone on your site. It authenticates to Jira with the identities Atlassian issues to it: its own app identity, and, for the reads described in section 2, access on behalf of the person using it.
The first time a person uses ReqDrift, Atlassian may ask them to grant this app access on their behalf. The app uses that access only to read: to check that person's Jira permissions and to show only issues and attachments they can see. Before it adds a label or a comment to an issue, it checks in this way that the person who confirmed the version holds Edit Issues and Add Comments on that issue. The permission list on that screen includes write access, but the writes described above are made by the app itself, not as that person. Turning off the label and comment for a table does not change the access requested when the app is installed.
The permissions we ask for. The app requests three scopes and no others: read:jira-work, write:jira-work and storage:app. These are declared in the app's manifest, which is the complete list of what the app is able to do. write:jira-work is required by the three writes in section 3: editing an issue's labels, adding a comment and asking Jira to send an email. Jira grants that scope more broadly than the app uses it: it would also permit creating, editing, transitioning and deleting issues, and adding attachments. The app does none of those things. It changes no field other than the labels, adds no attachments, and does not edit or delete comments.
Encryption and storage. The app writes your data only to your Jira site and to Forge storage hosted by Atlassian. Encryption at rest and TLS in transit are provided by the Atlassian platform, not by us. We add no encryption of our own, and we operate no storage of our own. The weekly email leaves Atlassian when it is delivered to the recipient's mailbox (section 6).
Who can reach what. Registering a table and changing its settings, including Write to Jira, require the Administer Projects permission in that project, checked for the person doing it. Confirming a version requires Edit Issues on the table's issue; closing a mark requires Edit Issues on the marked issue. A person sees the app's panel on any issue they can see.
Marks are recorded by the app itself, so a linked issue in another project can be marked in ReqDrift even if the person who confirmed cannot open it. The label and comment are written to an issue only if the person who confirmed has the Edit Issues and Add Comments permissions on that issue, checked when the marks are applied. Otherwise the mark stays only in ReqDrift, and the result counts the issue as without permission. Lists and emails show only issues the reader can see; the rest are counted, not named.
When the app searches a project for matching issues, it checks first that it may browse that project, and Jira returns only what the app's own permissions allow. Our access is limited to publishing new versions of the app and reading Forge's application log (section 5), through the single Atlassian developer account that owns the app. We have no access to your Jira site, and no interface through which we could read the data the app stores on your installation.
How the app is built and released. The app's runtime dependencies are Atlassian's own Forge packages, React and ExcelJS; it bundles no analytics, advertising or tracking library. Every release is built from a version-controlled source tree, and before each deployment we run the project's automated checks (manifest validation, code lint and tests). This is our own practice, not a pipeline that blocks a release by itself. Updates are delivered by Atlassian, not by us. According to Atlassian's documentation, a version that asks for new permissions is held until one of your administrators approves the new scopes, so this app cannot quietly widen what it is allowed to read or write.
Reporting a vulnerability. Please write to contact@myriastrastudio.com with security in the subject line, describing what you found and how to reproduce it. If you believe an issue is being actively exploited, say so in the subject line so that it is triaged first. Please test only against a site you control, and please do not access or modify data that is not yours. Please do not put customer data, spreadsheet contents or any other confidential material in your report. That mailbox is an ordinary email account outside Atlassian — the property that data stays inside Atlassian belongs to the app at runtime, and it does not extend to an email you send us.
We will acknowledge your report and tell you what we intend to do about it. Confirmed vulnerabilities are fixed on the timeline set by Atlassian's Security Bug Fix Policy, which applies to us as a Marketplace partner. We do not run a bug bounty, do not run continuous scanning or scheduled penetration tests, and cannot offer payment. If we become aware of a security incident affecting this app, we will investigate it, report it to Atlassian as the Marketplace Security Enforcement Policy requires, work with Atlassian on containment and a fix, describe it on this page, and contact affected installations wherever we are able to identify them.
What we do not have. So that a procurement team can rule us in or out quickly: Myriastra Studio holds no SOC 2 report and no other third-party security certification, has not completed a CAIQ Lite assessment, and offers no separate data processing agreement. If your organisation requires any of those, this app is not yet a fit — please write to us before you buy rather than after.
While the app is installed, the data in section 4 does not expire. The app has no screen for deleting a table, a mark or a person's account id from its records; it only replaces its own records as it updates them, removing the parts a newer copy no longer needs.
Uninstalling the app stops all further processing. According to Atlassian's Forge documentation, the app's Forge storage is then soft deleted and retained for 28 days, and what happens after that follows Atlassian's own data retention and disposal policy, not any action of ours. We cannot delete it sooner, so the data is not erased the instant you uninstall. Reinstalling the app starts a new installation; it is linked to the old data only if that is requested within 21 days of uninstalling.
Labels and comments the app has written stay on your issues after you uninstall; the app does not remove them. The spreadsheet versions stay as attachments on your issue. Emails that have already been delivered stay in the recipient's mailbox; we cannot recall or delete them, because we did not hold them.
For each table, a project administrator can turn off Write to Jira on the app's project page. The app then adds no new labels or comments for that table. Labels and comments already written stay. The app removes a reqdrift-open label only while at least one table behind that mark still has Write to Jira on; if you turn it off for every table, remove any remaining reqdrift-open labels in Jira yourself. The app also leaves the label in place if it cannot list every mark on that issue.
Turning off Write to Jira does not stop the weekly email. The email for a table stops in any week with no open marks on it, so closing the open marks stops it.
If the app's license is inactive, existing marks stay visible, but new versions are not read, changes cannot be saved, and no weekly email is sent.
To stop everything, a Jira administrator can uninstall the app (section 9).
Because the app processes data only inside your own Atlassian site, requests about a specific person's data are usually best served by your Jira administrator, who controls that site. The app has no screen for removing one person's account id from its records, and we have no access to your site, so we cannot remove it for you; after uninstalling, the whole of the app's storage, including those account ids, is left to Atlassian's retention and disposal (section 9). If you would like to contact us about this policy or about a data request, write to contact@myriastrastudio.com. If you are reporting a security vulnerability, please read section 8 first — it tells you what to include and, more importantly, what not to.
If we change how the app handles data, we will update this page and the version and date at the top of it.