The automation rules worth building
Six rules cover most of the value. The seventh is usually the one that starts a support ticket eight months later.
Jira automation is cheap to start and expensive to accumulate. The rules that pay back are the ones that remove a step somebody was doing many times a week, that fail loudly rather than silently, and that a colleague could read in thirty seconds. The ones that cost you are the ones that write data nobody asked for, run globally when they only needed one project, and burn a monthly run allowance on work that performs no action at all.
Count it before you automate it
The question is never whether a rule is possible. It is whether the thing it replaces happens often enough to be worth a permanent piece of configuration that outlives whoever wrote it.
So count first. Pick the step you are tempted to automate and tally it for one week. Twelve times a week at twenty seconds each is four minutes a week, roughly three hours a year. That is real, and a rule that reliably does it is worth building. Two times a week at twenty seconds is forty seconds a week, and the rule to do it will cost you more in the first hour of writing and testing than it will ever return.
Both of those are arithmetic you can do in a standup. The trap is the third case: the step happens constantly, so the rule looks obviously worth it, and nobody notices that the rule now fires several thousand times a month against a run allowance that is a documented number rather than an infinite resource.
That framing is the same one applied across delivery work generally in where automation pays in agency delivery. Jira just makes the mistake easier to make, because the cost is invisible until it is not.
A note on vocabulary, and where the real ceiling is
Atlassian's Jira Cloud automation documentation is mid-rename: what most people call a rule is called a flow across the current Cloud automation pages, and the same pages still use rule in places. This article uses rule, because that is what your team says out loud, and points at the pages under the new word.
The ceiling that actually governs what you can build is the monthly run allowance. Atlassian publishes it: for Jira Cloud, 100 runs a month on Free, 1,700 on Standard, 1,000 multiplied by the number of users on Premium, and unlimited on Enterprise. Unused runs do not roll over. Confluence Cloud is far tighter at 10, 100, and 1,000 multiplied by users respectively.
Put a real team against the Standard number. A rule triggered on every status transition, on a delivery team making sixty transitions a day across its clients, is roughly 60 times 22 working days, so about 1,320 runs a month from that one rule. On Standard you have 1,700. One well-intentioned rule can eat most of the site's monthly allowance, and the second and third rules then fail in ways nobody connects to the first one.
The counting rules matter as much as the number. A run counts only when the rule performs at least one action, and a run that performs several actions still counts once. Runs that perform no action do not count at all, which is why a condition placed early is not just tidy, it is the difference between a rule that costs you and one that does not. Five actions are also excluded outright: Log, Create variable, Create lookup table, Re-fetch work item data, and Lookup work items.
The six rules that earn their place
| Rule | Trigger | Why it survives |
|---|---|---|
| Move the parent to In Progress when its first child starts | Work item transitioned | Nobody ever remembers to do this, and every roll-up report depends on it being true |
| Comment on the blocked item when its blocker is closed | Work item transitioned, with a linked-item branch | Replaces the single most common cause of a card sitting untouched for a week |
| Flag work untouched for fourteen days | Scheduled, with a JQL search | Produces a shortlist for a human, which is the safest shape an automation can take |
| Set the reviewer as assignee when status becomes In Review | Field value changed | Removes a handoff step, and the failure is obvious immediately |
| Apply the client label when work is created in a client project | Work item created | Cross-client reporting depends on it, and humans apply labels inconsistently forever |
| Post to the delivery channel when a due date moves | Field value changed on due date | The one change clients care about, and the one nobody communicates |
These are the ones I would build on a new client site, in this order. Every one of them replaces a step a human was doing repeatedly, and every one of them fails visibly rather than quietly writing something wrong.
Note how many of them use a specific trigger rather than a general one. Atlassian's own optimisation guidance is that Field Value Changed is far more economical than Work Item Updated, because updating a work item can mean almost anything while a field change is one narrow event. The trigger reference also lets you narrow that trigger further by change type and by the operation that caused it: create, edit, transition or assign.
The rules that look worth building and are not
Auto-closing stale work. It is the most requested rule and the most damaging, because it converts a visible problem into an invisible one. The backlog stops looking bad and the work still is not done. If stale items are the problem, the fix is the flag rule above plus somebody whose job it is to read the flags.
Auto-assigning by round robin. It distributes work without distributing context, and the result is a queue where everyone owns something they have not read. It works for a genuine support rotation and fails for delivery work.
Anything that writes an estimate, a priority, or a date the team did not agree. A rule that sets a due date from a formula produces dates that look like commitments and are not, and by the time anybody notices, the tracker holds a hundred of them.
Anything that fires on Work Item Updated with no condition. It is the general trigger with the highest volume, and it is the classic way to spend a monthly run allowance on doing nothing. The wider pattern of automation producing more work than it removes is in automation that creates more work.
Scope is the setting almost everyone gets wrong
A rule's scope decides which projects it listens to. The default instinct is to make it global so it works everywhere, and Atlassian's optimisation guidance says the opposite: avoid global scope as much as possible, because events from projects with no matching rule are filtered out cheaply, and fewer rules then need queuing for execution.
For agency work the practical version is that a rule written for one client should be scoped to that client, and a rule that genuinely applies to all delivery projects should be multi-project with the projects named. Global means every project, including the internal one somebody made for holiday tracking, and including the next client project created by somebody who has never heard of your rule.
The same page also makes an argument people skip: review your rules when you review the process they support. A rule written for a workflow that has since changed is not neutral, it is actively enforcing a process nobody follows any more. If your statuses moved, your rules moved, and the design pressure behind that is in workflow design people will actually follow.
The limits that decide what is buildable
| Limit | Published value | What it rules out |
|---|---|---|
| Steps per rule | 65 conditions, branches and actions | The single mega-rule that handles every case with nested branches |
| Work items returned by a scheduled JQL search | 999 | A scheduled cleanup rule pointed at a whole site's backlog |
| Work items used by the Lookup work items action | First 100 only | Counting or summarising anything larger than a sprint's worth of work |
| Loop detection | 10 self-triggers in quick succession | Two rules that trigger each other, which is how most runaway rules happen |
Atlassian publishes automation service limits, and four of them change design decisions rather than merely constraining edge cases. These are the published values at time of writing, and they are the kind of number that moves, so check the page before you architect around one.
Test it like code, because it is code
Atlassian's debugging guidance is short and the first step is the one people skip: read the audit log before changing anything. Their diagnostic is precise. If the log shows no entries at all when you expected some, either the trigger is misconfigured or it has a filter on it that is not behaving the way you think, and no amount of editing the actions will fix that.
Two habits from that page are worth adopting permanently. Copy the rule and disable the original before you test, so reverting is one click rather than a reconstruction from memory. And wrap a value in the debug function to print it into the audit log as it evaluates, which turns a rule that mysteriously does the wrong thing into a rule you can watch think.
Document each rule where the team reads things, not only inside Jira. The name should say what it does and which client it serves, and there should be a line somewhere saying who asked for it and why. Eight months later that line is the difference between confidently deleting a rule and leaving it running because nobody dares.
Then be honest about the payback. A rule that saved four minutes a week saved four minutes a week, and the correct way to say that out loud, without inflating it into a business case, is in measuring time saved honestly. Automation is a good investment at this scale precisely because the individual wins are small and real, which is also the standard applied when a tracker is set up inside a fractional technical project management engagement.
One last practical note. Scheduled rules that run JQL are the most useful category and the easiest to write badly, because a query that returns almost the right rows produces an automation that acts on almost the right work. Get the query right on its own first, using the traps listed in the JQL queries a delivery lead uses weekly, and only then wrap a rule around it.