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:

Condition: (Priority = High OR Priority = Critical) AND
           (Component contains "Backend" OR Component contains "Frontend") AND
           (User in group "Developers" OR User in group "QA")

Evaluation: Slower (multiple fields, multiple comparisons)

Optimization:

• Use simple equality checks when possible

• Avoid complex OR/AND combinations unless necessary

• Break complex rules into multiple simpler rules if performance issues occur

Avoid Deep Nesting

Slower:

If Priority = High AND (
  Component = Backend AND (
    User in Developers OR (
      User in QA AND Status = Testing
    )
  )
)

Better:

Rule 1: Condition: Priority = High AND Component = Backend
Rule 2: Condition: User in Developers OR User in QA

Separate rules with simpler conditions evaluate faster than one complex rule.

---

Avoid Unnecessary Field References

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

Don't Over-Reference Fields

Inefficient:

Condition: Priority = High
Action: Set Component (references Priority, Description, Assignee, Labels)

If action only needs Priority, don't reference other fields.

Efficient:

Condition: Priority = High
Action: Set Component (references only Priority)

Why this matters:

• Each field reference requires data fetch

• More field references = more API calls

• More API calls = slower evaluation

Smart Values: Reference Only What You Need

Inefficient Smart Value:

Set Due Date = if(
  field("priority") == "High" AND
  field("component") == "Backend" AND
  field("assignee") != null AND
  field("labels").length > 0,
  today().plusDays(1),
  today().plusDays(7)
)

References 4 fields when only 1-2 are needed.

Efficient Smart Value:

Set Due Date = if(
  field("priority") == "High",
  today().plusDays(1),
  today().plusDays(7)
)

References only priority field.

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: Dynamic Screen Rules 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.

Consolidate Related Rules

Inefficient (3 rules):

Rule 1: Show Field A when Priority = High
Rule 2: Show Field B when Priority = High
Rule 3: Show Field C when Priority = High

More efficient (1 rule with multiple actions, if supported):

Rule: When Priority = High, show Fields A, B, C

Note: Dynamic Screen Rules may not support multiple actions per rule. Check if consolidation is possible, otherwise accept multiple rules.

---

Optimize Smart Values

Use Simple Date Functions

Slower:

Set Due Date = if(
  today().dayOfWeek() == "Monday",
  today().plusDays(7),
  if(today().dayOfWeek() == "Tuesday", today().plusDays(6), ...)
)

Faster:

Set Due Date = nextMonday()

Built-in date functions are optimized. Use them instead of complex calculations.

Avoid Complex Calculations

Slower:

Set Field = field("estimate") * 1.2 + field("buffer") - field("completed")

Faster:

• Use simpler calculations

• Or perform complex math in Jira Automation (post-creation) instead of during form load

---

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

---

Related Pages

Design:

• Designing Effective Rules - Create efficient rules

Organization:

• Organizing Rules - Structure reduces complexity

Testing:

• Testing Rules - Include performance testing

Limitations:

• Known Platform Limitations - Platform constraints

Troubleshooting:

• Common Issues - Performance problems

• Debugging Rules - Debug slow rules

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