Skip to content

How it works: data, storage & security

How Connected Table works under the hood — written for IT, security reviewers, and technical administrators evaluating the app.

Built entirely on Atlassian Forge

Connected Table is a Forge app. It runs inside Atlassian’s own cloud infrastructure — there is no external server, no third-party hosting, and no separate database. The app’s code executes on Atlassian-managed infrastructure and in your browser; nothing is deployed to or operated by the vendor outside Atlassian’s cloud.

Where your data is stored

Each table is stored in the Jira issue’s own field value (and, on Jira Service Management, in the portal request). It lives with the issue, inside your Jira instance, and is backed up, exported, and access-controlled exactly like any other Jira field data.

  • No external or vendor-side data store is involved.
  • If you use the Write API, its API token hashes and the log of recent API calls are stored as the app’s own data in your Jira site (Jira app properties), next to the app’s other settings.
  • The table travels with the issue (clones, exports, and the issue’s own history include it).
  • Because the whole table is held in one field value, there’s a practical size ceiling of roughly 100–150 rows per table (depending on the number of columns and how much text each cell holds).

What the app can access

At install, Connected Table requests a small, mostly read-only set of permissions. In plain terms:

PermissionScopeWhy it’s needed
Read Jira workread:jira-workTo read the table from an issue and build the Connected Table History tab from the issue’s change log.
Read Jira usersread:jira-userTo power the user-picker column and show people’s names in the table and its history.
Read field configurationread:field:jiraTo find the Connected Table field’s contexts.
Read custom field context configurationread:custom-field-contextual-configuration:jiraTo load the column setup an administrator saved for each field context.
Write app datawrite:app-data:jiraTo save table edits into the app’s own Connected Table field. It can’t change any other issue field.

The app does not request permission to edit issues in general, to manage Jira configuration, or to use app storage, and it accesses only Jira/JSM data granted at install — nothing outside your Atlassian environment.

Saves are made by the app on the user’s behalf, and only after the app checks the user’s own Jira permissions: Edit issues for agents on the issue panel, and access to the request for customers on the portal. Writes through the Write API are authorised by an administrator-issued API token instead — see below.

How it’s processed

The interactive grid and all in-table computation (formulas, aggregation, sequence numbering) run in your browser. There is no external computation service; formula evaluation is sandboxed client-side.

Export and import files

  • Export (Excel, PDF, Word, CSV) builds the file in the user’s browser from the table on screen and saves it directly to their device. The file isn’t stored in Jira or anywhere else, and no copy is sent to the vendor.
  • Import (CSV, Excel) reads the chosen file in the user’s browser. The file is never uploaded. Only the rows the user reviews and saves are written to the issue’s field — through the same save path, permission checks and validation as typing them in by hand.
  • Text beginning with =, +, - or @ is neutralised in CSV and Excel exports, so data entered in the table (for example by a portal customer) can’t run as a spreadsheet formula when someone opens the file.
  • Neither feature needs extra permissions. Administrators can turn each one off per field.

Write API

The Write API lets scripts and integrations write tables over HTTPS. It is part of the app itself — an Atlassian-hosted Forge endpoint — not a separate service.

  • Inbound only. Requests come into the app; the app makes no outbound calls and the endpoint can only return fixed status messages, so it can’t be used to read tables, issues or any other data.
  • Token authentication. Every request must carry an API token created by a Jira administrator on the app’s admin page. Tokens are high-entropy random secrets; only a one-way SHA-256 hash is stored, in your Jira site’s app data. The plain token is shown once and never stored. Revoking a token takes effect immediately.
  • Administrator control. Only Jira administrators can see the endpoint, create or revoke tokens, and read the call log. The app checks the administrator permission on every one of these actions.
  • What a token can do. Write the Connected Table field on any issue on the site — the write is made by the app, so the caller’s own Jira permissions don’t apply. It can’t change any other field and can’t read data.
  • Same validation as the UI. Every request is validated against the table’s columns, options, required columns and size limit before anything is saved; an invalid request saves nothing.
  • Audit trail. API writes appear in the issue’s history like any other edit, and the Connected Table History tab shows the administrator who created the token, marked via API. The admin page keeps a log of the last 25 calls (time, token name, issue, result and validation details).
  • No new permissions. The Write API uses the same scopes listed above.

Where the table appears

SurfaceBehaviour
Issue view — field cellClick to edit inline.
Issue view — Apps panelAlways-on grid in the main content area (read-only → Edit → Save).
Activity — Connected Table History tabRead-only, row/cell-level change log built from Jira’s own history.
JSM customer portal — request detailRead/edit panel for customers and unlicensed users.

Change history & auditability

Every edit to a table is captured in Jira’s own issue history, and surfaced as a readable row/cell-level diff in the Connected Table History activity tab. Nothing is stored outside Jira to make this work.

Updates

The app is delivered and updated through the Atlassian Marketplace / Forge app lifecycle. Administrators review and approve any permission changes as part of the standard upgrade flow.