Skip to main content

Performance Considerations

Well-designed rules perform efficiently even in large rule sets. This guide provides practical tips for optimizing rule performance and avoiding slowdowns.

When Performance Matters​

Small rule sets (1-20 rules): Performance is rarely an issue Medium rule sets (20-50 rules): Start monitoring performance Large rule sets (50+ rules): Performance optimization becomes important

Signs of performance issues:

  • Form loading takes 2+ seconds
  • Noticeable delay when changing field values
  • Spinner icon visible for extended time
  • Browser becomes sluggish

Minimize Condition Complexity​

Principle: Simple conditions evaluate faster than complex conditions.

Keep Conditions Simple​

Good:

Condition: Priority = High

Evaluation: Fast (single field, simple comparison)

Slower:

Conditions (AND): Priority equals High
                  Summary contains backend
                  Current user is in group "Developers"

Evaluation: Slower (multiple fields, multiple comparisons)

Optimization:

  • Use simple equality checks when possible
  • Avoid long lists of conditions unless necessary
  • Break complex rules into multiple simpler rules if performance issues occur

Avoid Unnecessary Field References​

Principle: Only reference fields actually used in conditions or actions.

Smart Values: Reference Only What You Need​

Each field() in a Smart Value ties the rule to that field: when the field changes, the rule runs again and sets the value again. Use field() only when the value really depends on another field.

Depends on another field:

Set Review Date = {{subtractBusinessDays(field("duedate"), 3)}}

Needs no other field:

Set Due Date = {{today().plusBusinessDays(3)}}

Best practice: Keep Smart Values simple and reference minimum required fields.

Be Specific with Context Filters​

Principle: Narrow scope reduces evaluation overhead.

Use Specific Scopes​

Less efficient:

Scope: All issue types
Condition: Issue Type = Bug

Rule evaluates for all issues, then filters by condition.

More efficient:

Scope: Bug
Condition: (other conditions)

Rule only evaluates for Bug issues.

Why this matters:

  • Scope filtering happens before condition evaluation
  • Narrower scope = fewer rule evaluations
  • Fewer evaluations = better performance

Target Specific Projects​

If using rules in multiple projects, be as specific as possible:

Less efficient:

  • Apply same rule to all projects
  • Rule evaluates everywhere, even where not needed

More efficient:

  • Create project-specific rules
  • Rules only evaluate in relevant projects

Note: Formify is per-project, so this is automatic. This tip applies if you're copying rules across projects.

Monitor Rule Count​

Principle: Too many rules per screen can impact performance.

Rule Count Guidelines​

Recommended limits per screen:

  • Global Issue Create: 20-30 rules maximum
  • Issue View: 20-30 rules maximum
  • Issue Transition: 15-25 rules maximum (per transition)

Warning signs:

  • 40+ rules on single screen
  • Forms load slowly
  • Users complain about sluggishness

UI Modifications Apps Limit​

Platform limit: Maximum 5 UI Modifications apps per project + issue type + screen

Performance impact:

  • Each app adds evaluation overhead
  • 5 apps with 10 rules each = 50 rules to evaluate
  • Consolidate functionality into fewer apps when possible

See Known Platform Limitations for details.

Inefficient (3 rules):

Rule 1: Hide Field A when Priority = Low
Rule 2: Hide Field A when Priority = Lowest
Rule 3: Hide Field A when Priority = Medium

More efficient (1 rule):

Rule: Hide Field A when Priority = Low OR Priority = Lowest OR Priority = Medium

Note: Each rule has one action on one field, so only rules on the same field with the same action can be merged. Rules for different fields stay separate.

Optimize Smart Values​

Use Simple Date Functions​

A Smart Value is one expression built from functions such as today(), nextWeek(), startOfWeek(), addDays() and .plusBusinessDays(). Pick the function that says what you mean:

Set Due Date = {{addWeeks(startOfWeek(), 1)}}

This gives next Monday without any extra calculation.

Put Decisions in Conditions​

Smart Values have no if/else and no arithmetic. When the value depends on the situation, give each case its own rule with its own condition:

Rule 1: Set Due Date = {{today().plusBusinessDays(1)}} when Priority = High
Rule 2: Set Due Date = {{nextWeek()}} when Priority not equals High

Calculations across several fields belong in Jira Automation after the issue is created.

Performance Testing​

Measure Form Load Time​

How to measure:

  1. Open browser Developer Tools (F12)
  2. Go to Performance tab
  3. Start recording
  4. Open Create issue dialog (or Issue View)
  5. Stop recording when form fully loads
  6. Check timeline for loading duration

Benchmarks:

  • Good: Under 1 second
  • Acceptable: 1-2 seconds
  • Slow: 2-3 seconds
  • Problem: Over 3 seconds

Test with Different Rule Counts​

Methodology:

  1. Measure performance with 10 rules
  2. Add 10 more rules
  3. Re-measure performance
  4. Repeat until you identify performance threshold

Goal: Find the rule count where performance degrades, then stay below that threshold.

Performance Optimization Checklist​

Rule design:

  • Conditions are simple (no deep nesting)
  • Only necessary fields referenced
  • Scope is as specific as possible
  • Smart Values use simple functions

Rule set:

  • Rule count per screen is reasonable (<30)
  • Related rules consolidated where possible
  • No duplicate or redundant rules
  • Form load time under 2 seconds

Monitoring:

  • Tested performance with real users
  • Browser console shows no errors
  • No user complaints about slowness

When to Refactor for Performance​

Refactor if:

  • Form load time exceeds 3 seconds
  • Users report sluggishness
  • Browser performance profiling shows rule evaluation bottleneck
  • Rule count exceeds 40 per screen

Refactoring strategies:

  1. Simplify conditions - break complex rules into simpler ones
  2. Reduce rule count - consolidate or remove unnecessary rules
  3. Narrow scope - target specific issue types instead of "all"
  4. Optimize Smart Values - use built-in functions instead of complex calculations
  5. Move logic elsewhere - use Jira Automation for post-creation processing

Platform Performance Factors​

Beyond your control:

Jira Cloud performance:

  • Atlassian infrastructure load
  • Network latency
  • User's internet connection speed

UI Modifications API:

  • API evaluation speed (Atlassian-controlled)
  • Browser rendering performance

User's environment:

  • Browser type and version
  • Device performance (mobile vs desktop)
  • Active browser extensions

What you can control:

  • Rule complexity
  • Number of rules
  • Field references
  • Smart Value complexity

Focus on optimizing what you can control.

Troubleshooting Performance Issues​

Slow Form Loading​

Diagnosis:

  1. Check rule count (how many rules per screen?)
  2. Check condition complexity (are conditions simple?)
  3. Check browser console (any errors?)
  4. Test with rules disabled (does performance improve?)

Solutions:

  • Reduce rule count
  • Simplify complex conditions
  • Remove unused rules
  • Consolidate related rules

Delayed Field Updates​

Diagnosis:

  • Which field changes trigger slowness?
  • How many rules reference that field?
  • Are Smart Values complex?

Solutions:

  • Simplify Smart Values
  • Reduce rules referencing that field
  • Use simpler conditions

Browser Becomes Unresponsive​

Diagnosis:

  • Extremely high rule count (50+)?
  • Very complex Smart Values?
  • Multiple UI Modifications apps?

Solutions:

  • Significantly reduce rule count
  • Disable other UI Modifications apps
  • Contact support for advanced troubleshooting

Design:

Organization:

Testing:

Limitations:

Troubleshooting:

Well-optimized rules provide instant feedback to users. Keep rules simple, specific, and focused for best performance.