- Overview
- Getting started
- User guide
- Admin guide
- Requester and owner guide
- Permissions and security
- Privacy and data
- Large sites
- Troubleshooting
- FAQ
- Known limitations
- Changelog
Permissions and security
The seven permissions (scopes), in plain words
| Scope | What Project Blueprints uses it for | Read / write |
|---|---|---|
read:jira-work | Search and read projects; read permission, notification and issue security scheme associations; check keys and names; read fields, roles, components, versions, properties and categories; check users' permissions; receive project events | read |
manage:jira-configuration | Create projects with their scheme associations; add role members; assign field contexts; read workflow, work type, work type screen and field scheme associations and field-context mappings; look up the app's own global permission; read the audit log to find who created a project outside the gate | read + write |
manage:jira-project | Create components and versions; write project properties; remove default role members on a new project in exact role mode | write |
read:jira-user | Show people's names when a page is shown (names are never stored); user and group pickers; group membership for blueprint eligibility; whether an account is active | read |
storage:app | Store blueprints, policies, requests, steps, the catalog, reviews and the ledger in Forge hosted storage | app storage |
report:personal-data | Report stored account IDs to Atlassian weekly so closed accounts are erased | — |
write:jira-work | Only the optional tracking work items and their comments, and the optional review reminder work items, in the one tracking project an admin chose. The app never edits existing work items | write |
Project Blueprints asks for no board scopes, no webhook scope, and no Confluence, Jira Service Management or Assets scopes.
What the app user can do — stated plainly
With manage:jira-configuration and manage:jira-project, Jira gives the Project Blueprints app user Jira-admin-equivalent permissions. In a live check it held Administer Jira, Administer projects and Bulk change. This is necessary: creating a company-managed project requires Administer Jira, and Jira offers no narrower scope. Jira's global permission settings can't narrow the app user's own power.
Project Blueprints limits what it does with that power. A new project is created only when all of these hold:
- a Jira admin opened requests (off by default);
- a Jira admin granted Request projects (Project Blueprints) to the requester's group (granted to nobody on install);
- the request uses a blueprint a Jira admin activated, and, if the blueprint is limited to certain groups, the requester is in one of them;
- a current Jira admin approved the exact preview (optionally a second, different admin), and confirmed the lead if the lead isn't the requester;
- the requester didn't approve their own request (unless self-approval is enabled by typed confirmation, or it is the one-time guided test);
- nothing changed since the preview, every approver still holds Administer Jira right before the first write, the kill switch is off and the licence is active.
The one-time guided test is the only exception to the first three conditions: a Jira admin starts it from a captured blueprint. It still needs an approval and every check before the first write.
Every request, approval, provisioning run and settings change is recorded in the hash-chained ledger. The app has no web triggers and sends no data outside Atlassian.
Four-eyes approval protects against mistakes. It is not a control against a malicious Jira administrator: any Jira admin can enable self-approval or delete all app data. Both need a typed confirmation. Enabling self-approval is recorded in the ledger; Delete all app data removes the ledger itself, so export it first if you need it as evidence.
Who can do what
| Who | Checked how |
|---|---|
| Admin pages and actions | Administer Jira. Read views, the Get started checklist and starting a catalog rescan or reconcile use a check cached for at most 5 minutes; every other admin action that changes something (approvals, rejections, stops, retries, redaction, blueprints, policies, settings, kill switch, catalog bulk actions, owner changes, Delete all app data) checks it fresh |
| Approving | Administer Jira, checked fresh at the moment of approval, and again for every approver before the first write |
| Requesting | Request projects (Project Blueprints), requests open, and the blueprint's allowed groups. The form caches the check for 5 minutes and checks again on submit |
| My requests, My projects | Only your own requests and the projects you own |
| Governance page | Administer projects on that project |
| User pickers | Jira's Browse users and groups permission |
How permission checks work
Project Blueprints checks people's permissions as the app, using Jira's permission-check API for the signed-in user. The user's account ID comes from the Forge platform, never from the browser. Because of this, requesters and owners don't see Atlassian's "Allow access" consent screen in the normal flow.
- Fail closed: an empty or unclear answer means "not permitted".
- Fallback: if Jira's permission-check API itself fails (for example an authorisation or server error), the admin, approval and requester checks fall back to asking Jira as the user. That may show Atlassian's one-time "Allow access" screen to that user. Health → Permission checks then shows "Fallback in use: Yes".
- Background work never falls back: if the provisioning job can't confirm an approver's permission, it creates nothing and retries; if the permission still can't be confirmed when the approval is 24 hours old, the request becomes Blocked and the page explains the remedy.
What the app writes, and where
Project Blueprints writes to Jira only:
- into projects it creates under an approved request (the project, role members, components, versions, field-context assignments, selected properties, and its own properties
com.matify.pbj.provenanceandcom.matify.pbj.governance); - into its own property
com.matify.pbj.governanceon existing projects, to record owners, review dates and reviews (catalog bulk actions, owner reviews, confirmed owner changes) and to restore those values when the property was changed outside the app; and into its own properties when a closed account's data is scrubbed or an admin redacts a request's free text; - work items and comments in the one tracking project an admin chose.
It never deletes, trashes, archives or renames anything in Jira, and never copies, edits or deletes schemes. The only removal it ever makes is of default role members on a project it has just created, in exact role mode; the preview shows this removal step (which members Jira added is known only after the project exists).
The app's project properties are visible. Like all Jira project properties, com.matify.pbj.provenance (request and blueprint IDs, requester and approver account IDs, times) and com.matify.pbj.governance (owner account ID, review dates, metadata values) can be read through Jira's REST API by everyone with Browse Projects on the project, and changed by its project admins. Don't ask for confidential data in metadata fields. The app doesn't trust these properties: it reads governance values only when it first sees a project, rewrites owner and review values that were changed outside the app from its catalog, and takes provenance from its own stored request (once retention has pruned that record, from the property, and only if it names the same request).
The write-path contract
All of the app's non-read calls to Jira live in one module. Each call needs a "ticket":
- a provisioning ticket, minted only from a stored, approved request whose pre-check passed, and limited to that request's project;
- an adopt ticket, limited to writing
com.matify.pbj.governance; - a tracking ticket, limited to creating work items and comments in the tracking project;
- a privacy-scrub ticket, limited to the app's own properties.
An automated test that runs on every build fails if any other code path writes to Jira.
How projects appear in Jira's audit log
Project Blueprints creates projects in the background as the app, so Jira's audit log names the app as the creator. The people are recorded by the app: the ledger records the requester and every approver, and the project property com.matify.pbj.provenance stores requester, approvers and timestamps. The project's Governance page and the evidence report show them.
Platform and architecture
- Forge only. Project Blueprints runs entirely on Atlassian's Forge platform: Atlassian-hosted functions and Forge hosted storage. Matify runs no servers or databases and has no access to your data.
- No egress. No external domains, no remote back end, no web triggers, no analytics, telemetry or error-reporting service. All interface assets are bundled with the app; exports are built in your browser.
- Tenant isolation. Forge hosted storage is separate for each installation.
- Data residency. Stored data follows your Jira site's data residency.
- Encryption is provided by Atlassian's Forge platform; Matify adds none of its own.
Application security
- Every request from the app's pages is validated on the server against a strict schema. The browser never calls Jira directly.
- Text people type is shown as text, never as HTML. CSV exports neutralise cells a spreadsheet would run as a formula.
- Regular expressions in naming policies and metadata forms are length-limited and, when saved, refused if their worst-case backtracking on a 255-character value exceeds a fixed budget. A stored pattern that fails this check is never run; nothing passes it until an admin updates it.
- Forge logs contain event names, IDs (for example of requests, jobs and projects), counts, error codes, HTTP status codes and a random reference for support. They contain no account IDs, names, project names, purposes or metadata values.
- No credentials, API tokens or secrets are collected or stored.
No compliance certification is claimed for Project Blueprints or Matify.
Reporting a security issue
Email support@matifyapps.de with "security" in the subject. Please don't open a public issue. See the Matify SLA for response times.
More detail: Data security and privacy statement.