Domino

Domino is a Rovo Agent that maps the "blast radius" of blocked Jira tasks, tracing dependencies across the Teamwork Graph to alert business teams before delays derail launches.

Comment

Inspiration

When a major incident strikes—like a primary database migration failure—engineering teams immediately jump into Jira. However, standard Jira issues only show dependencies as a flat text list. In a complex, cascading failure, developers struggle to visualize the true "blast radius" or figure out which ticket is the root bottleneck. Teams are forced to click through dozens of tabs just to understand what is broken, losing valuable time.

We wanted to replace guesswork with visual clarity. Domino was inspired by the need to give teams instant, multi-level context across both Jira and Confluence, empowering them to prioritize triage and ship fixes with absolute confidence.

What it does

Domino is a custom Atlassian Forge panel that transforms standard Jira "Linked Issues" into an interactive, multi-level dependency graph.

Visual Blast Radius: It recursively maps complex relationships (Blocks, Relates To, Clones) using an interactive React Flow graph.

Cross-Platform Context: It doesn't just stop at Jira; it automatically fetches and embeds connected Confluence documentation (like strategy docs or database schemas) directly into the incident graph.

Critical Path Calculation: Using a custom Python algorithm, Domino calculates and highlights the "Critical Path"—the absolute longest chain of blocking tickets—so teams know exactly which issue to prioritize to unblock the rest of the project.

How we built it

Domino is built using a decoupled monorepo architecture bridging Atlassian Forge and a custom cloud backend:

Frontend: We utilized the Atlassian Forge Custom UI framework alongside React and reactflow. We used @forge/api and @forge/resolver to securely fetch issue data and Confluence Remote Links directly from the Jira UI.

Backend: We built a custom Python 3.11 backend using FastAPI and Pydantic, continuously hosted on Render.

The Logic: The Forge frontend packages the nodes and edges into a JSON payload and sends it to the FastAPI server. The Python backend then runs a custom Depth-First Search (DFS) algorithm with memoization to compute the critical path via adjacency lists, returning the metrics to the UI in milliseconds.

Challenges we ran into

Serverless Timeouts & Cold Starts: Our biggest hurdle was the strict 25-second execution limit on Atlassian Forge resolvers. Because our Python backend was hosted on Render's free tier, it would spin down after 15 minutes of inactivity. When it experienced a "cold start" (taking 30-60 seconds to wake up), the Forge app would timeout and crash. We resolved this by implementing an automated HTTP pinging service to keep the backend permanently awake.

Sequential API Bottlenecks: Fetching deep, multi-tiered trees of linked Jira issues and Confluence pages sequentially took too much time. We had to heavily optimize our queue-based graph traversal in the JavaScript resolver to build the payload efficiently before hitting execution limits.

Accomplishments that we're proud of

Successfully bridging Atlassian's secure serverless Forge environment with a custom external Python/FastAPI backend.

Writing a flawless Depth-First Search algorithm that accurately identifies the critical path even in dense, highly-branched dependency trees.

Creating a highly visual, intuitive UI that takes zero configuration to use—users just click a button and instantly get high-value incident context.

What we learned

Deep, hands-on experience with the Atlassian Forge Custom UI framework, bridging the gap between Node.js resolvers and React frontends.

Managing complex graph data structures across two different languages (JavaScript for React Flow rendering, Python for DFS calculation).

Navigating the constraints of serverless deployments and finding creative architectural workarounds for timeout limits.

What's next for Domino

Real-time Graph Filtering: Allowing users to filter the visual graph by issue status, priority, or assignee (e.g., "Only show open bugs").

Post-Incident Review (PIR) Exports: Adding a feature to export the generated graph as a high-resolution image or PDF to attach directly to Confluence incident reports.

Cross-Project Maps: Expanding the algorithm to natively support and color-code massive cross-project dependencies for enterprise teams.

Built With

Share this project:

Updates

Submission history