Unlocking Atlassian Automation: Lookup Objects vs. Branch on AQL
When working with Atlassian Jira Automation and Assets, two key methods allow you to interact with Asset objects dynamically: Lookup Objects and Branch on AQL. While both serve similar purposes, they have distinct execution behaviors, performance considerations, and important limits you need to be aware of when designing automation workflows.
Let’s break it down to help you choose the best approach for your use case!
Understanding Lookup Objects
The Lookup Objects action allows you to query Assets using AQL (Asset Query Language) and store the resulting objects in a list. This data can then be referenced later in the automation using smart values.
Key Features:
- Retrieves a static list of objects matching your AQL query
- Allows processing results in bulk using smart values like
{{lookupObjects}} - Ideal for counting objects, logging, and generating summaries
- Can retrieve up to 100 objects at once
Example Usage:
Imagine you need to find all active servers and log their details. You could use:
ObjectType = "Server" AND Status = "Active"and then reference them in a smart value action:
Found {{lookupObjects.size}} active servers.
List: {{#lookupObjects}}- {{Name}} ({{Key}}){{/}}This approach is efficient for logging and bulk processing but doesn’t handle each object individually.
Understanding Branch on AQL
A Branch on AQL action creates a separate execution branch for each object returned by the AQL query. This means the automation processes objects one at a time instead of all at once.
Key Features:
- Executes actions sequentially per object
- Ideal for modifying, updating, or transitioning individual objects
- Can only retrieve up to 50 objects at a time
Example Usage:
If you want to update each active server from the previous example, you’d:
- Use Branch on AQL with the same query
- Inside the branch, apply individual updates (e.g., send a notification, update an attribute, or create a Jira issue, per object)
Since each object is handled separately, this approach is useful when unique actions are required per object.
Key Differences and Best Use Cases
| Feature | Lookup Objects | Branch on AQL |
| Execution Style | Bulk processing (all objects at once) | Per-object execution (one at a time) |
| Processing Method | Smart values (lookupObjects) | Individual object context |
| Object Limit | 100 objects max | 50 objects max |
| Use Case | Aggregations, logging, creating one issue for all objects | Updating objects, creating issues per object |
| Performance | More efficient for large datasets | Can be slower for large object sets |
| Flexibility | Can loop manually using {{#lookupObjects}} | Cannot process results as a group |
| Ideal When | Needing to store or display multiple objects at once | Acting on each object separately |
The Impact of Object Limits
Lookup Objects (100 max)
If your AQL query returns more than 100 objects, results will be truncated. You may need to refine your query to limit results, or split your automation into multiple rules.
Branch on AQL (50 max)
If more than 50 objects match the query, only the first 50 are processed. Since each object is handled separately, complex workflows may slow down execution. Consider using multiple automation rules if handling more than 50 objects is necessary.
Choosing the Right Approach for Your Automation
Use Lookup Objects when:
- You need to work with up to 100 objects at once
- You want to log, count, or summarize multiple objects
- You want to create one issue or message for all objects at once
Use Branch on AQL when:
- You need to process up to 50 objects, each requiring individual action
- You need to update, transition, or modify object attributes one by one
- You need to perform separate issue actions per object
Final Thoughts
Both Lookup Objects and Branch on AQL are powerful tools in Jira Automation, but understanding their limits and best use cases is crucial for optimizing your workflows.
- If you need bulk data processing, go with Lookup Objects
- If you need individual processing per object, use Branch on AQL
- Always consider the limits (100 vs. 50 objects) and adjust your automation strategy accordingly
Need help fine-tuning your automation? Drop a comment below or reach out! 🚀
These Solutions are Engineered by Humans
Did you find this article interesting? Does it match your skill set? Our customers often present us with problems that need customized solutions. In fact, we’re currently hiring for roles just like this and others here at Würth Phoenix.
Valentina Da Rold
Author
