Ripple

Change a policy once, and every copy follows: Ripple finds every Confluence page and Jira work item that still states the old value and gets them fixed.

Comment

Inspiration

Business teams write a policy once and then repeat it everywhere: in the onboarding guide, the benefits FAQ, the manager handbook, the careers page, slide decks and Jira requests. When HR raises parental leave from 12 to 16 weeks, or finance raises the hotel limit, the official page changes, but the copies do not. Employees and candidates read the old number, managers plan with it, and nobody can say where all the copies are. Rovo can answer questions about a policy, but nothing tells the owners of the stale copies that they have work to do. Ripple turns a policy edit into a tracked change that spreads until every copy is updated.

What it does

  • Notices the edit. Ripple watches Confluence pages labelled policy. When someone publishes a new value, a page-update trigger compares the new version with the one before and records the change, for example "12 weeks → 16 weeks". Ripple looks at durations, amounts and percentages. In our demo the change was recorded about 6 seconds after the page was published.
  • Finds the copies, however they are written. Ripple searches Confluence and open Jira work items for the old value in its different forms: "12 weeks", "12-week" and "twelve weeks". For each copy it shows:
    • where it is, and who owns it;
    • the exact sentence;
    • a suggested rewrite that keeps the sentence and changes only the value ("A generous 12-week paid parental leave" becomes "A generous 16-week paid parental leave").
  • Sets aside matches that are about something else. A context check reads the words around each match. In the demo, "The migration will take 12 weeks" in a platform plan was marked Probably unrelated and not counted. One click counts it if Ripple was wrong.
  • An agent that does the routine work. Ask the Ripple agent in Rovo "What still states the old value?" It lists the copies, explains why a match looks unrelated, and asks before it creates anything. After you confirm in Rovo's review card, it creates one Jira task per out-of-date page, assigned to the page owner, and adds a comment to each Jira work item that repeats the old value. Each task says what changed, quotes the sentence that is now wrong, suggests the new wording and links to the page.
  • Tracks the change until it is done. When an owner fixes a copy, the trigger reads it again. If the old value is gone, Ripple marks the copy Updated by itself; in the demo this took about 2 seconds. The copy's byline reads "Ripple ✓ up to date", and the policy's byline moves to "Ripple 1/5 updated".
  • One place to see what is still spreading. The Ripple page in Confluence shows every policy change with its progress, copies by status, and the copies that have waited longest, with owner and task. The agent answers "Which policy changes are not finished, and who still has to update something?"

How we built it

  • Forge, Confluence and Jira. One app with multi-app compatibility: Confluence required, Jira optional. Modules:
    • rovo:agent with five actions: get-changes, find-mentions, create-update-tasks (CREATE), update-mention (UPDATE) and propagation-status;
    • confluence:contentBylineItem with dynamicProperties, so the byline itself shows "Ripple 1/5 updated" or "Ripple: out of date";
    • confluence:globalPage for the Ripple page;
    • triggers on avi:confluence:updated:page and avi:jira:updated:issue;
    • Forge Custom Entities for changes and copies, indexed by page, by change and by target.

The UI is UI Kit, with a donut chart and dynamic tables.

  • AI where it helps, code where it must be right. The agent talks with people, explains matches and drafts better wording. Code decides every status: the value engine (durations, money, percentages, number words, hyphenated forms), the version comparison, the context check, progress, and the check that a suggested rewrite states the new value and no longer states the old one. 14 offline tests cover this logic.
  • Guardrails for the agent. Statuses come only from the actions. A copy can be marked updated only when the page or work item no longer states the old value; otherwise the action refuses. Suggested wording that drops the new value or keeps the old one is rejected. Nothing is created without Rovo's review card.
  • Catches up after a missed event. Each page version is compared once. If a trigger is missed, opening a page's Ripple panel compares the versions and re-checks the page's copies.
  • Permission-aware, no personal data stored. Searches, task creation and comments for people run as the current user, and Ripple only lists pages and work items the viewer can open. Owners are looked up live, so Ripple stores no account IDs or names. The triggers read as the app, only to compare text.
  • No external calls. After the production deployment, the Forge CLI reported that the version is eligible for the Runs on Atlassian program.
  • Measured on a live site. We ran the whole flow on the production app on a demo site with fictional data: detection on publish, search across four spaces and a Jira project, the review card, four tasks and a comment, automatic "Updated" after a fix, a second change for an amount ($200 → $250), the Ripple page and the status question.
  • Demo video. Screen captures of the production app. The people, pages and work items are fictional. The narration is synthetic (Kokoro-82M text to speech, Apache-2.0).

Challenges we ran into

  • Confluence does not send page events to an app for spaces the app cannot see. On our demo site, the sample spaces were restricted, so edits there did not reach the trigger. We added the catch-up: opening the Ripple panel compares the versions and re-checks the copies. For the demo we used new spaces, where events arrive within seconds.
  • Telling a copy from a coincidence. "12 weeks" appears in project plans too. We compare the topic words of the changed sentence, its heading and page title with the words around each match, and a short FAQ answer borrows the topic of the question just before it.
  • A packaging setting turned the resolver's default export into a namespace object. Removing "type": "module" from package.json fixed it.

Accomplishments that we're proud of

  • A policy edit becomes a list of owners with exact sentences and ready wording, in seconds.
  • Nothing is marked done until the text actually changes.
  • One agent conversation goes from "what is stale?" to assigned Jira tasks, with a human confirmation step in between.

What we learned

  • The hard part of keeping knowledge consistent is not finding the new truth but finding every place that still repeats the old one.
  • Showing the exact sentence and a suggested rewrite turns a vague "please check your pages" into a two-minute task.

What's next

  • Dates and plain counts, such as deadlines and seat limits.
  • Noticing a reverted edit by itself and closing its change.
  • Suggesting Confluence excerpts, so a copy can include the policy text instead of repeating it.

How it meets the technology requirement

Ripple is built entirely on Atlassian Forge. It integrates Confluence (a byline item with dynamic properties, a global page, a page-update trigger, page versions, labels and search), Jira (search, task creation, comments and an issue-update trigger) and Rovo (an agent with five actions, two of which go through Rovo's review card). It makes no external calls.

Bonus prize: Best Agents

The Ripple agent (rovo:agent) is the main way to work with Ripple. It reads the recorded change and its copies, explains why a match looks unrelated, asks for confirmation, creates the Jira tasks through a CREATE action, stores better wording or marks copies not applicable through an UPDATE action, and reports which changes are not finished and who still has work to do. Its actions only return statuses that the code decided.

Privacy and support

  • Ripple runs entirely on Atlassian Forge and makes no external calls.
  • It stores the following in Forge storage on the customer's site:
    • each change: the page ID, title and link, the old and new value, and the sentence before and after;
    • each copy: the page or work item ID, title and link, the sentence, the suggested wording, its status and task key.

It does not store account IDs, names or email addresses. Owners are looked up live from the page or work item when Ripple shows them or assigns a task.

  • Questions or problems: leave a comment on this Devpost page.

Built With

Share this project:

Updates

Submission history