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.