Matify/Project Blueprints for Jira

Permissions and security

The seven permissions (scopes), in plain words

ScopeWhat Project Blueprints uses it forRead / write
read:jira-workSearch 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 eventsread
manage:jira-configurationCreate 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 gateread + write
manage:jira-projectCreate components and versions; write project properties; remove default role members on a new project in exact role modewrite
read:jira-userShow 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 activeread
storage:appStore blueprints, policies, requests, steps, the catalog, reviews and the ledger in Forge hosted storageapp storage
report:personal-dataReport stored account IDs to Atlassian weekly so closed accounts are erased—
write:jira-workOnly 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 itemswrite

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:

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

WhoChecked how
Admin pages and actionsAdminister 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
ApprovingAdminister Jira, checked fresh at the moment of approval, and again for every approver before the first write
RequestingRequest 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 projectsOnly your own requests and the projects you own
Governance pageAdminister projects on that project
User pickersJira'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.

What the app writes, and where

Project Blueprints writes to Jira only:

  1. 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.provenance and com.matify.pbj.governance);
  2. into its own property com.matify.pbj.governance on 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;
  3. 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":

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

Application security

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.