How the XWiki Jira integration works with JIRA Pro
Choose JIRA Pro when your team wants Jira issues, counts and charts on XWiki pages and also needs people to create Jira issues from the wiki. The add-on works only with Jira Server and Data Center, and it requires XWiki 15.10 or above, so confirm both before you compare options. JIRA Pro adds OAuth authentication and issue creation to the open source XWiki JIRA extension. The decision you are making is mainly whether you need OAuth-based sign-in and the ability to write back to Jira from the wiki. If you only need read-only views for a small group, check whether the open source extension meets that need before you buy the add-on.
JIRA Pro provides five macros. The jira macro displays Jira issues on a page, and jiraCount returns a count of issues. The jiraPieChart, jiraCreatedVsResolvedChart and jiraBiDimensionalGridChart macros present issue data as charts and grids. Plan for query design: the people who build pages need to know which Jira projects, filters and fields feed each macro. Before rollout, list the pages that will embed each macro, the Jira data behind them and the views your readers actually use. Confirm the parameters, output options and limits in the documentation for the version you plan to install, because these details change between releases.
The Server and Data Center only limitation is the first decision gate. Jira Cloud support is listed as under development, so a team on Jira Cloud cannot rely on this add-on today and should plan another approach or wait for a supported release. Check your Jira deployment type and version, and confirm that XWiki can reach Jira over the network path you intend to use. On the XWiki side, the release lines published at the time of research all sit above the 15.10 minimum, but confirm compatibility with the exact version you choose. Ask the publisher for the current compatibility list before you commit, since a version mismatch on either side can block the OAuth setup.
Per-user OAuth decides what readers see. Each reader authorizes XWiki to access Jira with their own identity, so the issues shown on a page should match what that person can open in Jira. This behavior depends on your Jira permission scheme, so a project that is restricted in Jira must stay restricted on the wiki. Plan three checks before launch: test a page with a user who has no access to a restricted project, confirm that issue creation runs with the signed-in user's permissions, and document how users connect their accounts the first time. Also decide who may create issues from the wiki, because any page that creates issues is a write path into your work management system.
Prerequisites for the XWiki Jira integration
The Jira connector depends on three things lining up: a supported XWiki version, a Jira instance the wiki can reach, and an identity path that lets each reader authenticate with their own Jira account. Confirm these before scheduling any build work, because a gap in any one of them changes the design.
XWiki version 15.10 or later
JIRA Pro requires XWiki 15.10 or above, so the wiki must be on that release or newer before the extension is installed. Check the running version in the administration area, not only the image tag used for deployment. Note which line you run (stable, LTS or intermediate LTS) because it determines your upgrade cadence and how long the version floor will stay safe to rely on.
Jira Server or Data Center reachable
The connector works with Jira Server and Data Center only, and Jira Cloud support is listed as under development. Confirm that the target instance is one of these deployment types and that the XWiki application servers can open network connections to its base URL. Firewall rules, proxies and private DNS are the usual reasons this check fails, so test from the wiki host itself.
Jira administrator access for OAuth
Creating an OAuth application link in Jira requires administrator rights on that instance. Someone with that access must be available during the build to register XWiki as an application, record the generated credentials and confirm the redirect address. Agree in advance who holds this role and how the credentials will be stored, since they grant the wiki the ability to act on behalf of users.
HTTPS on both sides
Serve XWiki and Jira over HTTPS with certificates that clients and the other system trust. OAuth redirects and token exchanges are sent between the two applications, and mismatched schemes or self-signed chains without a trust path are common causes of failed sign-in. Confirm the exact external hostnames now, because the redirect address registered in Jira must match the public address of the wiki.
Test account for verification
Plan a dedicated service account or a named test administrator in Jira for the build and acceptance tests. Use it to confirm that macros return results, that issue creation works and that a user without access to a project sees nothing from it. Keep the account limited to test projects where possible so that verification does not expose production data.
JIRA Pro licence and trial terms
Confirm the licence status and the trial terms for JIRA Pro with the XWiki Store before the build starts, since the OAuth authentication and issue creation features depend on it. Ask what the trial covers, how long it runs, what it converts to and who signs the purchase. Record the answers in the project scope so that the build does not stall at installation.
How per-user OAuth keeps Jira permissions in place
Per-user OAuth means each reader signs in to Jira with their own identity, and the Jira macros in XWiki return only the issues that identity can access in Jira. The permission decision stays in Jira, where project permissions, issue security levels and role assignments already live. XWiki does not need its own copy of those rules, which matters most for teams that already restrict sensitive projects in Jira. Before you rely on this, confirm how the macros behave for anonymous visitors and for users who have not yet authorized the connection, because the output in those cases depends on the JIRA Pro configuration.
The change for administrators is mainly where access control sits. With a single shared Jira account, every reader sees whatever that account can see, so XWiki page restrictions become the only control over Jira data. A page limited to one group could still display issues from a project that group should never see. Per-user OAuth moves the filter into Jira. You no longer maintain a service account with broad read access, and Jira's own records can show which person viewed or created an issue, within what Jira logs. The trade-off is new operational work: registering the OAuth application on the Jira side, setting the allowed redirect addresses, and handling users who leave or change roles in Jira.
Several details must be confirmed in the JIRA Pro documentation rather than assumed from the feature summary. Check how the OAuth flow starts, which application configuration Jira requires, and where XWiki stores access and refresh tokens. Ask whether tokens are encrypted at rest, how long they remain valid, and how a user revokes them. Find out whether a consent screen appears in Jira, what text it shows, and who must approve it. Also confirm what a macro displays when a token expires during a session. Record the answers in your design notes, because token storage and consent behavior affect your security review and your user onboarding instructions.
Test the model in a non-production environment before any user relies on it. Create a dedicated Jira project with issues restricted to different permission groups, then create test users in each group. Compare the results of jira and jiraCount for each user with what that user sees when searching Jira directly. Check that an issue created from the wiki records the signed-in user as reporter. Remove one test user's Jira access and confirm that the data disappears from pages on the next load. Finally, confirm that your Jira instance is Server or Data Center, since JIRA Pro does not support Jira Cloud yet, and that your XWiki version is 15.10 or above.
Setup sequence for the XWiki Jira integration
This sequence takes an XWiki instance from a version and deployment check to a verified Jira connection in six steps. Each step ends with a check that the wiki administrator and the Jira administrator can confirm before moving on. The result is a working connection in which each user sees only the Jira issues their own account can access.
Confirm the XWiki version and Jira deployment
Start by checking two prerequisites before any installation. JIRA Pro requires XWiki 15.10 or above, so the wiki administrator should confirm the installed version in the administration area. The extension works with Jira Server and Data Center only, and Jira Cloud support is listed as under development, so the Jira administrator should confirm the deployment type and the base URL that users open in their browsers. This step is done when both values are written down and both meet the stated requirements.
Install JIRA Pro from the XWiki Store
A wiki administrator installs the JIRA Pro extension from the XWiki Store into the XWiki instance. Install it on a test instance first if you have one, so configuration can be tested before it reaches production. The extension adds OAuth authentication and issue creation to the open source XWiki JIRA extension and provides the jira, jiraCount, jiraPieChart, jiraCreatedVsResolvedChart and jiraBiDimensionalGridChart macros. Check that the extension appears in the installed extensions list and that the jira macro is available when you edit a page. Confirm the installation method for your packaging with your XWiki administrator.
Create the OAuth application link in Jira
A Jira administrator creates an OAuth application link on the Jira Server or Data Center side, so XWiki can request access on behalf of each user. Record the consumer key and the other credentials Jira generates, and keep them in a secure location, since the next step needs them. The menu path and field names depend on your Jira version, so confirm them against your own Jira documentation. Limit the link to the access the wiki use case needs. The step is complete when the link appears in the application links list with its settings saved.
Enter the Jira base URL and OAuth settings
A wiki administrator enters the Jira base URL and the OAuth values from the previous step into the JIRA Pro configuration in XWiki. Use the address that users open in their browsers, and confirm that the XWiki application servers can reach it, because they make the OAuth calls to Jira. Check the field names against the extension documentation for your installed version. Save the configuration and use any connection test the extension provides. The step is done when XWiki saves the settings without error and the connection test reports success.
Test OAuth login with a test user
Sign in to XWiki as a test user who has a known Jira account with defined project permissions. Approve the OAuth prompt from Jira, then open a page that uses the jira macro. The login should complete, and the test user should see only the issues their Jira permissions allow. Repeat the check with a second test user who has different access, and with a user who has no Jira access, who should see no issue data. This step is done when each test user sees the expected issue set and nothing beyond it.
Add a test page and create a test issue
Create a test page in XWiki and insert the jira macro with a query limited to a test project. Compare the rendered list with the same query run in Jira, checking issue keys, summaries and statuses. Then create a test issue from the wiki and confirm in Jira that it exists in the expected project with the expected fields. Remove the test page and issue once the integration is verified, or keep them as a documented smoke test. The sequence is complete when the rendered list matches Jira and the wiki-created issue appears in Jira.
How Jira fields and macros map to wiki content
This table maps each JIRA Pro macro to the wiki content it renders, the Jira data it reads and the inputs and permissions that shape the result. Read each row before you design page templates, because a macro that looks like a simple count can return different results for different readers. Confirm the parameters for every macro in the JIRA Pro documentation before publishing pages that depend on them.
| Macro or feature | Wiki content it produces | Jira data it reads | Inputs and permissions |
|---|---|---|---|
| jira | Issue list rendered in the page | Issues returned by a JQL query or saved filter | Input: JQL or filter. Results follow each reader's Jira permissions through OAuth. |
| jiraCount | Single number showing how many issues match | Issue totals for a JQL query or filter | Input: JQL or filter. The count can differ between readers with different Jira permissions. |
| jiraPieChart | Pie chart of matching issues grouped by one field | Issue counts per value of the grouping field | Input: JQL or filter plus a grouping field. Confirm the supported grouping fields in the JIRA Pro docs. |
| jiraCreatedVsResolvedChart | Chart comparing issues created and resolved over a period | Creation and resolution dates of matching issues | Input: JQL or filter and a time period. Confirm how the period and time zone are set. |
| jiraBiDimensionalGridChart | Grid crossing two fields with counts in each cell | Counts of matching issues across two field values | Input: JQL or filter and two fields. Confirm limits on grid size and how empty cells display. |
| Issue creation from the wiki | Action that creates a Jira issue from a wiki page (a feature, not a macro) | Writes a new issue to the target project | Requires create permission in the project for each user. Confirm the setup steps in the JIRA Pro docs. |
Which macros fit issue lists, counts and charts
Choose the macro by the question the page must answer. Use the jira macro when readers need to act on individual issues, because it shows keys, summaries, statuses and assignees they can open. Use jiraCount when one number is the message, such as how many open defects a release carries. The chart macros answer questions about shape: jiraPieChart shows distribution across a field, jiraCreatedVsResolvedChart shows whether work is accumulating or draining over time, and jiraBiDimensionalGridChart cross-tabulates two fields. For status reporting, a count and one chart usually carry the headline, with a list underneath for exceptions. Backlog pages depend mostly on lists. Project home pages work best with a count and a single chart, which keeps the page short enough to scan.
The JQL behind each macro decides what the page means, so write and review it before choosing the layout. A list and a count built from different queries will disagree, and readers will conclude the page is wrong. Keep one query per question and reuse it wherever the same number appears. Check that the scope names the projects, issue types, sprints or labels the report intends, and avoid open-ended clauses that pull in issues from other teams. Backlog pages need an explicit ordering and a status filter, otherwise the list can grow as projects change. Ask your Jira administrator which statuses and fields your workflows use, because a status name that differs between projects will split one count into several. Run each query in Jira issue search first and compare the result count with what the macro displays.
Visibility is the part most likely to surprise a shared page. With per-user OAuth, each reader sees the issues their own Jira account can access, so one page can show different content to different people. A project lead may see every issue, while a stakeholder outside the project sees a shorter list and a lower count. This is the intended behavior, but it changes what the page can be trusted to say. Decide whether the page is a working view for team members or a summary for executives, and state the audience at the top. Saved filters add a second layer. A macro that relies on a saved filter inherits that filter's owner and sharing settings, so confirm who owns it and what happens if that person leaves. Ask the vendor how the version you run handles filter references and any caching of results.
Start with a pilot page for one project before any wider rollout. Pick a project with a stable workflow, a named owner and an active backlog, then build one status page with a list, a count and one chart using the agreed JQL. Test the page with at least three accounts: a project member, a project lead, and a reader with no Jira access to the project. For each account, compare what the page shows with what Jira search returns for the same account. Record every mismatch and resolve it in the query or the permission model before copying the pattern. Confirm the prerequisites as well: JIRA Pro works with Jira Server and Data Center only, Jira Cloud support is listed as under development, and the XWiki version must be 15.10 or above. Widen the rollout only after the pilot results match, and document the pattern so the next team starts from the same tested setup.
Securing Jira credentials and reader access
These six checks cover the credentials, the people who can change the integration, the transport between systems, and the pages where Jira data and issue creation appear. Together they determine whether readers see only what Jira already allows, and whether anyone can change that without review.
OAuth client secret storage
The OAuth client secret lets JIRA Pro exchange user consent for Jira access, so it is the most sensitive value in this integration. Keep it out of wiki pages, page history and exported XAR files, and hold it in your secrets store or in an XWiki configuration location that only your administrators control. Confirm the secret is rotated when an administrator leaves, and check that the Jira application link still points at the intended Jira Server or Data Center instance after any change.
Limit who edits JIRA Pro settings
The JIRA Pro configuration decides which Jira instance the wiki talks to and which OAuth application it uses, so a change there affects every reader. Restrict edit rights on the configuration page and on any space where it is stored, and keep wiki-wide administrator rights in a small named group. Review the change history after each extension upgrade, because a changed endpoint or application ID silently changes which Jira instance readers authenticate against.
HTTPS on both sides
OAuth redirects, access tokens and issue data cross the connection between XWiki and Jira, and readers' browsers carry the same traffic to the wiki. Serve XWiki over HTTPS with a certificate your browsers trust, and require HTTPS on the Jira Server or Data Center base URL the integration calls. Verify that the redirect URI registered in Jira uses the same scheme and host as the public XWiki address, since a mismatch is a common cause of failed sign-in.
Inventory spaces that embed Jira macros
The jira, jiraCount, jiraPieChart, jiraCreatedVsResolvedChart and jiraBiDimensionalGridChart macros can appear on any page a writer can edit, so Jira data may reach a wider audience than the page owner intended. Search the wiki for these macros, record which spaces and pages use them, and confirm that each page's view rights match the Jira projects it displays. Repeat the search when new spaces are created or when authors receive edit rights.
Test access for a reader without Jira rights
Per-user OAuth should show each reader only the issues their own Jira account can access. Create a test reader with no permission on a restricted Jira project, sign in as that reader, and check that the jira macro, counts and charts show nothing from that project. Repeat the test for a reader in each permission group you use, and keep the results with your change records.
Review rights on issue-creating pages
A page that creates issues is an entry point into Jira, so anyone who can open the form may be able to file issues. Review view and edit rights on each such page, confirm which Jira project and issue type the form targets, and check that guest access is off wherever issue creation is enabled. Confirm with the extension's documentation how each created issue is attributed to the submitting user.
Why Jira macros return no results or fail
This table lists the failures most often seen when Jira macros return no results or fail, with the likely cause and the first check for each. Work through the rows in order, since version and deployment type are the fastest to rule out. Most failures trace back to the XWiki version, the Jira deployment type, OAuth registration or the reader's own Jira permissions.
| Symptom or failure | Likely cause | First check |
|---|---|---|
| XWiki version below 15.10 | JIRA Pro requires XWiki 15.10 or above, so the extension may not work on an older release. | Confirm the exact XWiki version in the administration area and compare it with the 15.10 minimum. |
| Extension pointed at Jira Cloud | JIRA Pro works with Jira Server and Data Center only. Jira Cloud support is listed as under development. | Confirm the Jira base URL points to a Server or Data Center instance before testing any macro. |
| OAuth callback or redirect error | The redirect URL registered in Jira differs from the address users reach XWiki on, in scheme, host, port or path. | Compare the redirect URL in the Jira application link with the public XWiki URL, character by character. |
| Authorization fails after it worked before | The user's OAuth token has expired or was revoked, or the user's Jira account lost access it depended on. | Ask the user to reauthorize, then confirm their Jira account is active and still has project access. |
| Admin sees issues, reader sees nothing | The JQL depends on permissions the reader lacks, or the reader has not yet completed OAuth authorization. | Run the same JQL as the reader in Jira and confirm their project role covers the issues returned. |
| Certificate trust error between XWiki and Jira | The Java truststore used by XWiki does not trust the certificate chain of the Jira server, often an internal certificate authority. | Test the TLS connection from the XWiki host and confirm the internal CA is in the truststore XWiki uses. |
| Counts or charts are empty with no error | The query is valid but matches no issues, often because of a wrong project key or an unexpected status filter. | Check the project key and run the JQL directly in Jira's issue search to confirm results exist. |
Why Jira Cloud is not covered by this integration yet
JIRA Pro works with Jira Server and Data Center only. The XWiki Store lists Jira Cloud support as under development, so the macros and issue creation described on this page do not yet have a supported path to a Jira Cloud site. If your organization runs Jira Cloud, plan on the basis that this integration is not available to you today. Because the status is a vendor statement that can change, record it in your planning file with the date you checked it and the name of the person who checked. Confirm the current status on the XWiki Store page for JIRA Pro before you schedule any build work, and repeat the check before any go-live decision.
Teams on Jira Cloud should not design around a Cloud connection until XWiki confirms one in writing. That includes choosing an authentication model, registering an OAuth application on the Jira side, defining how wiki readers are matched to Jira permissions, and drafting page layouts that assume Cloud site URLs will work. Each of those choices rests on an assumption that the vendor has not yet confirmed. If the assumption is wrong, the rework lands in the authentication layer, which is the part that decides whether readers see only the issues they are allowed to access. Keep those workstreams on hold, or limit them to items that do not depend on the connector, such as Jira project structure and issue fields.
In the meantime, a Jira Cloud team can keep the scope of the open source extension under review. Ask which macros and behaviors the open source XWiki JIRA extension provides on its own, and which ones depend on JIRA Pro. Then map each wiki use case to one of those two groups. If the main need is a reference from a wiki page to a Jira issue key, the open source scope may be enough for a first phase. If the need is counts, charts or issue creation from the wiki, those requirements depend on the commercial extension and its Cloud status. Write these needs down before any vendor conversation so your questions to XWiki SAS are specific and answerable.
Check your XWiki version as well. JIRA Pro requires XWiki 15.10 or above, so a platform on an older release needs its own upgrade decision, whatever Jira hosting model you use. Compare your current version with the XWiki release line you intend to run. Ask for JIRA Pro licensing terms in writing, including whether the license covers Server and Data Center deployments only and what the quote says if Cloud support ships after your planned go-live date. A clear written answer on these points is more useful to your steering group than a general statement that Cloud support is coming.
Questions buyers ask about the XWiki Jira integration
How much does the XWiki Jira integration cost?
The JIRA Pro licence price is not published in the sources we work from, so request it from the XWiki Store before you budget. Expect cost to come from four parts: the JIRA Pro licence, the implementation fee for work defined in a written scope, Jira administrator time from your side, and any XWiki SAS services you choose to buy. XWiki SAS lists consulting at 1200 EUR per day, a rate that requires a Business or Enterprise support plan, and training at 1500 EUR per day, according to its pricing page. DeployOpen does not publish prices. A quote follows from the scope you agree in writing, which should list the Jira instances, projects and macros in use. Ask whether licence fees recur and how renewals affect the total.
How long does setup take for a Jira integration?
No setup duration is published for this integration in the sources we use, so treat any timeline as something to confirm in the written scope. The main driver is Jira topology. A single Server instance is simpler to configure than a Data Center deployment with several nodes or multiple Jira instances. The number of projects matters because each project's permission scheme, issue types and fields affect what the macros return and what the create-issue form needs. Other drivers include how many wiki spaces will embed Jira content, whether charts are required, and how many test users must be set up for verification. Ask the provider to break the schedule into Jira configuration, XWiki installation, testing and handover.
What access does the Jira integration require from our administrators?
The team needs Jira administrator access to register the OAuth application link on the Jira side and to confirm the permissions it receives. On the XWiki side, it needs administrator rights to install and configure the JIRA Pro extension and to set the Jira server address and OAuth settings. Test users are also required: at least one account for each access level you want to verify, such as a user who can see a restricted project and a user who cannot. Someone must confirm that the XWiki host can reach the Jira server over the network and record the Jira and XWiki versions in use. Confirm exact settings and permissions against the extension documentation, since setting names can change between releases. Agree before work starts on who approves changes to the Jira application configuration.
Can our in-house team set up the XWiki Jira integration alone?
Often yes, if your team already runs both Jira and XWiki and has people comfortable with OAuth. The work spans three areas: Jira application configuration, XWiki extension setup and permission testing across different user types. The Jira side is where mistakes are costly, because a misconfigured OAuth link or overly broad permissions can expose issues to readers who should not see them. Check whether your team has someone who can test against actual permission boundaries in Jira, not only with an administrator account. If in-house skills are thin, you can buy XWiki SAS training at 1500 EUR per day or consulting at 1200 EUR per day (consulting requires a Business or Enterprise support plan), or ask DeployOpen for a fixed-scope quote covering configuration and testing.
Does JIRA Pro work with Jira Cloud?
No. JIRA Pro works with Jira Server and Jira Data Center only. The XWiki Store lists Jira Cloud support as under development, so do not plan a Cloud rollout around it today. The extension also requires XWiki 15.10 or above, so check your current XWiki version before scoping. If your organization is moving from Server or Data Center to Cloud, plan the order of work with that in mind, because the wiki integration may need to be redesigned or deferred. Confirm the current status with the XWiki Store listing and with XWiki SAS before you commit to a date. A written scope should name the Jira deployment type and XWiki version it assumes, so the quote reflects your actual environment.
Why does per-user OAuth stop readers from seeing restricted Jira issues?
Each reader's OAuth token is used when a macro queries Jira, so Jira's own permission checks decide which issues appear. A shared service account would show the account's visibility to every reader, which is usually broader than intended. Under the per-user model, a user who cannot browse a restricted project in Jira sees nothing from it in the wiki. Engineers should verify this with test accounts before rollout. Confirm that a restricted issue stays hidden, that counts and charts reflect the same filtering, and that creating an issue from the wiki respects the user's create permission in the target project. Also test that a permission change made in Jira shows up in the wiki view.
What should we test before giving readers access?
Test with a small set of accounts that represent each access level in your Jira projects before wider rollout. Include a user with full access, a user limited to one project, and a user with no access to a restricted project. For each account, check the jira macro output, the counts, the charts and the create-issue action. Load at least one page with a large result set to see how long it takes to render and whether the query is limited sensibly. Confirm that the XWiki version is 15.10 or above and that your Jira server version is supported by the extension release you install. Record the results so internal reviewers or auditors can see what was tested, and retest after any Jira permission scheme change or XWiki upgrade.
Who pays for the licence, the implementation and the support?
Three parties can be paid in this model. The JIRA Pro licence is bought through the XWiki Store, and its price must be requested there. DeployOpen charges for implementation under a fixed-scope written agreement, and it offers ongoing support, upgrades and testing as retainers. XWiki SAS charges separately for its own consulting, training and support subscriptions if you choose them. Your own team's time is an internal cost that does not appear on any invoice. Ask each party for an itemized quote, identify which items are one-time and which recur, such as renewals and retainers, and confirm whether upgrades to XWiki or the extension are included. Keep the signed scope, since it defines what the fixed fee covers.
How DeployOpen scopes and delivers the XWiki Jira integration
DeployOpen scopes the XWiki and Jira integration in writing before work starts, so the Jira instance, OAuth setup and macro usage are agreed up front. Work is delivered in infrastructure you control, and each engagement is fixed-scope, with ongoing support available as a retainer.
How we scope
- Confirm your Jira deployment is Server or Data Center, since JIRA Pro does not cover Jira Cloud today.
- Confirm XWiki is 15.10 or later, the minimum version JIRA Pro requires, before any build time is committed.
- Written scope lists the Jira projects, macros and creation fields that pages will use, with a fixed deliverable list.
How we build
- Register the OAuth application in Jira and configure JIRA Pro so each reader authenticates as themselves.
- Build wiki pages with the jira, jiraCount, jiraPieChart, jiraCreatedVsResolvedChart and jiraBiDimensionalGridChart macros.
- Test that issue visibility matches Jira permissions for sample users in a staging wiki before production rollout.
How we hand over
- Document the OAuth setup, macro parameters and the Jira permission scheme the integration depends on.
- Provide a runbook for rotating OAuth credentials and for upgrading XWiki and the extension together.
- Walk your administrators and wiki editors through creating issues from pages and reading the charts.
How we support
- Track extension version compatibility against your XWiki release line, including LTS and stable tracks.
- Review access after Jira permission scheme changes so readers keep seeing only issues they can access.
- Offer ongoing support and upgrade work as a retainer, or scope a one-time change as a separate fixed engagement.

