How to Reduce Jira Automation Step Usage — Five Fixes
A condition checked after the action it should have stopped. Three conditions one JQL could replace. A schedule that rescans everything. Five fixes, and what is free.
Most rules (Jira now calls them flows) that waste money are not badly designed. They were written quickly, extended twice, and never read again. The waste sits in the order of the steps, not in the intent.
From 3 December 2026 that waste appears on an invoice: Atlassian bills Jira automation by the step, at $0.50 per 1,000 steps above your organisation's allowance. This guide walks through five patterns that cost steps for no outcome, why each one happens, and what to do about it — and starts with what costs nothing, so you do not spend an afternoon deleting steps that were free.
Updated 4 November 2026: Atlassian's usage page lists Log action, Create variable, Create lookup table, Re-fetch work item data and Lookup work items as steps that are not counted. The earlier version of this article treated log actions and re-fetches as billed; it was wrong. Both sections have been replaced by the correction below, the pattern list now holds only steps that cost, and the site-wide saving we quoted from one real site has been withdrawn because it counted those free components.
Updated 17 November 2026: the same page now adds a rule on runs with no actions: from 5 November 2026, a flow run that ends as No actions performed is charged no steps at all, trigger included. A condition that evaluates to false is therefore a step only when an action ran before it. We have corrected the article accordingly: the fix "move the filter into the trigger" has left the numbered list, because the run it rejects is already free, and the remaining fixes are numbered 1–5.
What does not count — and what does
Atlassian's page How is my usage calculated? is explicit: "Some steps don't count, even if you add them to your flow." The list is Log action, Create variable, Create lookup table, Re-fetch work item data and Lookup work items.
So the log action someone added to debug a rule and never removed costs nothing per run. Deleting it tidies the audit log, which is worth doing on a rule you read often, but it saves nothing on the bill. The same goes for a re-fetch after nothing changed and for a variable set once and never read: clutter, not cost. Also from the same page: a run that is aborted or throttled is not charged at all, not even for the steps that ran before it stopped, and a step that fails because of an error on Atlassian's side is not charged either. And since 5 November 2026, a run that performs no action at all is not charged either: it ends with the status No actions performed, and none of its steps count — not the trigger, not the condition that rejected it, not a branch that found nothing to work on.
What does count, once a run has performed at least one action: the trigger (one step — a filter set inside it, such as transitioned to Done, is part of that step), every condition that ran, including one that evaluated to false, every action, and a branch, which costs one step plus the steps on the path that runs. A condition that evaluates to false is a step only if an action ran before it; a run that the first condition rejects costs nothing. Rovo and agent components (Use Rovo, Use agent) are billed in Rovo credits, not steps; actions that call third-party AI, such as Use Cursor and Use GitHub Copilot, count as steps. The five patterns below are made of the things that count.
1. Conditions placed after actions
A rule edits the issue, adds a comment, and then checks whether the issue is in the right status. When the check fails, the edit and the comment have already happened — you paid for them, and you may have to undo them. That rejected run pays the trigger, both actions and the condition. With the condition first, the same run performs no action, ends as No actions performed and costs nothing: the saving is the whole rejected run, not just the two actions.
Fix: every condition that does not depend on an action's result belongs above the first action. This is the one pattern on the list that is a correctness bug as well as a cost bug.

Cost findings say what to change and what it saves
2. Several plain conditions one JQL condition could replace
Three Work item fields conditions in a row — the type is Bug, the priority is High, the component is Billing — because each was added on a different day. Each one is a step on every run that reaches it.
Fix: one JQL condition with issuetype = Bug AND priority = High AND component = Billing is one step. On runs that pass, three steps become one. On runs that fail there is nothing to save: a run that performs no action is free whichever condition rejected it — unless an action came before the conditions, which is pattern 1.
3. Consecutive edits of the same issue
Three Edit work item actions in a row, each setting one field, because they were added on three different days. One edit action can set all three fields.
Fix: merge them. Three steps become one, and the issue gets one update in its history instead of three — which also stops three separate change events waking up whatever listens to that project.
4. A branch used as a yes/no check
A branch exists to run a set of steps for each of several work items — the sub-tasks, the linked items, the results of a JQL. Used on the current work item alone, with a condition inside to decide whether to carry on, it is a gate that, on every run that goes on to act, costs one step for the branch plus one for the condition, where a plain condition at the top level costs one.
Fix: replace the branch with the condition it was wrapping. Keep branches for the case they are made for: more than one work item.
5. A schedule that rescans everything
A scheduled rule runs on a JQL that returns every issue in the project, then a condition inside the loop picks the handful that matter. A thousand issues become a thousand condition steps on every night the rule acts on at least one of them.
Fix: push the filter into the schedule's JQL, or tick Only include work items that have changed since the last time this flow executed — that is what the app's finding points at. The loop then iterates over the matches instead of over everything, and the cost drops to what the rule actually acts on.
The other patterns
Automation Map checks more patterns of this kind than these five. The rest are narrower: rules that do nothing but log — the log itself is free, but the trigger and any condition in front of it are paid on every run, for no outcome; a first condition the trigger's own filter could apply (transitioned to Done as the To-status, one field in a Field value changed trigger) — moving it into the trigger keeps the rule from firing and the audit log clean, but since 5 November 2026 it saves nothing on the bill, because the run that condition rejects is already free; site-wide rules that then admit only a few spaces (projects) with a condition — the events they reject now cost nothing either, so scoping them stops the rule from firing, not a charge; copies of the same rule running side by side; rules racing on one event, each paying its own run for the same change; schedules that fire a dozen or more times a day; and constant edits a post-function or field default could do. Each finding names the step and explains why it is removable; most say how many steps the fix saves. If a finding points at a log action or a re-fetch, read it as tidiness, not as a saving.
NOTE: Every finding is a suggestion to review, not an automatic change. The app never edits your rules — it works from an export you upload and has no permission to change anything in Jira. You read the finding, decide, and make the change in Jira yourself.
What this is worth
The first version of this article quoted the share of removable steps the app found on one real site. That count included log actions and re-fetches, which Atlassian does not bill, so we have withdrawn it rather than reprint a figure we know is too high. We will publish a new one when it has been counted with the free components left out.
What you can get before December is the cost of one run, per rule, with the removable steps named. Multiply by how often your rules actually run — that count is in Jira's Performance insights — and you have the annual figure for your own site, which is the only one that matters.
FAQ
How do I find wasted steps in my Jira automation rules (flows)?
Export your rules from Settings → System → Automation flows → Export flows and load the file into Automation Map. Each rule card lists the steps one run spends and which of them the app's detectors flag as removable.
Are log actions, re-fetches and variables billed as steps?
No. Atlassian's usage page lists Log action, Create variable, Create lookup table, Re-fetch work item data and Lookup work items as components that do not count, even when they are in the flow. Deleting them tidies the audit log and saves nothing on the bill. The trigger and the conditions in front of a log action are still paid steps.
Does removing these steps change what my rules do?
Not for most of the patterns above — three field conditions merged into one JQL condition, three edits merged into one, or a branch replaced by the condition it wrapped produce the same outcome for fewer steps. The one exception is conditions placed after actions: fixing that changes behaviour, because the rule stops acting on work items it should never have touched.
Can the trigger do the filtering?
Often: a Work item transitioned trigger filters by From and To status, and Field value changed watches named fields. A filter inside the trigger is part of the trigger's one step, so either can replace a first condition. Since 5 November 2026 that saves nothing on the bill — a run the first condition rejects performs no action and is free — but it keeps the rule from firing at all, so the audit log and the run count stay clean.
How much can I expect to save?
It depends on how many of your rules carry these patterns and how often they run, and we no longer quote a site-wide share: the figure in the first version of this article counted log actions and re-fetches as savings. The app shows the steps per run and the removable steps for each rule; multiply by that rule's run count from Jira's Performance insights.
Will the app change my rules for me?
No. It works from an export you upload and has no permission to change anything in Jira. Findings are suggestions with the reasoning shown; you make the edit in Jira.
Why can't a tool tell me the money, only the steps?
Money is steps times frequency. Frequency lives in Jira's Performance insights (execution count per flow) and the audit log, neither of which has a public API, so no external tool reads them. The steps are in the rule's configuration and can be counted exactly.
Start with the expensive ones
You do not need to review a thousand rules. On Advanced, the Audit page sorts every rule by what its fixes would save.