- Quick assessment
- Overview
- At a glance
- App Internal (2 scopes)
- Compliance (1 scope)
- Issue Data (2 scopes)
- Field & Screen Configuration (4 scopes)
- Jira Administration (1 scope)
- Users (1 scope)
- Content Security Policy
- Reviewing scopes before installing
- Compliance and Trust Center
- Next steps
Quick assessment
A 30-second read for purchasing teams and managers evaluating the app.
- Forge-native - runs entirely inside Atlassian infrastructure (Forge SQL, Forge KV, Jira REST API). No external servers, no companion apps, no third-party data stores, no Forge Remote.
- 11 declared scopes, all app-only. The scope list is part of the app manifest published on Atlassian Marketplace, is shown during installation, and can only change through a new release that a site administrator approves.
- Admin-only configuration - the admin page is gated by the Forge
user_is_admincondition, and every mutating resolver call is re-checked server-side. Non-admin users never see configuration screens. - No
external:scopes declared - the app cannot call arbitrary hosts. The only endpoint outside your Jira site is Atlassian’s Personal Data Reporting API, called once a week with the stored account IDs. - No JSM portal modules - the app does not register any unlicensed-access surface; nothing the app stores reaches anonymous portal visitors.
- No Rovo agents - no LLM integration; the app does not declare
read:chat:rovoand does not register anyrovo:agentmodules. - No template engine, no scripting - configurations are typed (status pickers, calendar selectors, JQL filters) and validated server-side; there is no user-supplied executable code path inside the app.
- Compliance - JiBrok maintains SOC 2 Type II certification for its organizational controls; evidence may be shared under NDA where appropriate. GDPR-aligned, single sub-processor (Atlassian Forge). See Trust Center.
What Time in Status (Forge) does NOT request
The app’s manifest does not include any of the following:
- Filesystem access of any kind
- Outbound HTTP to arbitrary URLs (no
external:scopes) allowImpersonationon any scope - all Jira reads execute as the app, not as an end user (see How the app reads issue data below)- Jira user e-mail addresses - the app never requests user e-mail. The only user identifiers it persists are account IDs of two kinds: the administrator who starts a bulk recalculation (kept with the job record for up to 30 days) and the people an administrator picks in Count only while conditions on user fields (kept in the field setting until the condition is changed). Both kinds are reported to Atlassian weekly through Personal Data Reporting and removed when Atlassian reports the account as closed
- Account password resets, 2FA secrets, or session cookies
- Cross-site Jira data (each Jira site is a separate Forge installation with isolated SQL and KV storage)
- Atlassian Marketplace billing data, vendor analytics, or other vendor APIs
- JSM Assets / CMDB scopes (none declared)
- Sprint, board, or agile mutations
- Rovo or chat scopes (none declared)
- JSM service desk request scopes (none declared)
- Screen-scheme or screen-tab management scopes (the app uses Jira’s native custom-field placement UI; it does not write field placements programmatically)
Worst case
If a site administrator misconfigures the app - for example, tracks projects that were not meant to be tracked - the impact is bounded by the app’s write surface: the only Jira mutations the app performs are to its own custom field values (Time in Status, Stopwatch, Timer, Time Between Dates, Calendar Select) and to project-scoped properties used by the app’s display conditions. The app cannot create, transition, link, or delete unrelated issues, cannot post comments on the user’s behalf, cannot reach external services, and cannot bypass tenant isolation. Calculated values become visible to a user only via the standard Jira issue view, where Jira’s native Browse Project permission applies.
For setting up a production-ready configuration, follow the Admin Hardening Guide. For a security review, threat model, and DPIA-grade detail, see the Security Reference for Auditors.
Overview
Time in Status for Jira Cloud (Forge) declares 11 OAuth scopes in its Forge manifest. The list is shown to your Jira admin during installation and can only change through a new release that the administrator approves.
This page lists every scope by name, explains what it enables, and explains why the app needs it. It is the canonical reference for the app’s permissions and is the companion to the Admin Hardening Guide and the Security Reference for Auditors.
New in this release: two read-only scopes
This release adds two scopes, both read-only and app-only:
- Read user information (
read:jira-user) - assignee and author names in the Activity panel’s Download CSV files, picking people in Count only while conditions, and reading the site’s time zone (the default user time zone in Jira settings) for the day boundaries of 24x7 counting without a calendar time zone. - Read field options (
read:field.option:jira) - picking select-list values in Count only while conditions.
Neither scope lets the app write anything, and the app’s network egress has not changed - it still calls no host outside Atlassian. Because the scope list changed, a site administrator approves the update in Jira Settings → Apps → Manage apps before the new version takes effect; until then the site keeps running the previous version.
Why these scopes
Atlassian intentionally splits broad permissions into narrow, single-purpose scopes. The set Time in Status (Forge) requests is the minimum needed to:
- Read each issue’s status changelog and field values to compute time-in-status, stopwatch, timer, and time-between-dates metrics.
- Write the calculated metric values back into the app’s own custom fields on those issues.
- Read field configuration metadata to know where each app-owned custom field is registered, and read user information and select-field options for the Download CSV export and Count only while conditions, and the site’s time zone for the day boundaries of 24x7 counting.
- Write a small set of project properties used by Forge
displayConditionsto hide panels in projects that have opted out. - Submit the stored
accountIdidentifiers to Atlassian’s Personal Data Reporting API for GDPR compliance.
Which listing this page covers
This page covers the Time in Status / SLA / Timer / Stopwatch listing, which registers all five custom field types. The Timer field, Stopwatch field and Time between dates listings are separate apps with their own installation prompts; the scopes each of them requests are shown in its own installation prompt on the Atlassian Marketplace.
How the app reads issue data
None of the declared scopes carry allowImpersonation: true. All Jira reads (issue changelog, field values, field contexts, project metadata) execute as the app identity, not as the viewing user. This is intentional: time-in-status calculations are deterministic functions of the issue’s full changelog and must not vary by viewer.
The app’s read access is therefore broader than any individual user’s: when the app evaluates a JQL filter or fetches an issue’s changelog, it sees data regardless of the requesting user’s Browse Project permission. Three controls keep this safe:
- The configuration UI (where you choose which projects and field contexts the app processes) is admin-only at the platform layer (
user_is_admin) and re-checked server-side on every resolver invocation. - Calculated values are written into the app’s own Jira custom fields. End users see those values via the standard Jira issue view, where Jira’s native permissions apply - if a user cannot see an issue, they cannot see its app-calculated field values.
- Project administrators control where the app’s custom fields appear (via standard Jira screen and field-context configuration). The app does not write field placements programmatically.
At a glance
| Category | Count | Impersonation | What it enables |
|---|---|---|---|
| App Internal | 2 | App-only | Storage, custom field value writes |
| Compliance | 1 | App-only | GDPR personal data reporting |
| Issue Data | 2 | App-only | Read issue changelog/fields; write calculated values to issue custom fields |
| Field & Screen Configuration | 4 | App-only | Read field catalog, per-context configuration and select-field options |
| Jira Administration | 1 | App-only | Manage project properties used by display conditions |
| Users | 1 | App-only | Read user information (display names, the site’s time zone) |
| Total | 11 | 0 impersonation / 11 app-only |
App Internal (2 scopes)
These scopes power the app’s own storage and the mechanism for publishing calculated values.
| Scope | Impersonation | What it enables | Why Time in Status needs it |
|---|---|---|---|
storage:app |
App-only | Read and write the app’s own Forge KV storage | Stores admin-page state, scheduled-job bookkeeping, and JCMA migration progress alongside the structured data in Forge SQL |
write:app-data:jira |
App-only | Write app-scoped data on Jira entities | Publishes calculated metric values back to issues as the app’s own custom field values (Time in Status, Stopwatch, Timer, Time Between Dates, Calendar Select) |
Compliance (1 scope)
| Scope | Impersonation | What it enables | Why Time in Status needs it |
|---|---|---|---|
report:personal-data |
App-only | Submit GDPR personal data reports to Atlassian | Reports the account IDs the app stores - the administrator who started a bulk recalculation (kept with the job record for 30 days) and the people picked in Count only while conditions on user fields (kept in the field setting) - so that Atlassian can propagate account closures back to the app. Runs from the weekly personal-data-report scheduled trigger, which applies the erase and refresh actions Atlassian returns. On erase, a closed account is removed from every condition; a condition or group left empty is removed entirely |
Issue Data (2 scopes)
| Scope | Impersonation | What it enables | Why Time in Status needs it |
|---|---|---|---|
read:jira-work |
App-only (no allowImpersonation) |
Read issues, search issues with JQL, read changelog, read comments | The app processes the full status-transition changelog of each tracked issue to compute time spent in each status, stopwatch state, timer countdown, and time-between-dates intervals. Comment-reading is used by both Stopwatch and Timer when an event trigger is configured to fire on issue comments |
write:jira-work |
App-only | Update issue field values | Required to write calculated values into the app’s own custom fields on the issue. The app uses this scope only to update its own field values; it does not create, transition, link, or delete issues, and it does not post comments |
Field & Screen Configuration (4 scopes)
These read-only scopes power the field-context configuration UI and the change detection pipeline.
| Scope | Impersonation | What it enables | Why Time in Status needs it |
|---|---|---|---|
read:field:jira |
App-only | Read the Jira field catalog | Powers field metadata cache and field pickers in the admin UI; required to discover which Jira fields and contexts the app’s own custom fields are attached to |
read:field-configuration:jira |
App-only | Read field configurations | Required to determine where each app-owned custom field has been added in field configurations |
read:field.option:jira |
App-only | Read the options of select-list fields | Lets the administrator pick select-list values when building Count only while conditions in the admin UI. Read-only |
read:custom-field-contextual-configuration:jira |
App-only | Read custom field per-project contextual configuration | Required by the jira:customFieldType modules to know which projects and issue types each Time in Status / Stopwatch / Timer / Time Between Dates / Calendar field instance applies to, and to react to field-context create / update / delete events |
Jira Administration (1 scope)
| Scope | Impersonation | What it enables | Why Time in Status needs it |
|---|---|---|---|
manage:jira-project |
App-only | Manage project-scoped configuration | Required to write the tis-cloud-panels project property that controls per-project panel visibility. Forge displayConditions on the issue panels evaluate this property at the platform layer to decide whether to render Time in Status, Stopwatch, Timer, or Activity panels in a given project |
Users (1 scope)
| Scope | Impersonation | What it enables | Why Time in Status needs it |
|---|---|---|---|
read:jira-user |
App-only | Read Jira user information | Writes assignee and author display names into the Activity panel’s Download CSV files and lets the administrator pick people in Count only while conditions. Also reads the site’s time zone - the default user time zone in Jira settings - for the day boundaries of 24x7 counting without a calendar time zone, for example in Start counting from the next business day; if the app cannot read it, UTC is used. Read-only; the app does not read e-mail addresses |
Content Security Policy
The manifest declares permissions.content.styles: ['unsafe-inline']. This is a Forge content rule, not an OAuth scope, and it relaxes the default Forge CSP so that the admin page (a Custom UI whose component library emits inline styles) can apply those styles. It does not affect any Forge module other than the admin page resource bundle, and it does not enable network egress, script injection, or DOM access beyond the admin iframe.
The issue-panel and field-context-config resources are Forge UI Kit components (render: native); they do not need and do not inherit this CSP relaxation.
Reviewing scopes before installing
When you install or upgrade Time in Status (Forge), Jira shows the full list of scopes the app requests. The list comes directly from the manifest reviewed by Atlassian; it cannot be expanded silently between Marketplace releases. To see the current set without installing, check the app’s listing on the Atlassian Marketplace.
After installation, the administrative controls available on top of the declared scopes are:
- Admin-only access - the admin page is gated by
user_is_adminat the Forge platform layer; non-admins cannot reach configuration UI or trigger mutating resolvers - Per-project panel visibility - admins choose which projects display
Time in Status,Stopwatch,Timer, andActivitypanels via thetis-cloud-panelsproject property; default is hidden - Field-context scoping - the app processes only the projects and issue types where its custom fields are added in Jira field configuration; outside those contexts, the app does not read or write any data
- Recalculation throttling - bulk recalculations are queued and consumed by the async consumer with bounded timeouts; admins monitor and cancel jobs from the Recalculation tab
For the full hardening checklist, see the Admin Hardening Guide.
Compliance and Trust Center
The full set of declared scopes is part of Atlassian’s app review process and is referenced in our public security documentation:
- Admin Hardening Guide - Production checklist for installation, field-context scoping, recalculation, migration, and incident response
- Security Reference for Auditors - Threat model, scope-to-data category mapping, data flow, and GDPR mapping
- Trust Center - SOC 2 Type II, GDPR, DPAs, vulnerability disclosure, and certifications
- DPA - Time in Status for Jira Cloud (Forge) - Data Processing Agreement
- Vulnerability Disclosure - How to report a security issue
Next steps
- Admin Hardening Guide - Day 0 / Day 1 / Week 1 production checklist
- Security Reference for Auditors - Threat model, data flow, GDPR mapping, evidence
- Admin panel overview - Per-tab admin UI reference
- Recalculation - Bulk recalculation operations
- Limits - System limits and constraints
- Troubleshooting - Common issues

