Jira ticket validator that killed the refinement bottleneck (70% less rework)

Context

Mid-size product/tech department. Four squads working in parallel with a shared Jira backlog. The rule was: "before refinement, the ticket needs acceptance criteria, mockup if relevant, dependencies identified and an owner". The reality: 40% of tickets reached refinement with empty fields.

The typical pattern: someone created the ticket on a Tuesday, no one looked at it until Friday (refinement), Friday they discovered half the info was missing, had to ask the author, the author was in another meeting, the ticket slipped to next sprint. Result: Monday's sprint planning started with fewer refined tickets than needed.

The challenge

• Validate on creation, not on refinement. The problem wasn't missing info, it was detecting it days late. We needed real-time validation.
• Don't change Jira templates. The client had iterated their templates for years and didn't want to touch them. Validation had to live outside Jira.
• No new meetings. Any solution that meant "now we have a Wednesday meeting" was a no-go.

Approach

Internal webapp deployed on client infra, hooked to Jira via webhooks:

1. Discovery (1 week). Reviewed 200 historical tickets to identify "bad ticket" patterns: vague acceptance criteria, unmentioned dependencies, missing mockups, unassigned owner, no estimate. 9 validation rules emerged.
2. Validation webapp (weeks 2-3). App built on client infra subscribes to Jira webhooks. Every ticket creation or update triggers the 9 rules in under a second. If issues are found, the ticket gets tagged and the bot comments with a concrete checklist.
3. Author notification (week 4). Slack integration: if the ticket is still flagged after 24h, the author gets a DM with the checklist and a "mark as fixed" button that re-runs validation.
4. Backlog quality dashboard (weeks 5-6). Internal panel with metrics: % of tickets entering clean, authors with highest flag ratio, rules that fail most. For PMs to detect where to coach the team, not to assign blame.

Stack: internal webapp with AI-first dev assistance, Jira API, Slack integration, internal database for history. Everything deployed on client infrastructure, no data left.

Results

• ~70% reduction in rework (from 40% of tickets bouncing back to 12%).
• Refinements that lasted 90 min dropped to 50, because "this isn't clear" stopped happening.
• Sprint planning starts with a fully refined backlog consistently since week 6.
• Backlog quality metrics available to PMs for the first time, without manual data extraction.
• 0 new meetings introduced. All validation happens in background or async via Slack.

Lesson applicable

The product team bottleneck isn't dev speed. It's latency between writing a ticket and detecting that the ticket is incomplete. That latency is where real sprint velocity evaporates.

The most underrated piece wasn't the automatic validation, it was the backlog quality dashboard. Once PMs saw which authors consistently failed "acceptance criteria", they could run targeted 1:1 coaching. The tool didn't just clean tickets, it upskilled the team.

Technical lesson: aggressive validation (blocking the author) creates cultural pushback. Validation that flags and notifies without blocking is better received and delivers 90% of the value.

Confidentiality note

Client name omitted by NDA. Figures are real or conservative estimates based on client's internal measurements.