Security Reference for Auditors

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.

How to read this

This page consolidates the technical and privacy detail required for an external security review or a Data Protection Impact Assessment (DPIA) of Time in Status for Jira Cloud (Atlassian Forge). It is written for security architects, CISOs, DPOs, and external auditors.

The authoritative references are:

  • The Data Processing Agreement for legal categories of personal data, retention, sub-processors, and TOMs (Annex 1, 2, 3).
  • The Permissions Reference for the full list of 11 OAuth scopes and what each enables.
  • The Trust Center for SOC 2 Type II certification, CAIQ Lite, vulnerability disclosure policy, and certifications.
  • The official Atlassian Forge documentation for platform-level guarantees that apply to every Forge app (tenant isolation, runtime sandbox, declarative permissions).

Where this page summarizes a fact from one of the references above, the reference is linked.


Architectural foundation

Time in Status for Jira Cloud (Forge) is Forge-native. Every component (admin UI, custom field resolvers, issue panels, scheduled jobs, async consumers, JCMA migration handlers) runs inside Atlassian Forge. There is no companion service, no external database, no third-party processor, and no Forge Remote.

Property Mechanism
Tenant isolation Per-installation Forge runtime; per-installation Forge SQL (MySQL) and Forge KV storage; identity via Forge platform context
Data residency App data is held in Atlassian-hosted Forge storage (Forge SQL and KV); residency follows Atlassian’s Forge data residency support for the app as shown on the Marketplace listing
Outbound network No external: scopes and no remotes are declared; the app cannot call arbitrary hosts. The only endpoint outside the Customer’s Jira site is Atlassian’s Personal Data Reporting API (https://api.atlassian.com/app/report-accounts/), called weekly with the stored account IDs
Sub-processors One only - Atlassian (Forge platform). See DPA Annex 3
Encryption at rest Forge-managed for SQL and KV
Encryption in transit Atlassian Forge HTTPS termination
Authentication Forge platform identity for app calls; admin guard server-side on every mutating resolver call (user_is_admin re-checked)
Marketplace publication Every release is distributed through Atlassian Marketplace, where Forge apps are subject to Atlassian’s automated security scanning; a release that changes declared scopes requires site-administrator approval before it takes effect
Impersonation None - no scope is declared with allowImpersonation: true
User-supplied executable code None - no template engine, no scripting, no eval-style configuration. All admin inputs are typed (status pickers, calendar selectors, JQL filters) and validated server-side

Other JiBrok Cloud apps. JiBrok’s other published Forge apps - JiBrok Studio for Jira Cloud and Message Field for Jira Cloud - inherit the same platform-level guarantees (tenant isolation, no external infrastructure, declarative permissions, single sub-processor) and are documented separately. The Forge builds of Timer field, Stopwatch field, Time between dates, Display Linked Issues, Fields panel for JSM and Calculated fields (JBCF) are also published on the Atlassian Marketplace, inherit the same platform-level guarantees and are covered by the DPA - JiBrok Cloud Apps (Atlassian Forge); Calculated fields (JBCF) has its own security reference. The Atlassian Connect builds of JiBrok’s Cloud apps run on JiBrok-operated infrastructure and are covered by the DPA - JiBrok Connect Apps. JiBrok maintains SOC 2 Type II certification for its organizational controls; evidence may be shared under NDA where appropriate.


Threat model

The table below enumerates the principal threats relevant to a Forge app of this class and the controls that mitigate them.

Threat Mitigation Reference
Cross-tenant data leak Forge per-installation runtime, per-installation Forge SQL and KV; no shared memory, queues, or filesystem between tenants Atlassian Forge - Tenancy
Sandbox escape via user-supplied code Not applicable - the app does not expose a template engine, scripting interface, or any other user-supplied executable code path. All configuration inputs are typed and validated Architectural foundation
Resource exhaustion via recalculation queue Bulk recalculation is processed by the tis-async-consumer queue with a 180-second per-message Forge timeout; messages that hit the timeout are retried per platform retry policy. Admins can cancel running recalculations Recalculation playbook
JQL injection via configuration filters Admin-supplied JQL filters are stored as opaque strings and validated by Jira’s own JQL parser when executed; the app does not concatenate JQL fragments from untrusted sources Custom Events
Unauthorized read of issue data via app identity All Jira reads execute as the app, not as a user. Read access is therefore wider than any individual user’s. The app does not surface the raw read data to users; calculated values are written into Jira custom fields where Jira’s native Browse Project permission applies on viewing Permissions - How the app reads issue data
Unauthorized configuration change via non-admin user Admin page is gated by the Forge user_is_admin condition at the platform layer; every mutating resolver call performs a server-side admin re-check; resolvers take project, field and context identifiers from the Forge request context rather than from client-supplied payload Source review under NDA (see Verification and evidence)
Data exfiltration via outbound HTTP Manifest declares no external: permissions and no remotes. The app cannot call arbitrary hosts. The only endpoint outside the Customer’s Jira site is Atlassian’s Personal Data Reporting API, called weekly with the stored account IDs under the report:personal-data scope Architectural foundation
Issue mutation by app on behalf of attacker The app declares write:jira-work only to update its own custom field values on issues. Server-side resolver code restricts writes to the five app-owned custom field types (Time in Status, Stopwatch, Timer, Time Between Dates, Calendar Select). The app does not create, transition, link, or delete issues, and does not post comments Permissions - Issue Data
Project property tampering manage:jira-project is used solely to write the tis-cloud-panels project property that controls panel visibility. Server-side admin guards restrict writes to admins; project admins cannot modify the property through the app Permissions - Jira Administration
Comment scraping The app reads comments only when a Stopwatch event is configured to fire on avi:jira:created:comment. The handler reads the comment body to evaluate the event condition; comment content is not persisted in Forge SQL or KV Stopwatch field settings
Migration data leak across customers Data Center migration uploads arrive scoped to a single Customer / Forge installation; the consumer writes to that installation’s Forge SQL only. Cross-tenant exposure is prevented at the Forge platform layer Migration specifics
Compromised Marketplace publication chain Releases are published only through Atlassian Marketplace with automated security scanning; declared permissions cannot expand without a new release approved by the site administrator Atlassian Marketplace - App review
Personal data over-collection Manifest scopes are minimum necessary; the only personal identifiers persisted are account IDs of two kinds - the administrator who started a bulk recalculation (kept with that job record for 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 are reported weekly through Personal Data Reporting and removed when Atlassian reports the account closed; configuration items carry no creator or updater attribution, but conditions may contain account IDs the administrator chose; PII redaction (accountId, email, display name, JWT patterns) in diagnostic logs DPA Annex 1.C, DPA Annex 2
CSP weakening via unsafe-inline styles The directive applies only to the admin-page Custom UI iframe to permit Atlaskit inline styles. It does not relax CSP for the issue-panel or field-context-config UI Kit components, does not enable script execution, and does not affect network egress CSP relaxation note

Scope to data category mapping

The 11 declared scopes map to four data classes for DPIA purposes. The classification is based on what the scope exposes by design - not what an individual customer’s instance happens to contain.

Data class Definition
Personal Data Identifies a natural person directly (account ID, display name) or by combination
Business metadata Jira issue, project, status, changelog, comment data created by the customer
Configuration Customer-controlled Jira administrative configuration (fields, field configurations, contexts, project properties)
System internal The app’s own runtime state (KV, SQL bookkeeping, JCMA migration progress)

Mapping by category

Category Scopes Data class Notes
App Internal storage:app System internal App-owned KV storage for admin-page state, scheduled-job bookkeeping, JCMA migration progress
App Internal write:app-data:jira Business metadata + Personal Data when issues reference users Used to publish calculated metric values back to issues as the app’s own custom field values. The custom field values are derived metrics and references to status names; the app does not persist arbitrary issue content this way
Compliance report:personal-data Personal Data The stored account IDs (recalculation-job initiators and people picked in Count only while conditions), submitted weekly to the Atlassian Personal Data Reporting API
Issue Data read:jira-work Business metadata + Personal Data when the changelog or comment authors are read Reads issue changelog (status transitions), field values, comments. Executes as the app, not impersonated. Read content is consumed transiently for calculation; only derived metric values are persisted
Issue Data write:jira-work Business metadata Writes app-owned custom field values on issues. Server-side resolver code restricts writes to the five app-owned custom field types. Does not create / transition / link / delete issues; does not post comments
Field & Screen Configuration read:field:jira, read:field-configuration:jira, read:custom-field-contextual-configuration:jira, read:field.option:jira Configuration Read-only access to Jira’s field catalog, field-configurations, per-context configuration of the app’s own custom fields, and select-field options offered in Count only while conditions
Users read:jira-user Personal Data Read-only. Display names for the Activity panel’s Download CSV files and the people picker in Count only while conditions, and the site’s time zone (the default user time zone) for the day boundaries of 24x7 counting. E-mail addresses are not read
Jira Administration manage:jira-project Configuration Used to write the tis-cloud-panels project property that controls panel visibility

For per-scope detail, see the Permissions Reference. For the legal classification of personal data, see DPA Annex 1.C.


Data flow

All Time in Status (Forge) data resides inside Atlassian Forge. The diagram below shows where each data class is stored and how it leaves the perimeter (it does not, except for the weekly Atlassian Personal Data Reporting submission).

                   +------------------------------+
                   |  Customer Jira Cloud site    |
                   |  (per-installation Forge)    |
                   |                              |
   Admin UI <----> |  TIS resolver + admin-guard  |
   Issue panels -> |  (issue-panel, sw-panel,     |
   Custom fields > |   tmr-panel, activity-panel) |
                   |          |                   |
                   |  Event   |  Scheduled        |
                   |  triggers|  triggers         |
                   |  (issue, |  (5-min, hourly,  |
                   |  comment,|   weekly)         |
                   |  field-  |                   |
                   |  context)|                   |
                   |          v                   |
                   |  Async / Event / migration   |
                   |  consumer queues             |
                   |          |                   |
                   |          v                   |
                   |  Forge SQL (MySQL)           |
                   |  + Forge KV (storage:app)    |
                   |  + Jira custom fields        |
                   |  + Jira project properties   |
                   |    (`tis-cloud-panels`)      |
                   +------------------------------+
                              |
                              | weekly account-ID
                              | report
                              v
                   +------------------------------+
                   |  Atlassian Personal Data     |
                   |  Reporting API               |
                   |  (account ID only)           |
                   +------------------------------+

Forge SQL

Time in Status (Forge) uses Forge SQL (MySQL) for structured persistent state. The data falls into the following groups:

Group Purpose Retention
Field setting configurations Per-context configuration for Time in Status, Stopwatch, Timer, Time Between Dates, Calendar Select field types - which statuses to count, Count only while conditions (may contain account IDs of people picked on user fields), which events trigger start / pause / stop, goal times, calendar references, JQL filters Until deleted by admin; an account ID in a condition is removed when Atlassian reports the account closed
Calculated metric values Per-issue per-context calculated values (time spent in status, stopwatch state, timer countdown, time-between-dates intervals) used to populate the app’s own custom fields and to render issue panels Until issue or context deleted
Status transition cache Cached per-issue changelog summary for Time in Status fields, used to avoid repeated full-changelog reads on every event tick. Stopwatch, Timer and Time Between Dates values do not use it Refreshed on issue update events; removed when the issue is deleted, and removed hourly once it has not been refreshed for 30 days
Work calendars Customer-defined calendars (business hours, breaks, holidays, time zones, repeating patterns); built-in 24x7 calendar always available Until deleted by admin
Custom events Customer-defined named rules that fire when a specific field value changes Until deleted by admin
Activity panel configurations Per-project activity panel settings (R1 - Time in Status, R2 - Transition History, R3 - Time by Assignee) Until deleted by admin
Recalculation jobs Bulk recalculation job records: scope, status, progress, error counts, initiator account ID Deleted 30 days after completion, with expired records removed hourly
JCMA migration state Per-installation progress of a Data Center to Cloud migration delivered by Atlassian’s Jira Cloud Migration Assistant Until the migration completes

All tables are isolated per Forge installation by Forge SQL’s per-installation database scoping.

Forge KV (storage:app)

Key family Purpose
Admin-page bookkeeping Lightweight state for admin tabs, last-viewed selections
Scheduled-job state Cursor / progress markers for the 5-minute, hourly and weekly scheduled triggers
Migration counters Lightweight counters used during a Data Center migration for progress reporting

Jira custom field values (write:app-data:jira + write:jira-work)

The app publishes computed metric values back to issues as the values of its own custom fields:

  • Time in Status (tis-custom-field)
  • Stopwatch (sw-custom-field)
  • Timer (tmr-custom-field)
  • Time Between Dates (tbd-custom-field)
  • Calendar Select (cal-custom-field)

These values are derived metrics (durations, state strings, timestamps). They are scoped to projects and issue types where the field has a Jira field-context. End users see them via the standard Jira issue view; Jira’s native Browse Project permission applies.

Jira project properties (manage:jira-project)

The app writes a single project property: tis-cloud-panels. The property’s payload encodes which panel modules (tis, sw, tmr, act) are enabled in that project. Forge displayConditions on the issue panel modules evaluate this property at the platform layer to decide whether to render the panel. Only admins can write this property through the app.

Outbound

The only outbound HTTP call from the app is to the Atlassian Personal Data Reporting API:

  • Endpoint: https://api.atlassian.com/app/report-accounts/
  • Frequency: weekly scheduled trigger (personal-data-report)
  • Payload: the account IDs stored on recalculation-job records and in Count only while conditions of field settings, with their last-updated timestamps; each account ID is sent once
  • Purpose: required by Atlassian’s privacy compliance framework so account closures and updates are propagated back to the app

No customer data, configurations, calculated values, or business metadata leaves Atlassian Forge.

See DPA section 5.2.

Event-driven processing

The app reacts to the following Forge events:

Event Trigger Handler What it does
avi:forge:installed:app Install tis-on-install -> migration-handler Initialise SQL schema and KV state
avi:forge:upgraded:app Upgrade tis-on-upgrade -> migration-handler Apply forward-compatible SQL migrations
avi:jira:created:issue Issue created tis-issue-created -> event-handler Initialise per-issue state for tracked field-contexts
avi:jira:updated:issue Issue updated (status, assignee, etc.) tis-issue-updated -> event-handler Recompute affected metrics, update calculated values
avi:jira:deleted:issue Issue deleted tis-issue-deleted -> event-handler Mark the project’s report aggregates stale and remove the issue’s status transition cache
avi:jira:created:comment Comment created sw-comment-created -> event-handler Evaluate comment-based Stopwatch and Timer event triggers
avi:jira:updated:comment Comment updated sw-comment-created -> event-handler Re-evaluate comment-based Stopwatch and Timer event triggers
avi:jira:deleted:comment Comment deleted sw-comment-created -> event-handler Re-evaluate comment-based Stopwatch and Timer event triggers
avi:jira:created:field:context Field-context added tis-field-context-created -> ctx-event-handler Add the new context to the app’s processing scope
avi:jira:updated:field:context Field-context modified tis-field-context-updated -> ctx-event-handler Update processing scope
avi:jira:deleted:field:context Field-context removed tis-field-context-deleted -> ctx-event-handler Remove the context from the app’s processing scope
avi:ecosystem.migration:uploaded:app_data Data Center migration upload (JCMA) jcma-app-data-uploaded -> jcma-migration-handler Queue the uploaded Data Center configuration for background import

All event handlers respect Forge platform retry semantics and have ignoreSelf: true to avoid loops on the app’s own writes.

Scheduled triggers

Three Forge scheduledTrigger modules are registered:

Trigger Cadence What it does
tis-five-minute -> five-minute-handler Every 5 minutes Incremental recalculation, queue-depth checks, in-flight-job watchdog
tis-hourly -> hourly-handler Hourly Housekeeping: prunes expired recalculation-job records, refreshes monitoring snapshots
personal-data-report -> personalDataReportFn Weekly Atlassian Personal Data Reporting cycle: submits the stored account IDs and applies the erase and refresh actions Atlassian returns

All three run as the app (no impersonation) and have fixed implementations. They cannot be reconfigured at runtime; an admin cannot inject custom logic into them.


GDPR and data subject rights

Roles and sub-processors

Role Party Reference
Controller Customer DPA section 2.1
Processor JiBrok DPA section 2.2
Sub-processor Atlassian (Forge platform) - sole sub-processor DPA Annex 3

Categories of personal data

Three categories, defined in DPA Annex 1.C:

  1. Atlassian accountId - stored in two places: as the initiator of a bulk recalculation job, together with that job record and retained for 30 days; and as a value of Count only while conditions on user fields, in the field setting, until an administrator changes the condition. Configuration items carry no creator or updater attribution.
  2. App configurations - account IDs an administrator picks in Count only while conditions (see item 1), free-text fields in field-setting names and descriptions, work-calendar names and definitions, JQL filters, custom-event trigger definitions, and panel settings. Customer-controlled inputs; the customer determines whether any personal data is entered.
  3. Calculated metric values - duration metrics, state strings, and timestamps written into the app’s own custom field values. May contain references to status names and workflow timestamps derived from the customer’s configuration.

The app reads Jira issue data (changelog, statuses, assignees, comment bodies for Stopwatch comment-events) to compute metrics but does not persistently store full Jira issue content. Jira data is fetched transiently and discarded after the calculation completes.

Data subject request handling

Time in Status (Forge) implements Atlassian’s Personal Data Reporting and erasure workflow. Atlassian’s central pipeline is the canonical source for closure and update notifications.

Right Mechanism
Right to be forgotten (Art. 17) When the Personal Data Reporting API reports an account ID as closed, the app replaces that account ID on its recalculation-job records with an anonymized placeholder and removes it from the Count only while conditions of every field setting; a condition or group left empty is removed entirely. The field is not recalculated automatically; Health Check marks it so an administrator can review the condition. The record of the erase keeps no account ID - only the setting, the fields and the time of the erase
Right to rectification (Art. 16) When the API reports an account ID as updated, the app refreshes the last-updated timestamp it holds for that account ID
Right of access (Art. 15) Handled on the Customer’s documented instruction via privacy@jibrok.com (DPA section 8.1); the data held per account ID is the initiator reference on recalculation-job records and its occurrences in Count only while conditions of field settings
Right to data portability (Art. 20) Configurations are exportable as JSON via Import / export configurations; JiBrok provides the remaining categories on the Customer’s instruction (DPA section 8.1)
Right to restriction (Art. 18) The app supports per-field-context disablement, per-project panel-visibility controls, and full app uninstall, all controlled by site admins

Retention

Per DPA Annex 1.G: configurations, calendars, custom events, panel settings, and calculated values persist while the app is installed. Recalculation job records are deleted 30 days after completion, with expired records removed hourly; the status transition cache is refreshed on issue updates, removed with the issue, and removed hourly once it has not been refreshed for 30 days. Uninstalling the app triggers Forge-platform-managed deletion of all app-owned SQL and KV storage, and JiBrok additionally deletes app data on written request to privacy@jibrok.com. The app’s custom fields are removed from Jira together with the app, so the values stored in them are no longer available after uninstall.

PII redaction

Diagnostic logs are emitted only at the error level in production. A custom logging layer applies automated redaction to sensitive fields (accountId, email, display name, author / assignee / reporter identifiers, JWT patterns) before any log line is emitted. Debug and info levels are suppressed in production. See DPA Annex 2 and DPA Annex 1.E.


Compensating controls

Beyond the platform-level and architectural controls, customers can apply the following on the customer side. Each is documented in detail in the Admin Hardening Guide.

Control What it limits
Field-context scoping The app processes only the projects and issue types where its own custom fields are added in Jira’s field configuration; outside those contexts, the app does not read or write any data
Per-project panel visibility Issue panels (Time in Status, Stopwatch, Timer, Activity) render only in projects whose tis-cloud-panels property opts them in
Admin-only configuration Forge user_is_admin condition at the platform layer plus server-side admin guard on every mutating resolver call
Recalculation throttling and cancel Bulk recalculations are queued and bounded; admins can cancel a misconfigured job from the Recalculation tab
Configuration export for forensics Configurations are exportable as JSON for offline review and incident-response artifacts
App uninstall Standard Atlassian app uninstall removes all app-owned Forge SQL, KV, and custom field types per Forge platform behavior

Verification and evidence

Where to verify each claim:

Claim Where to verify
11 declared scopes The Marketplace listing’s installation prompt; the Permissions Reference; the manifest reviewed by Atlassian
SOC 2 Type II JiBrok maintains SOC 2 Type II certification for its organizational controls; evidence may be shared under NDA where appropriate - see Security and SOC Reports
CAIQ Lite Public PDF from Trust Center
GDPR DPA Public DPA - Time in Status (Forge)
Vulnerability disclosure policy Public Vulnerability Disclosure page
Forge platform guarantees Atlassian Forge documentation
Sub-processor list DPA Annex 3
Outbound network Manifest review (no external: block, no remotes); the single Atlassian endpoint used for personal-data reporting is listed under Data flow - Outbound
No impersonation Manifest review (no scope declared with allowImpersonation: true)
Restricted issue mutation surface Manifest declares write:jira-work; server-side resolver code restricts writes to the five app-owned custom fields; available for source review under NDA
Source code review (under NDA) Available for enterprise customers on request via security@jibrok.com

Contact

  • Security inquiries: security@jibrok.com
  • Privacy and DPO inquiries: privacy@jibrok.com
  • Vulnerability reports: see Vulnerability Disclosure

JiBrok is registered in the European Union (Republic of Cyprus). For legal entity details, see the Trust Center.