- What is Atlassian Forge?
- Tenant isolation
- Data residency and storage
- No external infrastructure
- Egress controls
- Scoped permissions
- Code review and updates
- Next steps
What is Atlassian Forge?
Atlassian Forge is Atlassian’s cloud-native app platform. Forge apps run inside Atlassian infrastructure - no external hosting, no vendor-managed servers, no companion services.
Key characteristics of the Forge platform:
| Property | Description |
|---|---|
| Serverless runtime | Functions execute on demand within Atlassian’s cloud, not on vendor-owned servers |
| Built-in storage | Forge KVS (key-value store) managed by Atlassian |
| Declarative permissions | All scopes declared upfront in manifest.yml and reviewed by Atlassian before each Marketplace release |
| Automatic updates | A single vendor deployment reaches every installation simultaneously |
| App review | Every app version passes Atlassian’s automated and human security review before it becomes available on the Marketplace |
Calculated Fields (Forge) for Jira Cloud is built entirely on Forge. There are no external servers, databases, companion apps, or third-party services involved. The Marketplace listing carries Atlassian’s Runs on Atlassian badge.
For a deeper view of the platform itself, see the official Forge security architecture documentation.
Tenant isolation
Each Jira site that installs JBCF Forge gets its own isolated Forge runtime. Every installation operates in a per-site isolated environment:
- Separate execution contexts - there is no shared memory, shared process, or shared filesystem between tenants.
- Scoped storage - the Forge KVS namespace is per-installation. One tenant cannot read or write another tenant’s data.
- Identity via platform context - all identity operations use Forge platform-guaranteed context. The app does not maintain its own session store.
- No shared state - there is no global variable, cache, or queue that spans multiple tenants.
Cross-tenant risk is architecturally eliminated - the platform itself enforces isolation boundaries, not the app code. JBCF Forge cannot accidentally expose data from one customer’s site to another, because there is no shared memory, process, or storage to leak through.
Data residency and storage
All JBCF Forge data is stored within Atlassian-managed infrastructure:
- Forge KVS - app settings (field bindings, per-context settings), service state, and ToDo templates. Encrypted at rest by the platform. Calculated values are not copied into KVS - they exist only as the value of the Jira field.
- No vendor database - there is no Amazon RDS, S3 bucket, MongoDB, or any third-party data store.
- Atlassian data residency - your data is subject to the same data residency policies as your Jira Cloud site. If your Jira site is pinned to a specific Atlassian region (for example, EU or US), the Forge runtime and KVS for JBCF Forge run in that region.
Field configuration, calculated values, and all associated metadata never leave Atlassian’s infrastructure.
No external infrastructure
JBCF Forge operates with zero external infrastructure:
- No vendor-hosted servers
- No companion apps or satellite services
- No proxy servers or API gateways
- No third-party monitoring, logging, or analytics services
The app manifest does not declare external: permissions and does not register any Forge Remotes - there are no outbound HTTP requests from the app to any non-Atlassian URL. Network communication is requestJira() (the standard Forge mechanism), routed through the Forge proxy to the Jira REST API of the current site only, plus Atlassian’s own Personal Data Reporting API.
What this eliminates
| Threat | Status |
|---|---|
| Server-side compromise | No vendor server to compromise |
| SSRF (Server-Side Request Forgery) | No outbound HTTP client; no external: permissions |
| Data exfiltration via callbacks | The app cannot call non-Atlassian URLs |
| DNS-based attacks | No DNS resolution from app code |
| Supply chain attacks on vendor infrastructure | No vendor infrastructure dependencies |
| DDoS attack surface | No public-facing vendor endpoints |
Egress controls
Forge blocks outbound network requests by default. JBCF Forge does not override this:
- The manifest does not declare any
external:permissions. - The manifest does not register any Forge Remotes.
- The runtime cannot call
fetch(),XMLHttpRequest, or any HTTP client to a non-Atlassian endpoint. - The only network access is
requestJira(), which is routed through the Forge proxy to the Jira REST API of the current site only, and the Atlassian Personal Data Reporting API, which the app calls on a weekly schedule to report the account identifiers it stores (see Security overview - Personal data). Both endpoints are Atlassian’s own.
The app also exposes two Forge apiRoute REST endpoints (GET / PUT /todo/items) through which customer scripts and integrations read and replace ToDo List items (ToDo List REST API). They are hosted and authenticated by Forge, reachable only through the Atlassian platform, and guarded by app-specific custom scopes - they are not a vendor-operated endpoint on the public internet.
There is no way to exfiltrate data to external URLs, set up callback endpoints to a third party, or perform SSRF attacks from inside JBCF Forge.
Scoped permissions
JBCF Forge uses a declarative permission model:
- All permissions are declared upfront in
manifest.ymland reviewed by Atlassian before each Marketplace release. - 12 granular Jira and platform scopes, plus 2 app-specific custom scopes on the app’s own REST endpoints. Two of them are Jira write scopes -
write:app-data:jira, which covers the values of the app’s own custom fields, andwrite:custom-field-contextual-configuration:jira, which covers the contextual configuration of the app’s own fields (written when settings are migrated from Data Center). There is no “full access” permission, nomanage:*, and nodelete:*. The per-scope rationale is in Security overview - Why these permissions. asApp()execution - calculation and background work run under the app’s own Forge identity, scoped strictly to the declared scopes.- No cross-site data sharing - each Jira site’s data is completely isolated.
If the vendor wanted to add a new scope, Atlassian would re-review the listing and the admin who upgrades the app would be prompted to grant the new scope explicitly.
Code review and updates
Marketplace review
Every release of JBCF Forge passes Atlassian’s automated and human security review before becoming available on the Marketplace. The review covers:
- Declared scopes (ensures the manifest matches the listing)
- Static analysis of the app bundle
- Manual review for sensitive scope combinations and known anti-patterns
- Verification that the app does not register external endpoints or declare
external:permissions inappropriately
Single-deployment updates
Forge apps use a single-deployment model:
- One vendor deployment automatically becomes available to all installations.
- Minor and patch versions deploy without admin action. Major versions that introduce new scopes prompt the admin for explicit consent on next visit.
- No version fragmentation across sites.
- Security patches reach every installation simultaneously, not on a per-customer upgrade schedule.
Next steps
- Security overview - Per-scope rationale, storage, monitoring, and data residency.
- Security reference for auditors - Vendor info, threat model, RFI-ready answers.
- Trust Center - SOC 2, GDPR, certifications.
- Atlassian Forge security architecture - Platform documentation from Atlassian.
- Field reference - The calculated fields, the ToDo List field, and their data types.

