← All workRelease Train Engineer & Enterprise Agile Lead · client confidential · 2026

The PI dashboard

I run the release train on a tolling modernization program: ten vendor teams, contracted scope, and a launch date that does not move. This is the planning board I built for it. It shows what each increment holds, what it inherits and what it hands on, and it never shows a number it cannot source.

Who it’s forTen workstream leads, the client, program and delivery leadership, the business-analysis and test leads, and the Jira platform owner.

ProductBuilt with AIProgram delivery
10vendor teams planning from one board
5ten-week increments on one chart
5 weeksto a working prototype, built test-first
1 fileruns offline on locked-down client networks

The problem

  • Ten workstreams, each with its own vendor or contractor team, onshore, offshore and in Europe. They planned in ten different ways, and nobody could see what an increment really held.
  • Scope is fixed by contract. The only levers are sequencing and added people.
  • Carry-over was invisible until it hurt.
  • Leadership needed honest go or no-go answers at each increment's entry and exit gates.
  • The limits: Jira Standard tier, no admin rights for me, no service accounts, and a security review for any add-on.

What I did

  • Interviewed every workstream lead before planning, and turned the answers into one script that every lead plans from.
  • Rebuilt the cross-workstream Scrum of Scrums, and run a retrospective with all leads at the end of each increment.
  • Built a working prototype of the board with AI agents, test-first, in five weeks: 87 commits, all mine.
  • Showed each increment as what begins there and what it inherits, by workstream and by capability.
  • Declared every metric with the Jira query that will produce it, so the prototype doubles as the build spec for the Jira administrator.
  • Derived the increment from sprint dates, because no increment field existed.
  • Made it run offline from a single file, for locked-down client networks.
  • Produced the first increment's delivery report from it, and ran the two-day close-out roadshow for the client.

What changed

  • Program Increment 1 closed with every committed requirement accepted.
  • Every lead plans from one script and one picture of all five increments, with carry-forward on the chart.
  • The first increment's delivery report and roadshow came from it.
  • The board now runs inside the team's requirements app.
  • The picture above is the board's layout, redrawn with sample numbers. The figures in the text are the real ones.
  • Still open: writing results back to Jira. One field, end to end, is the go or no-go test.

Decisions

  • Interview every lead before planning.Ten vendors plan in ten ways. The interviews produced one script that every lead now plans from.
  • Build the tool when the tool can't be bought.Jira Standard and no admin rights ruled out the usual add-ons. I prototyped the board myself and wrote it as a spec the Jira owner could build from.
  • A gate with no data shows a dash, never green.A green light nobody checked is worse than no light. Out-of-scope requirements are also kept apart from invalid ones, so the unmapped list holds only what is really unmapped.
  • Every number carries its source.Stated in a document, joined, derived, or entered by a person. 1,552 test links are stated; 803 were inferred by the tool and are marked that way.
  • Ambiguity is shown, never guessed.Some requirement numbers appear twice in the source. Those rows are flagged as ambiguous instead of being quietly merged.
  • Machine suggestions stay marked as proposals.Epics the tool derived matched the team's own only 20% of the time. They wear a proposed badge until a person confirms them.
  • Loaded data is never edited in place.Changes go to an append-only journal, and undo adds the reverse change. The journal doubles as the future change set for Jira.
  • Compute outside Jira, store little inside.About 135 authored decisions belong in the system of record. The rest is a cache. The plan also lists what to stop building.

How AI was used

  • A rules file sets scope and git limits for every agent session. It records two times an agent overreached, and the rule each one produced.
  • Plans are test-first specs: the test names are part of the deliverable.
  • I check the agents' numbers. A stale worktree had inflated the test count to 682. The real figure was 384, and fixing that came first.
  • Reusable AI skills do the recurring work: a readout from a meeting transcript, and a refresh of the roadshow numbers from delivery exports, reconciling increment figures against program-wide ones.

Need a product manager who can also build?

Talk about a role