- How to read this
- Architectural foundation
- Threat model
- Scope to data category mapping
- Data flow
- GDPR and data subject rights
- Compensating controls
- Verification and evidence
- Contact
- Related documents
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:
- 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. - 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.
- 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.
Related documents
- Permissions Reference - Every OAuth scope explained
- Admin Hardening Guide - Production checklist
- Admin panel overview - Admin UI reference
- Migration to Time in Status (Forge) - Migration routes from Data Center and Connect
- Trust Center - SOC 2, GDPR, certifications
- DPA - Time in Status (Forge) - Data Processing Agreement
- Atlassian Forge documentation - Platform-level architecture

