Permissions Reference

Cloud This page documents the Forge build of Time in Status for Jira Cloud. On Jira Data Center or Server? See Time in status | SLA | Timer | Stopwatch for Data Center.

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_admin condition, 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:rovo and does not register any rovo:agent modules.
  • 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)
  • allowImpersonation on 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:

  1. Read each issue’s status changelog and field values to compute time-in-status, stopwatch, timer, and time-between-dates metrics.
  2. Write the calculated metric values back into the app’s own custom fields on those issues.
  3. 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.
  4. Write a small set of project properties used by Forge displayConditions to hide panels in projects that have opted out.
  5. Submit the stored accountId identifiers 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_admin at 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, and Activity panels via the tis-cloud-panels project 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:


Next steps