Decision Radar — Decision Intelligence for Jira

Turn Jira into a system of understanding. Decision Radar tracks undocumented decisions, quantifies decision debt, and reveals governance risk across Epics, projects, and organizations.

Comment

Inspiration

Every day inside Jira, decisions are being made. An Epic is reassigned. A scope is rolled back. A priority suddenly changes. These are not task updates — these are decisions.

But Jira only records what changed. It never records why.

We watched teams repeat the same mistakes, make the same rollbacks, and face the same coordination failures — because organizational memory was lost. The decision context that could have prevented these incidents simply didn't exist.

We built Decision Radar to fix this.

What it does

Decision Radar introduces Decision Intelligence as a first-class concept in Jira.

It works at three levels:

  • Epic Level — Tracks decisions on individual Epics, calculates Decision Debt, and predicts incident patterns
  • Project Level — Aggregates decision health across all Epics in a project
  • Organization Level — Provides a global Decision Radar showing governance risk across the entire organization

The app detects undocumented decisions, quantifies them as Decision Debt using a deterministic formula, and identifies patterns that historically correlate with delivery failures — before they happen.

How we built it

  • Atlassian Forge — Serverless backend running natively on Atlassian infrastructure
  • React — Custom UI for the issue panel and radar views
  • Jira REST API — Changelog analysis to detect decision events
  • Forge Storage — Persistent storage for decision history and governance state

The app runs in three Jira surfaces: Epic issue panel, project sidebar, and global Apps menu — all using the same resolver backend with different aggregation logic.

Challenges we ran into

  1. Jira API Migration — Midway through development, Jira deprecated the /rest/api/3/search GET endpoint. We had to migrate to the new /rest/api/3/search/jql POST endpoint, which required restructuring our API calls.

  2. Forge Deployment Caching — Deployed code wasn't always executing on Atlassian's servers. We spent significant time debugging what turned out to be a caching issue, requiring multiple deployment strategies to force new code execution.

  3. Epic-Only Filtering — Ensuring the app only analyzes Epics (not tasks or stories) required careful JQL construction and issue type detection across different Jira configurations.

Accomplishments that we're proud of

  • Three-level intelligence — Same decision data, three different lenses (Epic, Project, Organization)
  • Deterministic causality — Pattern matching that explains predictions, not black-box ML
  • Zero configuration — Install and it works. No setup, no onboarding, no training.
  • Native Jira experience — Feels like part of Jira, not an external tool

What we learned

  • Decision governance is a gap that Atlassian hasn't addressed natively — and teams desperately need it
  • Forge's "Runs on Atlassian" model is powerful but requires careful attention to deployment and caching behavior
  • Epic-level focus is the right abstraction — task-level tracking creates noise, not signal

What's next for Decision Radar

  • Slack/Teams notifications — Alert leaders when decision debt crosses thresholds
  • Historical trend analysis — Show how organizational decision health evolves over time
  • Custom pattern definitions — Let organizations define their own incident signatures

Built With

Share this project:

Updates