Blog /
Product

Jira admin's guide to Plane: Schemes, workflows and PQL

Understanding Plane through the workflows, roles, and controls Jira admins already know

Sneha Kanojia
●
20 Nov, 2026
Cover image illustration for the blog post titled "Jira admin guide to Plane"

Introduction

Once Jira Data Center work is running in Plane, administrators still own the same jobs: deciding who sees what, keeping Bug definitions consistent across teams, enforcing QA workflows, and rebuilding the reports engineering leads depend on. What changes is where that configuration lives and how far one change reaches. In Jira, you maintain a scheme for every project. In Plane, you set the standard once for the workspace, and projects pick from what you allow.

This guide follows two engineering projects, Web Platform and Mobile App, through their first weeks of administration in Plane, access, work item types and fields, workflows, reporting and governance.

Jira administration in Plane at a glance

Jira concept
Plane equivalent
Plan

Permission schemes and project roles

Workspace and project roles; custom roles built from reusable permission groups (Granular Access Control)

System roles on every plan; custom roles on Enterprise Grid

Issue security schemes

Work item security with audiences

Enterprise Grid

Issue types, field configurations and field contexts

Project work item types; workspace work item types with property contexts

Project types from Pro; workspace types and contexts on Enterprise Grid

Workflow schemes

Workflows, transitions and who can move work

Business

Conditions, validators and post-functions

Approvals, pre-validation and post-action scripts, workflows per work item type

Enterprise Grid

Shared schemes across projects

Workspace governance with Any, Constrained and Required rules

Enterprise Grid

JQL filters

PQL and workspace views

Pro and above

Dashboards and filter subscriptions

Dashboards with PDF export; sharing and public links

Dashboards from Pro; sharing and public links on Enterprise Grid

Audit log

Workspace and project audit logs

Enterprise Grid

The rest of this guide focuses on how each piece works, so it doesn't repeat the plan for every feature. Use this table as the reference. If you're still preparing the move, our complete Jira-to-Plane migration guide walks through importing existing work and mapping Jira configurations.

How do Jira permission schemes translate into Plane's access model?

Jira Data Center administrators associate permission schemes with projects, defining what users, groups and project roles can do. Plane manages access through workspace and project roles, and Granular Access Control builds custom roles from reusable permission groups. The shift that matters is where access comes from: a user's effective access in Plane can arrive through several paths at once, and a project role is only one of them.

Managing access to projects and work items

Consider Web Platform, a private engineering project where QA reviewers need access to Bugs while unrelated workspace members stay outside the project.

In Plane, effective access comes from four places:

  • Workspace roles: Workspace Owners and Admins have access to project resources, including projects they haven't explicitly joined, and that inherited access stays in place even when a restrictive project role is assigned.
  • Project roles: These decide which actions directly assigned members can perform within a project.
  • Teamspaces: Members receive Contributor access to projects linked to their Teamspace, even without direct project membership, and a restrictive direct project role leaves that access in place.
  • Work item security: Audiences restrict who can see sensitive work items within a project.

For Web Platform, workspace roles live under Workspace Settings → Members, while direct assignments and linked Teamspaces sit under Project Settings → Members. The Teamspace path is the one that surprises Jira admins most: removing a user from a project's member list leaves their Teamspace-derived access intact for as long as they remain in a linked Teamspace.

Restricting sensitive work items within a project

Suppose Web Platform contains a security-sensitive Bug that only authorized reviewers should see. Work item security lets administrators define audiences made up of workspace roles, project roles or specific members, and attach them to individual work items or to a work item type.

A few rules decide who can see restricted information:

  • Workspace Owners and Admins always have access to restricted work items.
  • Assignees and subscribers can see restricted items, even when they sit outside the configured audience.
  • Project Admins get no automatic access through their project role alone.
  • Audiences assigned directly to a work item replace the audiences on its work item type. When several audiences apply at the same level, matching any one of them is enough.
  • Disabling an audience removes its restriction, subject to any other active audiences. If every item-level audience becomes inactive, the type-level audiences take over, and without any active restriction, normal project visibility applies.

Open a Work Item with an audience-based visibility restriction.

Show the Restricted work item banner or lock indicator, along with the audience assigned to that Work Item. The screen should clearly demonstrate that visibility is restricted to selected users or roles.

For a closer look at audience configuration, access exceptions, and visibility rules, see the work item security guide.

Standardizing permissions across multiple projects

The next requirement is a consistent set of QA permissions across Web Platform and Mobile App.

In Jira, administrators associate the same permission scheme with multiple projects. Plane works one level down: permission groups hold reusable grants, administrators attach those groups to custom roles, and the roles are assigned to members at the right scope.

For example, a Workspace Admin could create a custom project role called QA Reviewer with the permissions needed to inspect and comment on Bugs, leaving out project administration capabilities. The setup takes four steps:

  • Open Workspace Settings → Workspace roles and permission groups, and on the Permission groups tab, create a project permission group containing the required grants.
  • Under the Roles tab, create the custom project role QA Reviewer.
  • Attach the permission group to the role.
  • Assign QA Reviewer to the relevant members in Web Platform and Mobile App.

Open Workspace Settings → Workspace roles and permission groups → Roles.

Show a custom Project Role named QA Reviewer with its attached Permission Groups visible. Make sure the role name and associated permission groups are clearly readable.

The advantage comes from maintaining reusable permission definitions. A permission group can be attached to several custom roles, and changing it updates the effective permissions of every role that references it, so shared grants are maintained in one place while role assignments stay with each project.

Permissions from multiple groups combine additively. If one group allows editing only creator-owned work items and another permits unrestricted editing, the broader grant applies. A change to a shared group therefore reaches every role that uses it, alongside whatever a user already inherits through workspace roles or Teamspaces.

For step-by-step instructions on creating permission groups and combining grants across custom roles, follow the permission groups guide.

Managing access through identity-provider groups

Enterprise Grid deployments on self-hosted Commercial and Airgapped editions can also use IdP Group Sync to manage workspace roles, project access, and private collection access from identity-provider groups. Auto remove is off by default, so group sync only revokes the access it granted once that setting is turned on, and manually assigned roles and memberships stay in place either way. Plane also protects the last workspace or project Admin from automatic removal. Timing depends on the provider: SAML updates group access at login, while OIDC and LDAP support both login-based sync and optional scheduled offline sync. The IdP Group Sync guide covers provider-specific settings and removal behaviour.

How can administrators keep work item types and fields consistent across projects?

In Jira Data Center, a Bug's shape comes from several schemes at once: an issue type scheme decides which types a project offers, field configurations decide which fields are required, field contexts vary options by project, and screen schemes decide what appears on each screen. Keeping Bug consistent across ten projects means keeping all of those schemes in step.

Plane puts the definition on the work item type itself. Consider Web Platform and Mobile App, which both need a Bug type with the same core properties, plus a Severity field that one team treats as required and the other as optional.

Standardizing work item types across engineering teams

On Pro and Business, work item types are managed per project. Each project defines its own Bug type and properties under its project settings, which suits teams that run independently.

On Enterprise Grid, Workspace Admins define work item types and custom properties once at the workspace level, and every project uses the same definition. Imported types stay linked to the workspace library, so a change a Workspace Admin makes to Bug reaches every project that uses it. Turning on workspace work item types is permanent for the workspace.

Open Workspace Settings → Work item Types → Bug.

Show a workspace-managed Bug Work Item Type with multiple custom properties, such as Severity, Environment, and Steps to reproduce. Keep the property names and configuration clearly visible.

Each workspace type rolls out to projects in one of three modes:

  • None is the default. The type reaches a project only when a Project Admin imports it from the workspace library.
  • Seed adds the type to every new project by default, while existing projects don't get it. Seed works only on workspaces with workspace governance turned on.
  • Mandatory puts the type in every project right away, where it can't be removed. Switching it back to None later leaves it in the projects that already have it.

For Web Platform and Mobile App, central IT could mark Bug as Mandatory so both projects get the same definition on day one, set an Incident type to Seed so every new project starts with it, and keep more specialised types, such as a Security Review type, on None for the teams that need them. The workspace work item types guide covers activation and import in detail.

Setting project-specific rules with property contexts

Property contexts are how one definition serves teams with different rules. A context changes how a property behaves for a given project or work item type, and Plane applies the most specific context that matches. Contexts exist only on workspace work item types, so project-level types on Pro and Business don't have them.

For the two engineering teams, the Severity property on Bug can be mandatory in Web Platform and optional in Mobile App. Both projects share one Severity property with one set of options, and only the requirement differs.

Open Workspace Settings → Work item Types → Properties → Severity → Manage contexts.

Show the Severity property with two contexts:

  • Web Platform / Bug: Mandatory
  • Default context: Optional

Make sure both contexts and their configuration settings are visible. This screen should demonstrate how the same property can have different requirements across projects.

For a Jira admin, this replaces the combination of field contexts and field configuration schemes with a single property that carries its own rules. Screen schemes are the one piece to plan separately, and section 6 covers how.

Changing properties that are already in use

Once any work item has a value for a property, its structure is fixed. You can't change the property's type, its single or multi-select setting, or a dropdown's options. You can still change the title, the default value and whether the property is mandatory.

If you make a property mandatory after work items already exist, those items keep working as they are and need the value at their next edit. For a Bug type already in use across both projects, this means a new required property can be added mid-cycle, while restructuring an existing dropdown is a decision to make before the type rolls out.

Can Plane enforce your existing workflow and approval requirements?

In Jira Data Center, workflow schemes associate workflows with issue types within projects, while conditions, validators, post-functions, and Marketplace extensions govern how work progresses. Plane covers the same ground with a workflow builder, approval flows, and scripts that run before and after a transition.

Consider Web Platform and Mobile App, where Bugs must move through development, pass QA review, and receive approval before completion. Both projects need the same process, with central IT controlling which teams can change it.

Configuring workflows, transitions, and approvals

Business gives you workflows, transitions, and control over who can move work. Enterprise Grid adds approvals, pre-validation and post-action scripts, and workflows per work item type.

For the engineering scenario, the Bug workflow could follow:

Todo → In Development → In Review → Done

If QA rejects a Bug, the workflow returns it to In Development.

In the workflow builder, administrators select the states a workflow uses and configure the flows between them. The default workflow includes the project's configured states, while additional type-specific workflows are built from selected states.

Defining allowed transitions

A transition flow specifies the destination state and the members allowed to make the change. For example, the administrator can configure a transition from In Development to In Review and restrict it to selected project members.

Each state also has an Allow new work items setting. Turning it off stops new work items from being created directly in that state, which keeps work entering the process at the right point.

One constraint shapes more complex designs: all flows leaving the same state must be the same type. A state can have several transition flows or several approval flows, but a single source state can't mix the two.

Configuring approval flows

Approval flows require a decision before a work item advances. For the QA scenario, the administrator can configure the In Review state with:

  • On approval: Move the Bug to Done.
  • On rejection: Return the Bug to In Development.
  • Approvers: The members allowed to approve or reject.

When the Bug reaches In Review, it enters a pending approval state. Approvers see Approve and Reject controls on the work item, and their decision sends it to the configured destination.

  • Open Workspace Settings → Workflows in a workspace with governance enabled, or Project Settings → Workflows in a project-managed workspace.
  • Show a custom Bug Review Workflow with multiple states, such as: Todo → In Development → In Review → Done

If possible, also show an Approval Flow configured for the review stage, with the approval and rejection destinations visible.

Check existing assets: We already have a custom workflow screen referenced for the IT operations blog. Reuse it if the approval configuration is visible and suitable for this article.

Where you configure the workflow decides who can be an approver. Project-managed workflows select from project members, while workspace-managed workflows select from workspace members, which matters when central IT runs one approval process across several projects.

Applying pre-validation and post-actions

Plane Runner lets administrators enforce rules and trigger follow-up actions with JavaScript or TypeScript scripts, and the workflow builder splits these into two operations:

  • Pre-validation runs before a transition. A script can check whether required information exists or whether all sub-work items are complete. A pre-validation script that fails or throws blocks the transition, and the user sees why. When several pre-validation scripts are attached, they run in sequence and all must pass.
  • Post-actions run after a successful transition. Scripts can update properties, add comments, create related work items or call external services. A failed post-action doesn't undo the transition; the error is logged in the script's run history.

For Web Platform, pre-validation could stop a Bug from entering QA review while its sub-work items are still open, and a post-action could notify an external system after approval.

A Workspace Admin activates Plane Runner, and scripts can only make HTTP requests to explicitly allowed domains, within documented execution limits. This is where Jira validators, post-functions and Marketplace extensions get rebuilt. See Workflows and Approvals and Plane Runner for configuration details.

Enforcing workflow standards across projects

With workspace governance turned on, Workspace Admins maintain a shared workflow catalog and decide how much choice each project gets. Section 5 covers the decision to turn governance on; this section covers how it applies to workflows.

For each work item type, administrators pick one of three rules:

Rule
What projects can do

Any

Projects pick any active workflow

Constrained

Projects pick from an approved list

Required

One workflow for every project using the type

Central IT could set Bug to Required so Web Platform and Mobile App use the same QA approval workflow, or set it to Constrained to allow a short list of approved review processes.

Under Any and Constrained, administrators can also pin a specific project to a specific workflow. Plane resolves the effective workflow in this order:

Required workflow → Project-specific pin → Project selection → Workspace default

The resulting workflow controls the states, creation restrictions and transitions for that work item type, which gives central IT one standard with room for approved project choices.

  • Open Workspace Settings → Work item Types → Bug → Governance in an Enterprise Grid workspace with Workspace Governance enabled.
  • Show the Workflow Governance settings with Constrained mode selected, two permitted workflows (for example, Bug Triage and Standard Delivery), and a project-specific workflow assignment or pin visible.

This should demonstrate how central administrators control which workflows different projects can use.

Managing changes to active workflows

Shared workflows reach active work, so changes need a plan. Suppose central IT adds another review stage to the Bug workflow. The first questions are which projects and work item types use it and whether their current states survive the change.

When a project's effective workflow changes, Plane moves work items into fallback states if their current states don't exist in the new workflow. The reassignment screen previews the affected work items and their state mappings before you confirm, so the impact on Web Platform and Mobile App is visible before anything moves. Editing an existing workflow definition is a separate operation from reassigning a project's workflow, and the remapping preview applies to reassignment.

How can administrators recreate JQL-based reporting workflows in Plane?

Jira administrators often maintain saved JQL filters for engineering reviews, dashboards, and recurring reports. After moving to Plane, the job is to carry over the requirement behind each filter: which work items appear, who can see them, and how the results reach people.

Consider an engineering lead who needs to review open, high-priority Bugs across Web Platform and Mobile App.

Translating existing JQL filters into PQL

Plane Query Language (PQL) supports structured work item queries with fields, logical operators, built-in functions, sorting, and result limits.

For the engineering review, the two queries look like this:

Jira Data Center (JQL):

plaintext
issuetype = Bug AND priority = High AND statusCategory != Done

Plane (PQL):

plaintext
type = Bug AND priority = High AND stateGroup IN (openStates())

Both return high-priority Bugs that haven't reached a completed status. The difference lies in how each tool groups workflow states. Jira uses three status categories: To Do, In Progress, and Done. Plane's openStates() function covers Backlog, Unstarted and Started, and leaves out Completed and Cancelled, so map your Jira statuses to Plane state groups before you rely on the counts.

To recreate the report, open a workspace-level work item list or workspace view, switch the filter bar to PQL, and enter the expression. Add project filters for Web Platform and Mobile App if the workspace has other projects, then save it as a workspace view.

Open Workspace Views and display a filtered Work Item list using PQL.

Use this query: type = Bug AND priority = High AND stateGroup IN (openStates())

Show the PQL query and matching Work Items from multiple projects, such as Web Platform and Mobile App. Make sure the Work Item titles, projects, priorities, and states are visible.

If possible, save it as a View named Open High-Priority Bugs and show the View name.

To adapt this example to your own reports, use the PQL reference for supported fields, operators and functions.

Where PQL and JQL differ

PQL covers the everyday filters: work item types, priorities, states, projects, assignees, dates and custom properties, along with functions for date ranges and work item relationships.

History is the main difference. PQL has no WAS or CHANGED operators and can't query a field's past values. The closest options are stateChangedBy(), resolvedBy() and workLoggedBetween(), plus filtering on when an item was last updated. JQL functions added by Marketplace apps, such as ScriptRunner's issueFunction, belong to those apps and stay behind with Jira.

Maintaining reporting visibility across projects

Once the query is settled, the next decision is how teams use the results. Plane offers three surfaces:

  • Views save work item filters and display settings, including reusable cross-project workspace views.
  • Dashboards aggregate data from selected projects through configurable widgets and filters.
  • Analytics provides deeper project and work item analysis, with CSV export where supported.

For Web Platform and Mobile App, a workspace view gives the engineering lead a reusable list of matching Bugs, while a dashboard shows how they spread across projects, priorities and states.

Reporting access and visibility

Workspace views live at the workspace level, and every user still sees only the work items their permissions allow. Dashboards are workspace-scoped too: public dashboards are visible to workspace members, while private dashboards, available from Business, are visible only to their creator.

Work item security carries through to reporting, so restricted work items drop out of dashboards for users outside their audiences, subject to the access exceptions covered in section 1. The views guide and dashboard documentation cover the sharing and filtering options.

What about scheduled JQL filter subscriptions?

Views and dashboards can't be emailed on a schedule. Dashboards can be exported as PDF, and sharing and public links are on Enterprise Grid. Teams that rely on Jira's filter subscriptions for a weekly Bug digest will move that habit to a shared dashboard or a PDF export.

How can central IT govern configuration across multiple Plane projects?

Workspace governance moves states, labels, workflows, work item types and automations from project settings into workspace settings. Workspace Admins own the definitions, and Project Admins work with what the workspace allows. Section 3 showed how this works for workflows. This section covers the decision to turn it on.

  • Open Settings → Workspace Governance.
  • Show the Workspace Governance screen with governance enabled and the centrally managed configuration resources visible, if the interface provides this overview.

The screen should communicate that configuration is centrally managed at the workspace level.

Note: Use a workspace where governance is already enabled. Do not enable it in an active workspace just for this screenshot.

What changes when you turn on workspace governance

Turning on governance is a one-way change. It can't be disabled or undone, and once it's on, Project Admins can no longer create or edit governed configuration inside their projects.

Before anything changes, a read-only migration review shows how each project's setup will move into the workspace. States with the same name merge into one workspace state, while workflows stay separate. For Web Platform and Mobile App, that means two "In Review" states become one, and each project's QA workflow arrives in the workspace catalog as its own entry.

Once you start the migration, the workspace is locked until it finishes, so plan it for a quiet window. Existing project automations move to the workspace level and keep their original project scope.

Governance is also different from project templates. A template copies a setup into a new project once, while governance keeps every project tied to the workspace definition from then on. The workspace governance guide covers the migration review step by step.

Reviewing administrative changes through audit logs

Audit logs record administrative events such as changes to membership, roles, settings, and project configuration, with timestamps, actor details, filtering, and export.

Each log has a clear reach. The workspace log opens for workspace admins and owners only, while a Project Admin reads their own project's log. Changes to work items don't appear in the audit log; they stay in each work item's activity history. Changes to workspace automations don't appear in the workspace log.

For example, after changing a member's role in Web Platform, a Project Admin can open the Web Platform audit log and see who made the change and when. For the full list of tracked events, see the workspace audit logs and project audit logs guides.

  • Open Workspace Settings → Audit logs or Project Settings → Audit logs.
  • Show the audit log table with multiple administrative events visible, preferably permission changes, role changes, or project configuration updates.

Make sure Timestamp, Actor, Event, Event object, and Category columns are visible.

What should Jira administrators validate before adopting Plane at scale?

Before rolling Plane out across teams, run a focused proof of concept that tests your most important access, workflow, and reporting requirements against a real configuration. For the wider Data Center decision- deadlines, deployment, and platform fit- start with Before you commit to Jira Cloud: What Data Center customers should validate. This section stays with what's specific to administrators.

Jira administration practices that need a different approach

A few Jira practices map to a different mechanism in Plane, and they are the ones worth testing first:

Jira requirement
Plane approach
Limitation
What to validate

Screen schemes and operation-specific field configurations

Properties on the work item type, with mandatory settings per context and pre-validation scripts for transition checks

Required fields at a transition are enforced through a script

Each team's required fields at create, edit and transition

Advanced validators, post-functions and Marketplace extensions

Approval flows, pre-validation and post-action scripts in Plane Runner

Scripts run within execution limits and an allowed-domain list

Each critical rule rebuilt as a script, including its failure path

Historical and app-specific JQL

PQL with stateChangedBy(), resolvedBy() and workLoggedBetween()

No WAS or CHANGED; no past field values

Which reports depend on history and how they'll be answered

Filter subscriptions and scheduled reports

Dashboards with PDF export; sharing and public links

No scheduled email delivery

How each recurring report will reach its audience

Administrative proof-of-concept checklist

For Web Platform and Mobile App, six tests cover the setup described in this guide:

Area
Test and expected evidence

Permissions and security

Assign QA roles and sign in as a QA Reviewer, an unrelated workspace member, and a Workspace Admin. Check every access path, workspace roles, Teamspaces, group sync, and restrict a sensitive Bug. Authorized users can act; restricted content stays hidden from everyone else.

Work item types and properties

Roll out a shared Bug type with Severity mandatory in one project and optional in the other. Confirm the contexts apply and that existing work items behave as expected at their next edit.

Workflow enforcement

Run QA approvals, rejections, a failing pre-validation script, and a workflow reassignment. Confirm the transitions and review the state-mapping preview.

Reporting

Recreate the cross-project Bug report in PQL and compare the returned records, item by item, against the Jira report. Matching totals can hide different records.

Governance and auditability

Run the governance migration review in a separate test workspace first, since the change can't be reversed. Make an administrative change and find its audit entry.

Plan and deployment

Confirm every capability you need is available in your intended plan, deployment edition, and release.

Bottom line

Jira administration runs on schemes attached project by project. Plane moves that work to the workspace: you define roles, work item types, workflows, and the rules for using them once, and each project works within what you allow. Web Platform and Mobile App show the pattern end to end, from a QA Reviewer role built from shared permission groups to a Required Bug workflow that both teams follow.

The proof-of-concept checklist and acceptance worksheet turn this guide into a test plan for your own organization, so you can see where your Jira setup carries over directly and where it takes a different shape.

Ready to see how your Jira administration requirements would work in Plane?

Book a demo with Plane and bring your permission schemes, approval workflows and JQL reports into the conversation. We'll walk through how each one maps to Plane and what your proof of concept should cover before you roll out across the organization.

Frequently asked questions

1. Can Plane replace Jira's permission schemes across multiple projects?

Yes. Plane's Granular Access Control lets administrators build custom workspace or project roles from reusable permission groups. Where Jira associates a permission scheme with each project, Plane attaches permission groups to roles and assigns those roles to members, so one change to a shared group reaches every role that uses it.

2. Can Plane restrict access to individual work items within a project?

Yes. Work item security restricts visibility at the work item or work item type level through audiences. Workspace Owners and Admins always have access, and assignees and subscribers can see the items they're assigned to or subscribed to.

3. Does Plane support Jira-style workflow approvals and validators?

Yes. Plane supports approval flows, controlled transitions, and script-based rules through Plane Runner. Pre-validation scripts block a transition when requirements aren't met, and post-actions run after a successful transition. Complex Jira validators and Marketplace extensions are rebuilt as scripts within Plane Runner's supported APIs and limits.

4. Can existing JQL filters and scheduled reports be recreated in Plane?

Most operational JQL filters translate directly to PQL and can be saved as reusable views. PQL has no WAS or CHANGED operators, so queries on a field's past values need a different approach, such as stateChangedBy() or resolvedBy(). Views and dashboards can't be emailed on a schedule; dashboards can be exported as PDF.

5. Can workspace governance be turned off after enabling it in Plane?

No. Turning on workspace governance is permanent. A read-only migration review shows how states, workflows, and other configuration will move before you commit, and the workspace is locked until the migration finishes.

Recommended for you

View all blogs
Plane

Every team, every use case, the right momentum

Hundreds of Jira, Linear, Asana, and ClickUp customers have rediscovered the joy of work. We’d love to help you do that, too.
Plane
Nacelle