Backlog Refinement for Jira

Stop guessing, start planning: Real-time consensus for a healthier backlog.

Comment

Backlog Refinement for Jira — The Story Behind the App

Why I Built It

It started with a familiar pain: backlog refinement meetings that dragged on, left people unsure, and rarely produced actionable clarity. I’d watch teams debate estimates, rewrite priorities, and lose momentum. The ritual was essential, but the process was messy.

I wanted a way to capture the heartbeat of those ceremonies and make them useful—without extra overhead. A tool that could show, not tell; summarize, not speculate; and help teams see their refinement activity with confidence. That’s how this Forge app was born: a focused companion for Jira, designed to turn refinement into a reliable, trackable practice.

What I Learned

  • The right constraints are liberating: Forge’s security model and module boundaries push you to design clearly and responsibly.
  • Custom UI isn’t just about visuals—it’s about trust. Teams need fast, familiar, and accessible interfaces in Jira. React 18 with Ant Design and styled-components gave me the speed, polish, and consistency I wanted.
  • Data tells the story. With Forge SQL (MySQL) and a clean repository pattern, I learned how much clarity comes from structuring storage thoughtfully—from meetings metadata to work item coverage.
  • AI agents need rules. The Rovo agent isn’t a chatbot—it’s a disciplined analyst. I learned to write tight prompts and strict output contracts so teams get reliable, grounded results every time.

How I Built It

  • Platform: Atlassian Forge on Jira Cloud, serverless runtime (Node.js 22, arm64). Two UIs—Project Page and Settings—packaged as separate resources with dev tunnels for quick iteration.
  • Frontend: React 18 with Ant Design, styled-components, Bootstrap/react-bootstrap, Lodash, classnames, react-icons, and React Router. The grooming UI focuses on clarity; the settings UI makes configuration painless.
  • Backend: @forge/resolver functions for routing, @forge/api for Jira/Forge integrations, and @forge/bridge/@forge/jira-bridge to connect Custom UI to backend securely.
  • Data: Forge SQL (MySQL engine) with scheduled schema migrations (hourly) and a post-install migration trigger. Repository pattern for queries stored in src/sql/repositories, with a TypeScript migration scaffold.
  • Agent: A Rovo agent that only does two things—and does them well: show meetings and summarize a meeting. It validates inputs, never fabricates data, and adheres to a strict output format so teams get high-signal, low-noise insights.
  • Dev experience: React Scripts for builds, Prettier/ESLint/Husky/lint-staged for clean commits, and Forge CLI for deployment. Static builds live in static/grooming/build and static/settings/build and are wired in manifest.yml.

The Challenges

  • Designing for truth, not flair: It’s tempting to add speculative insights. I resisted that by crafting strict agent rules and keeping summaries factual and compact.
  • Data modeling the “ceremony”: Meetings are more than dates and links. Capturing participants, variance in estimates/priorities, and coverage without overcomplicating the UX took iteration and restraint.
  • Balancing two UIs with one brain: The project page and settings page have different jobs but share components and design language. I built common patterns and providers to keep the experience cohesive.
  • Working within Forge constraints: Content security and module permissions require care. Explicit scopes and inline content settings were configured to keep the app secure and functional.
  • Reliability over time: Schema migrations can be tricky. Scheduled and post-install triggers ensure the app stays healthy and consistent across environments. ## Why It Matters

Backlog refinement is a team sport. This app helps teams:

  • See their ceremonies at a glance
  • Summarize discussions without bias
  • Understand variance where it matters
  • Keep Jira as the source of truth

It’s opinionated, disciplined, and built for teams that value clarity over theatrics. If you run backlog refinement regularly, this app turns your rituals into measurable, reliable practice.

What’s Next

  • Deeper analytics on refinement activity trends
  • Optional exports for sharing summaries outside Jira
  • Lightweight guardrails for participation and preparation

If you’re interested in elevating backlog refinement without adding overhead, this app is ready to help—inside Jira, on Forge, and with a clear, reliable lens on your ceremonies.

Built With

  • ant-design
  • forge
  • forge/api
  • forge/bridge
  • forge/sql
  • react
  • rovo:agent
Share this project:

Updates