CT&P

Chase what's promised. Pace what's moving. Trace what's broken.

Comment

Inspiration

Every team I've worked with has the same problem: work disappears between conversation and completion.

Someone says "I'll take care of that" in a meeting — it's never tracked. A bug surfaces in production and nobody can explain where it came from. Tickets sit in "In Progress" for weeks while everyone assumes someone's working on them.

These aren't edge cases. This is the default state of how teams operate.

Confluence is where decisions happen. Jira is where work is tracked. But the connection between them is manual, fragile, and usually forgotten. CT&P closes these gaps automatically.

Chase what's promised. Trace what's broken. Pace what's moving.

What it does

CT&P is a suite of three tools that integrate directly into Confluence and Jira.

Chase — Commitment Extraction

Chase scans Confluence pages — meeting notes, project plans, decision documents — and identifies actionable commitments. It recognizes patterns like "John will deliver the API spec by Friday" and extracts them into a structured list.

With a single click, selected commitments become Jira tickets. What used to require manual transcription now takes seconds.

Chase Commitments

Successful Creation

Trace — Causality Mapping

Trace answers the question every team asks when something breaks: "Where did this come from?"

When you open a Jira issue, Trace displays the complete chain of upstream causes and downstream effects. Instead of clicking through ten tickets trying to piece together what happened, you see the whole picture instantly.

Trace Casuality Chain

Pace — Health Monitoring

Pace watches your project and tells you the truth.

It surfaces what dashboards hide: issues that have gone cold, work that's off track, and blocked items. Configure it with your project, and it displays a health score with specific metrics.

Pace Monitoring

Rovo Agents

CT&P also includes Rovo agents for each capability. Ask "What commitments are on this page?" or "Trace this bug's origin" or "How healthy is this project?" and get answers in natural language.

How I built it

CT&P is built entirely on Atlassian Forge, leveraging its native capabilities for security, scalability, and deep product integration.

Architecture

I chose a unified app architecture with three distinct UI modules sharing a common backend:

  • Chase: confluence:contentAction module that opens a modal for commitment review and ticket creation
  • Trace: jira:issuePanel module that renders the causality chain directly in issue view
  • Pace: jira:dashboardGadget module for configurable health monitoring

All three modules call into a shared resolver that handles API interactions with Confluence, Jira, and Jira Software.

UI Implementation

I used Forge UI Kit 2 with @forge/react for all user interfaces. UI Kit 2 renders natively within Atlassian products, automatically inherits theming, and provides components that match Atlassian's design system exactly.

For Chase, I used DynamicTable with checkbox selection and Lozenge components for status badges. For Trace, I implemented a custom vertical flow using Stack, Box, and Inline primitives. For Pace, I used ProgressBar for sprint progress and conditional styling with design tokens for health indicators.

Commitment Extraction

Chase identifies commitments by recognizing:

  • Explicit ownership: Names or @mentions followed by action verbs
  • Deliverable language: Concrete outputs rather than vague intentions
  • Temporal markers: Deadline references that signal commitment

The extraction happens server-side, with parsed commitments returned to the UI for review. Users always have final say over what becomes a ticket.

Rovo Agent Integration

Each capability has a corresponding Rovo agent with custom actions. The agents use the same resolver functions as the UI, ensuring consistency. This dual-interface approach lets users choose how they want to interact.

Security

CT&P runs entirely on Atlassian infrastructure. No data leaves Atlassian's cloud — CT&P qualifies for the Runs on Atlassian program.

Challenges I ran into

Commitment Extraction Accuracy

The hardest challenge was making Chase's extraction useful without being noisy. Early versions caught too much — every sentence with a name and verb became a "commitment." Later versions were too conservative.

The breakthrough was recognizing that commitment language has specific markers: future tense, specific deliverables, and ownership assignment. I still show everything Chase finds and let users deselect false positives.

Confluence API Scope Mismatch

I initially encountered authorization errors with certain API endpoints. The Confluence API has v1 and v2 variants with different scope requirements. After debugging, I added the correct scopes to cover both versions.

Dashboard Gadget State Management

Pace's dashboard gadget needed to handle configuration and data display in the same component. Forge's gadget module has edit and view modes, but the handoff required careful state management using useProductContext() and view.submit().

Cross-Product Data Correlation

CT&P spans Confluence and Jira, which have separate APIs and data models. I handled this by treating each product's API separately in the resolver, then correlating data at the presentation layer.

Accomplishments that I'm proud of

It Actually Works

CT&P isn't a mockup or proof of concept. Chase extracts real commitments and creates real tickets. Trace shows real causality chains. Pace monitors real project health.

Cross-Product Integration

Most Forge apps target a single Atlassian product. CT&P meaningfully integrates Confluence, Jira, and Jira Software data. This integration depth is rare.

Dual Interface Design

The combination of visual UI components and Rovo agents gives users flexibility. Need quick action? Use the UI. Want to ask a question? Talk to the agent.

Production-Quality UI

The interfaces use Atlassian design tokens, UI Kit components, and spacing patterns that match the host products. When you open Chase on a Confluence page, it feels like part of Confluence.

What I learned

Forge is Production-Ready

I was initially skeptical of Forge's constraints. But these constraints enable security guarantees and deployment simplicity that would be impossible otherwise. The developer experience is genuinely good.

UI Kit 2 is Worth the Tradeoffs

Custom UI offers more flexibility, but UI Kit 2's native rendering and automatic theming create a level of polish that's hard to achieve otherwise.

Rovo Agents are Underutilized

Most Forge apps don't use Rovo agents, but the agent framework is surprisingly powerful. The combination of visual UI and conversational agents isn't redundant — it's complementary.

What's next for CT&P

Chase Enhancements

  • ML-based commitment detection trained on real meeting notes
  • Custom patterns for team-specific language
  • Deadline parsing to convert "next Friday" to actual dates

Trace Expansion

  • Deeper recursive traversal for complex causality networks
  • Timeline view showing when each link was created
  • Export for post-mortem reports

Pace Evolution

  • Custom thresholds for what "stale" means
  • Alerts via Slack/email when health drops
  • Historical health tracking to identify patterns

Use Cases

After the Weekly Standup

Your team just finished a 30-minute sync. Action items were discussed, owners were named, deadlines were mentioned. With Chase, scan the meeting notes before everyone leaves — six commitments become six Jira tickets in ten seconds. Nothing forgotten.

Production Bug Investigation

A customer reports they were charged twice. Instead of spending an hour clicking through linked tickets, open Trace. See instantly: this bug traces back to a webhook timeout, which traces back to retry logic, which traces back to the original payment flow story. Root cause found in seconds.

Sprint Health Check

Your board shows 12 tickets in progress. Everything looks fine. But Pace shows the truth: 4 of those tickets haven't been touched in 10 days. 2 are past due. 1 is blocked. Your "healthy" sprint is quietly dying — now you know where to focus.

Project Handoff

New team member joining mid-project? Pace gives them instant context on what's moving, what's stuck, and what needs attention. No more "how's everything going?", the dashboard shares that information.

Share this project:

Updates