Automation has become one of the most important parts of Jira and Jira Service Management administration.
For years, many of us designed rules mainly around a simple question:
Does the automation work?
With Atlassian’s move from automation runs to automation steps, there is now another question we need to ask:
How much does this automation actually consume every time it works?
That may sound like a small change in terminology, but it significantly changes how automation rules should be designed, reviewed, and governed.
In this article, I want to break down the difference between the old run-based model and the new step-based model, show how the same rule can behave very differently from a usage perspective, and share some practical optimization patterns for Jira admins.
1. The old model: one execution, one run
Under the previous Jira Cloud automation usage model, a successful rule execution generally counted as one automation run.
That meant a simple rule such as:
Trigger → Action
and a much more complex rule such as:
Trigger → Conditions → Branch → Multiple Actions
could both consume one run when executed successfully.
From a usage perspective, the internal complexity of the rule was not the main factor.
This encouraged admins to think mostly about:
- how frequently a rule was triggered;
- how many issues caused it to execute;
- whether rules were unnecessarily triggering each other.
A large automation could contain many components, but one successful execution was still fundamentally measured as one run.
2. The new model: usage is measured in steps
Automation usage is now measured using automation steps.
A step is an executed component of an automation flow.
The main components that count include:
- Triggers
- Conditions
- Actions
- Branches
- Loops
This means that rule complexity now matters directly.
A rule containing ten executed components can consume considerably more allowance than a rule containing only two.
This is the most important conceptual change:
Before, we mainly optimized how often a rule ran. Now we also need to optimize what happens inside each run.
3. A simple example
Imagine this automation:
- Work item created
- Check if Project = OPS
- Check if Issue Type = Bug
- Branch to related work items
- Edit the related work item
Under the previous model, a successful execution could count as:
1 automation run
Under the step model, the same execution can consume:
Component | Steps |
|---|
Trigger | 1 |
Project condition | 1 |
Issue Type condition | 1 |
Branch | 1 |
Edit action | 1 |
Total | 5 |
And this is still a simplified example.
If the branch processes multiple related work items, the actions inside the branch can execute multiple times.
That means the actual step usage can increase depending on runtime behavior.
This is where automation architecture becomes much more important.
4. Branches and loops deserve special attention
Branches are particularly important when reviewing automation usage.
Consider:
Trigger → Branch over subtasks → Edit each subtask
If the issue has three subtasks, the calculation is not simply:
Trigger + Branch + Edit = 3 steps
The Edit action executes once for every relevant subtask.
So the actual execution would look more like:
- Trigger: 1
- Branch: 1
- Edit subtask 1: 1
- Edit subtask 2: 1
- Edit subtask 3: 1
Total: 5 steps
Add conditions inside that branch and the consumption increases again.
This does not mean branches are bad.
It means branches should now be treated as potential usage multipliers and reviewed accordingly.
5. An important update: NO_ACTIONS_PERFORMED does not consume steps
There is an important detail that changed after Atlassian received feedback about the new model.
Starting November 5, 2026, flows that finish with:
NO_ACTIONS_PERFORMED
do not consume automation steps.
For example:
Trigger → Condition = false → Rule stops
If no action is ultimately performed, the run does not consume steps.
This is important because it means we should not interpret the new model as:
“Every trigger automatically costs one step no matter what happens.”
That is no longer accurate.
However, once the automation performs an action, the executed trigger, conditions, actions, branches, and loops involved in that flow become relevant to the usage calculation.
6. Not every component consumes a step
Another useful detail for admins is that some system-oriented components do not consume automation steps.
Examples currently documented by Atlassian include:
- Log action
- Create variable
- Create lookup table
- Re-fetch work item data
- Lookup work items
This is useful when designing rules.
For example, adding a Log action for troubleshooting does not mean you need to remove your diagnostic logging just to save automation allowance.
Likewise, using variables to make a rule easier to maintain should not be avoided simply because of concerns about step consumption.
7. Moving conditions earlier can make a difference
One optimization I find particularly interesting is moving filtering logic as early as possible.
Imagine this:
Trigger: Work item transitioned
followed by:
Condition: Status = Done
and then:
Action: Send notification
When all three execute, that is three steps.
But if the transition trigger itself can be configured specifically for:
Work item transitioned → To: Done
the flow becomes:
Trigger with criteria → Send notification
Now the same business requirement can be achieved with fewer executed components.
The lesson is not to remove useful conditions blindly.
The lesson is:
If the trigger can safely perform the filtering, avoid repeating the same filtering later in the automation.
8. Consolidate conditions where it makes sense
Suppose you have:
Condition 1: Project = OPS
Condition 2: Issue Type = Bug
Condition 3: Priority = High
Sometimes those checks can be represented as one condition block containing multiple criteria.
Atlassian counts a condition block with multiple criteria as one executed condition step.
Again, I would not optimize rules purely to reduce a number.
Readability and maintainability still matter.
But when auditing high-volume automations, duplicated or unnecessarily separated conditions are worth reviewing.
9. Start with the rules that run the most
If you manage dozens or hundreds of automation rules, manually optimizing every rule is probably not the best place to start.
Instead, focus on the automations with the greatest potential impact.
I would prioritize:
- High-frequency event triggers
- Scheduled rules
- Rules with large JQL searches
- Rules containing branches
- Rules containing loops
- Rules that update multiple related work items
- Rules that trigger other automation rules
A rule that runs twice per month is rarely the first optimization target.
A rule triggered thousands of times every day deserves much more attention.
10. A practical before-and-after example
Imagine a scheduled automation that runs every hour.
Original design
Scheduled trigger
↓
JQL search
↓
Condition: Project = OPS
↓
Condition: Issue Type = Bug
↓
Branch
↓
Edit work item
If the scheduled query can safely be changed to retrieve only:
project = OPS AND issuetype = Bug
then the two downstream conditions may no longer be necessary.
The automation becomes:
Scheduled trigger with targeted JQL
↓
Branch
↓
Edit work item
The business result can remain the same while the execution path becomes smaller.
That is the type of optimization Jira admins should now be looking for.
11. Step optimization should not become rule golf
There is also a danger here.
Once usage is measured by steps, admins may become tempted to remove every condition possible simply to reduce consumption.
I don't think that is a good automation strategy.
A good rule still needs to be:
- understandable;
- maintainable;
- safe;
- auditable;
- predictable.
Saving one step is not worth creating a rule that nobody understands six months later.
The objective should be:
Remove unnecessary execution, not necessary logic.
12. Allowances are also changing how we think about governance
Another major change is that automation allowances are now pooled across eligible Atlassian apps at the organization level.
For Jira, Atlassian currently documents monthly allowances such as:
Jira plan | Automation allowance |
|---|
Free | 150 steps per subscription |
Standard | 400 steps per user |
Premium | 750 steps per user |
Enterprise | 1,000 steps per user |
Jira Service Management / Service Collection has different allowances, including significantly larger per-user allocations on paid plans.
This means automation governance is becoming less of a project-level concern and more of an organization-level capacity management topic.
An inefficient rule in one area can potentially affect the automation pool available elsewhere.
13. Usage-based pricing adds another reason to monitor automation
Another important date for admins is December 3, 2026.
Atlassian has announced that billing for automation usage beyond the included allowance begins from that date for applicable plans.
Pay-as-you-go is enabled by default, although organization and billing admins can configure limits or disable it.
That changes automation optimization from being purely technical to potentially becoming a cost-management responsibility as well.
Automation architecture can now influence:
- platform performance;
- monthly allowances;
- operational continuity;
- and potentially the Atlassian bill.
14. My automation audit checklist
When reviewing an existing Jira automation environment, this is the checklist I would use:
Trigger
Can the trigger itself be made more specific?
Instead of:
Work item updated
could you use:
Field value changed
or another narrower trigger?
Conditions
Are multiple conditions checking information that could already be filtered by the trigger or JQL?
Can related checks safely be consolidated?
Scheduled rules
Is the JQL retrieving more work items than necessary?
Can the query itself identify exactly what needs processing?
Branches
How many related work items can this branch realistically process?
Could it fan out across dozens or hundreds of items?
Loops
How many times can the actions inside the loop execute?
Is the repetition genuinely required?
Rule chaining
Can one automation trigger another automation?
Could this create unexpected usage or recursion?
Frequency
Does this process really need to execute every five minutes?
Could it run every 15 minutes, hourly, or based on an event instead?
Audit log
Which automations are consuming the most steps?
Which executions are failing?
Which rules are repeatedly processing the same work?
15. From “Does it work?” to “Does it scale?”
For me, this is the biggest change introduced by the move from runs to steps.
The old mental model encouraged us to ask:
Does the rule execute correctly?
The new model adds another question:
Does the rule execute efficiently?
And for Jira administrators managing larger environments, I would add one more:
Will this design still make sense when usage grows 10x?
That is a much healthier way to think about automation architecture.
Final thoughts
Moving from runs to steps is more than a billing or usage change.
It changes the economics of automation design.
Complex rules are no longer equivalent to simple rules from a consumption perspective, and patterns that previously seemed harmless — broad triggers, unnecessary conditions, large branches, repeated actions — deserve another look.
At the same time, optimization should not mean aggressively stripping logic from every rule.
The goal should be to build automations that are:
efficient, understandable, maintainable, and predictable.
For Jira admins, I think automation auditing will increasingly become part of normal platform governance rather than something we only investigate after reaching a limit.
I’d be interested to hear how other admins are approaching this change:
Have you already started auditing your rules based on step consumption?
And if so:
Which automation patterns have surprised you the most?