How to Use Argon's JQL Search Tools for Smarter Project Planning in Jira

Jira's built-in JQL is powerful, but when it comes to real-world project planning, you quickly hit its limits. You can't easily query across issue hierarchies, track how long work has been stuck in a status, or find issues based on complex relationship patterns. That's exactly the gap Argon fills.

In this post, we'll walk through practical ways to use Argon's advanced JQL search tools to level up your project planning workflow in Jira Cloud.

The Problem: Standard JQL Falls Short for Planning

Project managers and team leads often need to answer questions like:

• Which epics have stories that have been "In Progress" for more than 5 days?
• Are there any blockers across my entire project hierarchy?
• Which issues were recently transitioned by someone outside the core team?
• What's the total story point count for a filtered set of issues?

Native JQL can't answer most of these. You'd typically resort to exporting data to spreadsheets, building custom dashboards, or installing multiple plugins. Argon solves this with a single set of JQL extensions that work directly in Jira's search bar.

1. Plan Sprints with Hierarchy Queries

One of Argon's most powerful features for planning is Links & Hierarchy queries. These let you traverse the full issue tree — from epics down to subtasks — using JQL alone. But here's where Argon really shines compared to native Jira: instead of querying children of a single issue, Argon accepts a full JQL subquery as its argument. This means you can define complex, dynamic criteria to find children across many epics at once.

Use case: You're planning the next sprint and need to see all child issues across every epic in the MARS project that are still in the backlog. In native Jira, you'd have to look up each epic one by one. With Argon, one query does it all:

This single query finds every epic in the MARS project, then returns all their children that are still in the backlog — no matter how many epics that is. The subquery inside childrenOf() is a standard JQL expression, so you can make it as specific as you need. For example, narrow it to only high-priority epics:

Or find children of stories across multiple projects at once:

You can also go the other direction — find parent epics that have unresolved children blocking delivery:

This approach scales beautifully. As your projects grow and epics multiply, your planning queries don't need to change — they dynamically adapt because they're based on criteria, not hardcoded issue keys.

2. Identify Bottlenecks with Time in Status

Knowing where work gets stuck is critical for planning. Argon provides two ways to query time in status: the timeInStatus function and thetimeExpression function that works with Argon's built-in Time in Status fields.

Use case: Find issues in the MARS project that have been "In Review" for more than 3 days — a sign that your review process might be a bottleneck.

Notice how the first argument is a JQL subquery — just like the hierarchy functions. This means you can scope your time-based queries to any set of issues you need. You can also use Argon's Time in Status fields directly with timeExpression:

This is invaluable for retrospectives and sprint planning. If you consistently see issues aging in certain statuses, you can proactively allocate more resources or adjust your process before the next sprint.

For a deeper walkthrough of this one function — operators, time formats, and copy-paste examples — see our full guide on how to query time in status with JQL.

3. Track Who Changed What with Changed By & Transitioned By

Planning isn't just about issues — it's about people. Argon's changedBy andtransitionedBy functions let you query based on who made specific changes, when they made them, and to which fields or statuses.

Use case: Find all issues in the MARS project that were moved to "Done" by a specific person in Q1 (useful for auditing and process compliance):

You can also use changedBy to find issues where a specific field was modified by someone — for example, find all issues where the priority was changed in the last quarter:

For project leads, this helps understand team dynamics, audit who is transitioning work, and identify where handoffs are happening unexpectedly.

4. Search Comments, Worklogs, and Attachments

During planning, you often need context buried in comments, worklogs, or attachments. Argon's Activity functions — commented, worklog, and attachment — let you find issues based on their activity history, with filtering by author, date range, and content.

Use case: Find all issues in the v2.5 release where someone mentioned "deployment" in the comments, helping you identify release dependencies:

Need to find issues with significant logged work? Use worklog to filter by time spent — for example, find issues where someone logged more than 4 hours:

You can even find issues with specific attachment types — handy for tracking design specs or documentation:

This is particularly useful when preparing release notes or identifying issues that need special attention during deployment planning.

5. Use Regex for Advanced Filtering

Sometimes you need pattern-based matching that goes beyond simple text search. Argon'sregex function brings full regular expression support to JQL, letting you match patterns in any text field — summary, description, or even custom fields.

Use case: Find all issues in the MARS project with summary matching a specific naming convention (e.g., issues prefixed with a module code):

Or search descriptions for version numbers matching a semantic versioning pattern:

This helps teams that use naming conventions for categorization find and plan work for specific modules or components without relying on labels or components.

6. Make Data-Driven Decisions with Math Functions

Argon's min, max, and avg functions let you perform statistical calculations directly in JQL queries. This is a game-changer for capacity planning — you can compare individual issue values against aggregates across your project.

Use case: Find issues with story points above the project average — these are your high-effort items that might need to be broken down:

Or find outliers by comparing against the maximum — useful for spotting estimation inconsistencies across teams:

By comparing individual issues against aggregate metrics, you can catch scope creep, identify stories that need splitting, and make more accurate sprint capacity decisions.

Bringing It All Together: A Planning Workflow

Here's how a project manager might use Argon in their weekly planning routine:

1. Monday morning review: Use timeInStatus or timeExpression to find any issues aging in "In Progress" or "In Review" from last week. Triage them before standup.
2. Sprint planning: Use childrenOf with subqueries to pull all backlog items across every epic in your project — no need to list individual issue keys. Filter by priority, fix version, and dependencies.
3. Mid-week check: Use avg and max to compare individual story points against project averages. Flag any issues that look like outliers needing breakdown.
4. Release prep: Use commented to find issues mentioning deployment concerns. Use changedBy to audit recent field changes and transitionedBy for status transitions.

The best part? All these queries can be saved as Jira filters and shared with your team, pinned to dashboards, or used as the source for any Jira-compatible visualization — whether that's a Gantt chart, a board, or a report.

Why Argon Is Built Different

Unlike other JQL extension tools that rely on external services and REST APIs, Argon is built natively on Atlassian Forge. This means:

• Real-time indexing — no sync delays or stale data. Your queries always reflect the current state of your project.
• No external dependencies — everything runs within Atlassian's infrastructure, so there's nothing extra to manage or secure.
• Data residency compliance — your data never leaves Atlassian's boundaries, which is critical for teams in regulated industries.

This architecture makes Argon especially reliable for planning workflows where accuracy and speed matter. When you're making decisions in a sprint planning meeting, you need results you can trust — not data that was last synced 15 minutes ago.

Get Started

Ready to upgrade your project planning with smarter JQL? Argon is available on the Atlassian Marketplace with a free tier to get you started. Install it, try the queries from this post, and see how much faster you can find the information that matters.