Inspiration

Every software team has lived this: a change ships, and the same thing breaks again. A payment retry double-charges customers. Someone fixed it before and wrote a postmortem, but at the moment the next retry change was shipped, nobody looked. The warning signs were all there, spread across old Jira incidents, Confluence pages and GitHub. We wanted the history of an area to speak up at the exact moment someone ships into it.

Who it's for

  • Developers moving a work item to Done, who need to know what broke in this area last time.
  • Reviewers and tech leads, who need risky changes flagged with proof and the right reviewer named.
  • Release owners and engineering managers, who want fewer repeat incidents without another meeting or checklist.

What it does

Tripwire gives every Jira work item a ship confidence score with evidence:

  • On every work item (right column), a compact box shows the score, the verdict (Clear to ship, Ship with care, Tripwire triggered), the ship gate state and the top risks.
  • The full panel lists every tripwire with links to the proof (past incidents, the blocking work item, the failed deployment, the open pull request, the postmortems), the next step, and its risk points.
  • The ship gate is a workflow validator: moving a work item to Done is blocked while serious risks are open.
  • Teams stay in control: anyone can acknowledge a risk with a reason. The name and reason are saved, and if new evidence appears, the tripwire re-arms.
  • The Tripwire Rovo agent answers "Is PAY-9 safe to ship?" and "Who should review this change?" with the same evidence, and names the people who fixed the most incidents in that area.
  • A one-time warning comment is posted when work starts on a red item, never twice for the same evidence.

Tripwire only cites what it finds. It never guesses.

How we built it

Tripwire is a Forge app that runs on Atlassian: no external servers, no egress, all data in Forge storage.

  • Evidence: Jira REST (incidents, bugs, "is blocked by" links, subtasks, tests, acceptance criteria), Confluence search (postmortems and runbooks for the area), and Teamwork Graph curated queries for pull requests and deployments linked to the work item (jiraWorkItemLinkedExternalPullRequests, jiraWorkItemLinkedExternalDeployments), so code and release data from GitHub count too.
  • Permissions: the panel, the right-column box and Rovo read everything as the current user, so nobody sees evidence they could not open. The validator and trigger run as the app and reuse the last user check's Teamwork Graph snapshot.
  • Explainable scoring: a pure TypeScript engine with 45 unit tests. Each tripwire adds risk points (for example, a recent high-priority incident is 18, a failed production release is 15), and confidence is 100 × e^(−risk/60), so more risk always lowers the score without collapsing to 0.
  • Modules: jira:issueContext, jira:issuePanel (one shared UI Kit app), jira:workflowValidator, a trigger, rovo:agent with three actions and a rovo:skill. One cross-product installation (Jira required, Confluence optional) gives one shared storage and one agent.

Challenges we ran into

  • Teamwork Graph changed under us. Raw Cypher is closed to new apps, and registering persisted queries was failing. We moved to curated queries, and learned that the API answers HTTP 200 even on errors, so success means "data present and no errors".
  • A score that hits 0 tells you nothing. Our first linear score bottomed out on risky items. The exponential curve keeps every extra risk visible, and strengths can cancel at most half of the risk.
  • Duplicate Rovo agents and split storage came from separate Jira and Confluence installations. Declaring app compatibility gave us a single installation.
  • Validators must never block a team because the app is down, so the ship gate fails open.

Accomplishments that we're proud of

  • Five Atlassian surfaces (Jira panel, right-column box, workflow, Rovo, comments) working from one explainable engine.
  • Real cross-tool evidence: a failed GitHub production deploy and an open pull request show up as tripwires through Teamwork Graph.
  • Acknowledgements that re-arm on new evidence: human judgment without silencing the warning forever.

What we learned

Evidence beats opinion. Teams accept a red score when every point links to something they recognise, and they ignore it when it does not. Building on curated Teamwork Graph queries and strict user-permission reads made Tripwire both more trustworthy and simpler.

What's next for Tripwire

  • Learn from outcomes: compare predicted risk with incidents after release, and tune the weights per team.
  • More signals from Teamwork Graph: builds, feature flags and on-call incidents from connected tools.
  • A release-level view: the combined risk of everything in a Jira release before release day.

Built With

Share this project:

Updates

Submission history