For Jira administrators who inherited somebody else’s automation
Upload one export from Jira. A minute later you see which rule sets off which, which hand-offs are switched off, which rules race for one event, where a credential sits in a rule — and what one run costs in steps before billing starts on 3 December.
On one real Jira site, one pass through the enabled rules costs 5,443 billable steps, and 505 of them could be removed. Above your plan’s allowance, from 3 December, that is a line on an invoice. The same site carries 1,724 hand-offs that can never fire — most were never meant to chain, and some were built on purpose and are quietly not working.
Jira Cloud · Built on Atlassian Forge · It never changes anything in Jira
Export the rules from Jira, upload the file, and a site of a thousand rules is mapped in about a minute. Nothing to install on a server, nothing to configure, and no API token in the app on the Marketplace editions.
One rule and the two rules it sets off, with the card of the rule and the space’s figures. Every screenshot on this page is taken on an invented demo site of 1,088 rules, so no customer’s data is shown anywhere on this site.
Step billing starts on 3 December 2026. Until then the waste is untidy; after it, every run pays for it — on this site, 505 steps of it in a single pass through the rules.
Every figure here is read by the app from one real Jira Cloud site — an export of 22 September 2026, step counts included, and none of it estimated. The same site also carries 46 cloned rules. One site, not an average: a second would give eight different numbers.
The site above spends 5,443 steps on one run of every enabled rule, and 505 of those could be removed — about one step in eleven. Put your own rule count in and the page applies the same ratio. Nothing more clever than that.
On the page this is a field you type your own rule count into. At 900 rules it works out as 5,542 steps per run across the instance, 514 of them removable.
If your site runs above its plan’s allowance, those 514 removable steps cost about $0.26 per pass through your rules — times how often they fire, which only your audit log knows.
This assumes your rules are built like that site’s, and they will not be exactly: the ratio comes from one instance, and a tidier or messier set moves it either way. Treat the result as the shape of the answer, not the answer.
And it is steps per run — not a monthly bill. Atlassian publishes no API for how often a rule actually fires. On Advanced, the real-runs beta reads it from your own push and prices each fix in this month’s runs; without that, nobody can turn one into the other for you.
None of these is visible from Jira's automation screen, because that screen shows you a list of rules and this is a problem about the relationships between rules. That is the gap this app fills, and the only one it claims to.
One upload answers three questions nobody can answer from inside Jira: what fires what, what races what, and what one run costs.
Rules are boxes, relationships are lines. You see which rule sets off which, which of those hand-offs cannot fire, where two rules race for the same event, and what creates issues in other projects. A dashed border means the rule is disabled.
Open a rule and its Links tab separates chains that fire from chains that are blocked, each with the reason in plain words — normally that the receiving rule has Allow rule trigger switched off, so it does not react to changes made by automation.
Each rule shows the steps one run spends and which of thirteen detectors found waste — a condition checked after the edit it should have stopped, a branch used as a yes/no check, a schedule that rescans every issue. Log actions and re-fetches are not billed steps. Each finding says how many steps the fix saves.
The Automation Expert agent answers from the map in Rovo chat, on every edition: what stops if you disable a rule, whether a rule for this already exists, what touches a field. Every rule it names comes back as a link into the map and into Jira’s rule editor. It runs on your own Rovo — nothing we bill you for.
With your own sender pushing Jira’s usage numbers and audit log as counts, each rule shows its runs, steps and failures over 30 days and the hours it is busiest. Diagnosis multiplies each fix by the runs the rule really had — 7 steps a run times 700 runs is 4,900 steps this month — and names the rules that wait on a failing one. Advanced edition, beta: it reads an internal Atlassian API that may change. Not on Standard.

A fix priced in this month’s real runs

A failing rule, and the two rules that wait on it
The Findings tab is not a score. It names the thing — this condition sits after the edit it should have gated; this scheduled run walks every issue its JQL matches — and tells you what to change in Jira. You make the change; the app never touches your rules.
Trigger, conditions and actions as a tree you can read without opening Jira, every field, status and issue type named rather than numbered, and anything that looks like a credential masked before it was ever stored.
How to read the map: direct call — one rule's action sets off another; live chain — the hand-off really fires; blocked chain — the receiver has Allow rule trigger off — nothing happens; trigger conflict — two rules race for the same event; creates issues elsewhere — the rule creates issues in another project; recursion — the chain comes back to where it started; clone — the same rule, twice.
One page over the whole site: the same findings the rule cards carry, gathered by class, ranked, filtered and exportable to CSV — the document an audit or a clean-up works from. The Rovo agent answers from the same map, on every edition. The audit page itself is on Advanced and Enterprise.
The audit page of the demo site: every finding by class and level, each with the fix spelled out.
The rules keep accreting. Nobody decides to stop understanding their automation — it happens one rule at a time, and the December step billing arrives on an instance nobody has measured.
Reading the exported rule JSON, one rule at a time. The catch is not that it is slow: the relationships are not in there to be read. A rule exported on its own carries none of its links — which rule sets it off, and which rule it sets off, simply are not in the file. That is a fact about the export format, and it is the honest reason a tool has to exist at all.
It lists every rule, it is free, and it is already open in your other tab. What it does not do is show the rules in relation to each other — which is the entire question this page is about.
If the question is what actually happened on this issue yesterday — did the rule run, what did it do, why did it fail — then Jira's automation audit log is the correct tool and this app cannot replace it. Atlassian exposes no public API for run history. Automation Map reads how your rules are built; on Advanced it adds 30-day run counts and failures per rule (beta), not the record of each run.
Standard and Advanced are the two editions of the Marketplace app (inside the app, Standard is labelled Basic). Enterprise is a different app, distributed privately. The difference that matters most is how the rules get into the app; almost everything else follows from that.
| Standard (Marketplace, Basic in the app) | Advanced (Marketplace) | Enterprise | |
|---|---|---|---|
| How you get it | Atlassian Marketplace, buy it yourself, free trial | Atlassian Marketplace, buy it yourself, free trial | From us directly, installed with a private link |
| Billing | On your Atlassian invoice | On your Atlassian invoice | Invoiced by us, yearly contract |
| How your rules get into the app | |||
| How the rules get in | You download a file from Jira and upload it to the app | The same file — or a small script on your side sends the rules automatically; the API token for Jira stays on your side | The app fetches them from your Jira by itself, using an API token you give it |
| Keeps itself up to date | No — you upload a new file when you want fresh data | Yes, if you run that script on a schedule | Yes, on a schedule you choose |
| How often you can update the data | Up to 7 times a week | Up to 5 times a day | No limit |
| The app warns that the data is old after | 8 days | 2 days | Depends on your schedule |
| What you get | |||
| The map: which rule sets off which, chains that silently do not work, rules that clash | Yes | Yes | Yes |
| Problems found in each rule, including a password or key typed into a rule | Yes | Yes | Yes |
| What each rule costs under Atlassian’s per-step billing, and what to cut | Yes | Yes | Yes |
| All rules in one list, sorted by what they could save, exportable to Excel (CSV) | No | Yes | Yes |
| AI assistant in Rovo, and access for your own AI tools (MCP) | Yes | Yes | Yes |
| How often each rule really ran and failed in the last 30 days (beta) | No | Yes, with the script on your side | Yes |
| Audit report — every problem on the site, ranked, filterable, exportable | No | Yes | Yes |
| AI writes what each rule is for, and explains groups of related rules | No | Yes | Yes |
| Custom field catalogue — which field to use, which duplicates nobody uses | No | No | Yes |
| Options of select-list fields — “does ACME already exist, and where do I add it” | No | No | Yes |
| Features Atlassian does not allow in Marketplace apps | No | No | Yes — the two rows above are examples |
| Security and permissions | |||
| “Runs on Atlassian” badge — Atlassian’s mark that the app makes no connections outside Atlassian’s cloud | Yes | Yes | No — Jira lets automation rules be fetched only with an API token, so the app has to call your Jira over the internet, and Atlassian counts that as leaving its cloud |
| Permissions it asks for | Read-only: it can look at Jira, not change it | Read-only: it can look at Jira, not change it | Also the permission “manage Jira settings”, needed to read select-list options. The app only reads with it and never changes a setting |
Standard and Advanced are priced per user per month through Atlassian, with a free trial; the prices are on the Marketplace listing, the only place they are guaranteed to be current. Enterprise is an annual term, quoted directly.
The Marketplace editions stay entirely inside Atlassian’s cloud, can only read Jira, never change it, and the map they build is the same map. Enterprise is for sites where uploading an export by hand is not acceptable — a large instance whose rules change daily, or an audit obligation that needs the map to refresh without a person.
Why the Enterprise edition has no “Runs on Atlassian” badge: to fetch your rules by itself it needs an API token, and Jira only accepts that over a normal internet connection, which Atlassian counts as leaving its cloud. That is the whole trade — hands-free updates for the badge — and we would rather you read it here than discover it at installation.
Standard (labelled Basic inside the app) is the whole map, every relationship, every finding on the rule it belongs to, the step costs and the Rovo agent. What Advanced adds is the work the product does for you: those same findings gathered into one ranked, filterable, exportable document; a model writing what each rule is for; the model's reading of whole groups of rules — a chain, a race on one event, a duplicate; and room to reload five times a day rather than seven times a week.
We hold no SOC 2 report, no ISO 27001 certificate and no other certification, and we are not going to imply one. The full detail is in the Data Security and Privacy Statement.
From 3 December 2026 Atlassian bills automation by the step — the trigger and every condition, action, branch and loop turn that ran — at $0.50 per 1,000 steps above your plan’s allowance. Automation Map counts what one run of each rule costs and what could be removed. On Advanced, a job on your side pushes the real runs, so the app also says what each fix saved since you made it and the day this month's pace hits your plan's run limit. It never prints a dollar bill: Atlassian exposes the run limit, not the step allowance.
The most common cause the app finds is a hand-off that cannot fire: rule A's action would set off rule B, but rule B has Allow rule trigger switched off, so the chain never happens and nothing reports an error. Jira ships that switch off, so the app shows the pair and names the switch rather than calling it broken — you confirm which chains you actually built.
Two or more rules react to the same event in the same place, and Jira does not guarantee which one runs first. Automation Map calls these trigger conflicts, groups the rules involved, and shows them on the map in orange so you can see exactly which rules are racing.
Yes — cross-project writes are drawn as their own link type, and picking two projects shows only what crosses between them. It answers the question every admin eventually asks: what stops working on our side if that other team changes their rules?
Yes. Both in-Jira jobs have a time limit per run, so past a few hundred rules you schedule two copies of the rules job with PART=1/2 and PART=2/2, each sends its half and the map builds once both are in; the usage job sends the previous hour's runs every hour, so a busy site never loses a day. Docker and Python have no such limit and read everything in one go. Any other language works too: the push API is documented.
Ask by field name and the app lists every rule that reads or writes it, and whether the match was in the trigger, a condition or an action. It searches the rule text the way a person would read it, with ids already resolved to names. On every edition, including Standard.
The audit page lists every finding across the site: credentials written into rules, hand-offs that cannot fire, racing triggers, rules that send data outside Jira, throwaway and stale rules, loops, cost savings and naming problems. Each class exports to CSV, and a credential finding comes with a security ticket ready to paste. The audit page is on Advanced and Enterprise; the findings themselves, including a credential found inside a rule, are on every edition.
No. It reads and reports. It has never written a rule, an issue, a field or a configuration, and it will not. Every link it offers into Jira opens Jira's own editor, where you make the change yourself.
Start on the Marketplace. Standard (labelled Basic inside the app) is the whole map, every relationship, the findings on each rule, the step costs and the Rovo agent. Advanced adds the audit page, with every finding ranked, filterable and exportable; AI descriptions; AI insights across groups of rules; five loads a day rather than seven a week; a push from a job on your side instead of uploading by hand; and real runs, steps and failures per rule, 13 months of history and the day you hit your run limit (beta). Enterprise is for sites where uploading an export by hand is not acceptable.
You export the rules from Jira's Automation screen and upload the file to the app, and the map is built in the background. On Advanced, a small job on your side can push them instead, on any schedule you like — your API token stays in that job, and the app only sees a key it issued. Standard allows 7 loads in a rolling week and counts the data stale after 8 days; Advanced allows 5 loads in a rolling day and 2 days. The Enterprise edition reads your site by itself, on a schedule you set.
To fetch your rules by itself it needs an API token, and Jira accepts that only over a normal internet connection, which Atlassian counts as leaving its cloud — so no badge. The Marketplace editions get the rules from a file you upload or a script on your side, never connect outside Atlassian, and both carry the badge.
Both Marketplace editions can only read Jira, never change it. The Enterprise edition also asks for the permission “manage Jira settings”, because reading the options of select-list fields needs it; the app only reads with it and never changes a setting. We list this here rather than let you discover it at installation.
Everything the app derives is stored in Forge hosted storage inside your own Atlassian site. The only outbound address the Marketplace editions may call is the product analytics endpoint analyze.journy.io, which is on Atlassian's approved analytics list.
No. The app keeps the display name of whoever created or last edited a rule, and nothing else about a person. No e-mail addresses are stored.
It is masked before anything is stored, and the finding is shown on every edition, Standard included — never gated behind a plan. A security finding you cannot see because of your licence tier would be worse than useless.
Not the story of one run. Jira's own automation audit log holds that, and it is the right place to look — Atlassian exposes no public API to it. Automation Map reads the structure of your rules and answers with hypotheses from it. On Advanced, a job on your side can push usage and audit-log counts (beta): then each rule shows its runs, steps and failures over 35 days, month by month for 13 months, and the error its failed runs hit — counts, not the record of each run.
No. Cloud only, every edition.
On Advanced and Enterprise, the AI writes a one-sentence description of what each rule is for, plus insights about chains, racing triggers and clones. It runs on Atlassian-hosted Claude through Forge, is sent the rule's masked configuration and nothing else, and only for the projects you choose. It is optional and off until you switch it on.
Yes, on every edition including Standard, along with the MCP server. The agent answers questions about the map in Rovo chat — what breaks if a rule is disabled, why a rule ran twice — with links back into the map and into Jira's editor.
Each of these is a question administrators arrive with, worked through on a real site: what the symptom looks like, why Jira does not show it, and what to do about it.
Two kinds of ticket land on a Jira administrator every week, and both are answerable from the map without anyone reading rules one by one. The agent is called Automation Expert, it is on every edition including Standard, and it runs on your own Rovo entitlement — not on anything we bill you for.

The agent explaining a whole space — its real answers on the demo site, not a mock-up.

Rovo Studio: the ten Automation Map tools, ready for your own agent.
The app brings ten tools to Rovo Studio — search rules, get a rule’s relations and details, check a rule against a work item, who touches a field or status, project overview, what the rules really did, and saving descriptions. Give them to your own Rovo agent and it answers rule questions inside your team’s own flows.
Can we get an email to the team lead when a support request has gone two days without an answer?
Nothing new needs building. Turn Allow rule trigger on for the paging rule and the escalation already does what the ticket asks.
Escalated tickets used to page the on-call engineer. They stopped, and there is nothing in the audit log.
From the structure alone I cannot tell you whether it ran yesterday. On Advanced with real runs switched on (beta) I can show its runs and failures of the last 30 days; otherwise Jira's own automation audit log is the place to look.
Both exchanges are illustrations of the shape of an answer, written for this page — not a recording. The screenshots above are the agent's real answers on the demo site. In the product every rule the agent names comes back as two working links, one into the map and one into Jira's own rule editor.
The MCP server and Rovo Studio carry ten of the eleven, so an agent you build yourself can use the same tools alongside Jira's own. draft_documentation stays with the Automation Expert.
A fixed template — header table, contents, purpose, trigger, every step, what the rule reads and writes, the rules connected to it and racing it, what stops if you disable it, its cost and its findings. It offers to create the Confluence page and creates it only when a person says yes.
It describes the rules that have no business description and saves them. This is the only thing the agent writes, and it writes to the app's own store — never to a rule in Jira.
One into the map, one into Jira's own rule editor. You are never left searching for the rule the answer just named.
It knows how your rules are built on every edition. On Advanced, when your own job pushes Jira’s usage and audit-log counts (beta), it also knows what they did over 30 days — which rules fail, run most or spend most. Without that, “why did this fire yesterday” gets hypotheses from the structure and a pointer to Jira’s automation audit log.
There is an AI tab on the settings page and everything on it starts off. While AI-written descriptions are off the app makes no call to a model at all, for any reason. Descriptions can still be written by hand, and the Rovo agent still works — that runs on your own Rovo, not through here.
The AI tab after an administrator switched it on, shown on the Enterprise edition inside Jira’s settings. Every switch says in plain words what leaves the app and what does not.
One or two sentences per rule saying why the rule exists in business terms — not a re-reading of what its steps do, which you can already see.
The model's reading of a group of rules rather than one: a chain, a race on a single event, logic duplicated across projects. Each insight names the rules it is about.
The model only ever sees the projects an administrator ticks, and there is deliberately no “all projects” switch. The card prices the choice before it runs: how many rules, roughly how many minutes, and how much of this month's allowance it will spend — each installation has one, and the card says what is left.
Sent: The rule's name and the text of its steps, with anything that looks like a credential masked before it leaves.
Never sent: Never an issue, never a comment, never a field value out of one of your projects.
Atlassian-hosted Claude through Forge LLMs: Claude Haiku 4.5 writes the descriptions, Claude Opus 4.6 writes the insights. It does not leave Atlassian.
“The AI overwrote my description” cannot happen. A rule's purpose is taken in this order, and the first one that exists is the one you see:
A rule the model cannot confidently describe gets no description at all. Instead it gets a list of questions for whoever owns the rule — which is more useful than a confident sentence that is wrong, and a great deal safer.
If you can hold your automation in your head, a map of it is not worth paying for. The threshold is roughly the point where nobody on the team can any longer say what fires what.
That is Jira's own automation audit log, and it is the right tool for the question. This app reads the structure of the rules; Atlassian offers no public API for the log of their runs. On Advanced, a job on your side can push usage and audit-log counts (beta) for runs and failures over 30 days — counts, not the log of one run. Otherwise it answers with hypotheses from the structure and sends you to the log.
It will tell you what to change and why — each finding names the step, the saving and the remedy, and the Rovo agent will walk you through it. What it will not do is make the edit. It has never written a rule, a field or a configuration, and the last click stays yours.
Cloud only, every edition.
Not this product. Advanced shows runs, steps and failures per rule (beta, from your own push), never per person.
The Enterprise edition keeps a catalogue of every custom field: its type, which projects it is already used in, and which same-named fields look abandoned. Jira records when a field's value last changed, so a field in no project that has never changed is somebody's first attempt.
Enterprise only. The Marketplace editions map automation rules; they do not carry the custom field catalogue.
Values belong to a context, not to a field — which is why "I added it and it didn't appear" is so common: a field with three contexts has three separate lists. The Enterprise edition names the contexts, says which projects each covers, links straight to the right one, and tells you whether the value is already there.
Including a value that merely looks identical — ACME typed in Cyrillic characters, for instance. This one is Enterprise only.
The Enterprise edition is distributed by a private installation link and sold directly, so there is a conversation before there is a licence. The number of automation rules on your site is the question that decides whether this is worth either of our time. The enquiry form on this page files a ticket in our service desk, which you are equally welcome to use directly.
Documentation · Support · Privacy Policy · Customer Terms · Data Security and Privacy Statement · Product Analytics
Last updated