Jira Tickets Data Quality Check

[ajay rajput]

I want to build a solution to track all the Jira tickets(Epics, Features, everything) that are missing relevant fields inputs like (Acceptance Criteria, Exec Summary, Labels etc).

After getting the list of tickets that needs attention, I wanna send individual comms to assignees/reporters to fill out the details.

If suppose a reporter has three tickets under his name, then a single comm with the concerned fields shall be communicated to him.

Is there a way to build this?

[Igor Medeiros - Modus Create]

Hi @ajay rajput 

Adding to what Matthew and the others sent, the JQL plus Automation route covers finding the incomplete tickets. The harder requirement is the last one. You want one email per reporter that lists only their own flagged tickets. Native Automation fires per issue, so consolidating three tickets into a single message per person is where it breaks down.

Our app Notification Assistant for Jira sends scheduled, JQL-filtered notifications grouped by recipient. Each assignee or reporter then gets one digest listing only their own issues.

Feel free to reach out if you'd like to learn more.

[Matthew Joslin_AppFox_]

Native Jira doesn't have a single built-in feature that bundles several missing-field tickets into one message per person - you have to build it with Jira Automation using a scheduled JQL trigger, a Lookup Issues action, then branch/group by reporter before sending the email or comment, or hand the grouping off to an external script against the REST API if the automation gets too fiddly across several fields.

Before automating the nagging though, it's worth asking why the fields are empty so often. If a field gets skipped on nearly every ticket, teams either don't understand it or don't need it on that screen.

Auditing custom field usage and emptiness rates across projects is exactly the kind of health-check tools like Optimizer for Jira are built for, which can help you decide whether to enforce, redesign, or retire a field rather than just chasing people to fill it in. There's also now a 'monitoring' feature, which helps you keep track of a particular field over time and see how much it's actually being used, before you decide to do something about it. Might make sense for your use case?

[Laura Marin - Millarum]

This is a classic headache. Every single growing team runs into this exact "dirty data" issue where people forget to fill out descriptions or labels.

​You can definitely build a solution for this, but honestly, trying to force Jira to do the whole thing internally can get messy fast. Here is the breakdown from someone who has been down this rabbit hole:

​The Jira Automation Way (High Drama)

You can technically use Jira's native automation. You’d set a weekly timer, run a JQL search for empty fields, and then try to loop through the reporters. But pulling off that "single email for multiple tickets" trick inside Jira requires some really annoying, complex configurations with Smart Values and variable tracking. If a reporter has 5 broken tickets, Jira might accidentally spam them with 5 separate emails anyway, or the automation rule will just break halfway through. It's a bit of a nightmare to debug.

​The "Outside Jira" Way (Much Easier & Cleaner)

If you want to save yourself the stress, the best way to handle this is actually writing a quick, simple script outside of Jira using the REST API.

​If you or someone on your team can write a basic Python or Node.js script, you can set it to run every Monday morning and do all the heavy lifting:

​Grab the data: Have the script call the Jira API to pull all tickets where Acceptance Criteria is EMPTY.
​Bundle it up: Use the script to group those tickets by the reporter's email. It's super easy to write code that says: "Hey, John Doe has these 3 broken tickets."
​Send one message: Have the script formatting those 3 tickets into a single, clean email or Slack message and send it directly to John.
​Doing it outside of Jira keeps your system fast, doesn't waste your Jira automation limits, and gives you 100% control over making the email look exactly how you want.

​Are you looking to keep this strictly inside Jira's built-in tools, or do you have a place where you could run a lightweight script? Happy to point you in the right direction

[Bartek Szajkowski _ Orbiscend OU]

Hello @ajay rajput 

Thanks for your message.

If you are open for third-party app, I would like to recommend to check JQL Argon Powerful Search.  JQL Argon  

Your request is a good question — this is doable, but it splits into two separate problems that need two different tools:

1. Finding the tickets missing key fields → this is a JQL problem (JQL Argon helps here).
2. Grouping by reporter/assignee and sending one consolidated message per person → this is a notification/automation problem (native Jira Automation, but not JQL/Argon).

JQL Argon doesn't send emails or comments itself — it's a JQL search engine.
But it's the piece that makes step 1 accurate, and it feeds directly into Jira Automation for step 2.

Part 1 — Finding tickets missing required fields

For simple text/label fields, native JQL already supports IS EMPTY:

issuetype in (Epic, "New Feature", Story)
AND status != Done
AND (
"Acceptance Criteria" is EMPTY
OR "Exec Summary" is EMPTY
OR labels is EMPTY
)

That covers "field has nothing in it." Where Argon's fieldCount function helps is when "missing" means more than empty — e.g. you require at least 2 labels, not just any label:

issue < fieldCount("issuetype in (Epic, Story)", "labels", 2)

If you only want to police Epics and their children (not standalone tasks), Argon's hierarchy function keeps that scoped:

issue in childrenOf("issuetype = Epic")
AND "Acceptance Criteria" is EMPTY

Save this as a filter — it's the input for Part 2.

Part 2 — One consolidated comm per reporter (native Jira Automation)

This part is outside what JQL Argon (or any JQL) can do — JQL returns issues, it doesn't group people or send messages. The standard way to do it is a Jira Automation rule:

Division of responsibility

Task	Tool
Detect tickets missing simple fields	Native JQL (IS EMPTY)
Detect tickets missing thresholds (e.g. "fewer than 2 labels")	JQL Argon fieldCount
Scope the check to Epics/children only	JQL Argon childrenOf / parentOf
Group results by reporter/assignee	Jira Automation (Lookup issues + Branch, grouped)
Send the consolidated message	Jira Automation (Send email / Add comment)

Hope that clears it up — happy to help and hope you will find my answer useful.

Greetings

Bartek  from Orbiscend OU
(JQL Argon app provider)

[Trudy P Claspill]

Hello @ajay rajput 

If the fields are relevant and important have you considered making them required so that they can't be left empty?

[Viswanathan Ramachandran]

hi @ajay rajput 

Good thought. Yes, this is achievable.

A practical approach is to treat it as a data quality/compliance process rather than just a reporting exercise.

Step 1: Identify incomplete issues

Create one or more JQL filters that identify issues with missing mandatory fields. For example:

• Description is EMPTY
• Components is EMPTY

You can combine these into a single filter (or several filters depending on your governance model) to capture all Epics, Features, Stories, Tasks, Bugs, etc.

Step 2: Aggregate by assignee or reporter

Instead of sending one notification per issue, group the results by Assignee (or Reporter if that’s your ownership model). This provides each user with a single summary listing all their issues requiring attention.

Step 3: Automate the communication

There are several ways to do this:

• Jira Automation (suitable for smaller environments)
• ScriptRunner (great for Data Center and advanced logic)
• A scheduled Python using the Jira REST API endpoints

The process would typically:

1. Run on a schedule weekly better
2. Execute the JQL.
3. Group issues by Assignee or Reporter.
4. Generate a consolidated email or Teams message.
5. Include direct links to each issue and identify which fields are missing.

Step 4: Governance reporting

In addition to notifying users, I’d recommend maintaining a dashboard showing:

• Number of incomplete issues by project
• Most frequently missing fields
• Trends over time
• Age of non-compliant issues

This helps project managers and governance teams monitor data quality instead of relying solely on individual reminders.

regards

[Gor Greyan]

Hi @ajay rajput

Welcome to the Atlassian Community!

I would approach it in two phases.

First, define the data quality rules that every issue should meet (the criterias that you mentioned). You can then use JQL and Jira Automation, or a ScriptRunner to periodically identify issues that don't satisfy those rules.

Once you have the list, you can iterate through the results and group the issues by the Reporter or Assignee. For example, if one reporter owns three issues with missing information, you can compile those three issue keys into a single message or email instead of sending three separate notifications. The same approach can be used for assignees.

Depending on your environment, this can be implemented using a scheduled Jira Automation rule or a ScriptRunner scheduled job.