Shelby Mason
← Back to my workPresent as slides

Automated Board Reporting

Automate the assembly, not the authorship.

Every quarter, an internal audit team reports to its board on the audit program. I led the design of an agent that assembles that report from live audit data in Optro, while the people who sign it stay the authors.

An abstract report card: blue bars that climb, a violet signature, and a violet check mark.
My Role
UX lead and product designer, end to end
Team
1 designer, 1 product manager, 1 tech lead
2 UX researchers and an engineering team of 8
Timeframe
February 2026 to now
Status
MVP locked Oct 1 and in beta. The agentic layer is designed and prototyped for Q4 and Q1.

An agent that assembles the board report from live audit data.

The people who sign it stay the authors.

System-owned: data and generated contentPerson-owned: their deck, edits, and judgement

The problem

Rebuilt by hand every quarter, even though the structure rarely changes.

The preparer pulls audits, issues, and findings out of Optro, fixes them up in Excel, charts them in Power BI, then rebuilds the same tables in PowerPoint. The Excel step exists because the system can’t express their logic, like “is this really past due?”

The structure of the report barely moves from one quarter to the next, but the work is redone every cycle. That was the opportunity: configure it once.

5 to 20
hours per board cycle, about 75% of it spent just gathering data
Today’s board cycle
  1. OptroExport audits, issues, and findings
  2. ExcelApply logic the system can’t express: “is this really past due?”
  3. Power BIBuild the charts
  4. PowerPointRebuild the same tables, again

Three people, one deck

  1. Preparer

    Assemble it.

    Spends the hours. Exports to Excel to apply logic the system can’t express, then rebuilds the same tables in PowerPoint.

  2. Audit director

    Put my name on it.

    Can’t verify deck numbers against the system of record, and worries they’ll change after review.

  3. Board member

    Never opens Optro.

    Needs figures fixed to a point in time. The PowerPoint has to stand on its own.

So the output had to be their PowerPoint, with numbers someone had signed off on.

The challenge

Four questions where a reasonable person could go either way.

If a question had an obvious answer, it was a requirement. These were the ones every answer pulled on the others, and the fourth was the hardest.

  1. How much should the agent do on its own, and where does a person have to decide?
  2. How do you make next quarter’s report mostly build itself?
  3. How do you let an agent draft words that someone else will sign?
  4. How do you keep a report current when nothing may change behind the signer’s back?

Discovery

I started wide, then converged on something we could test. In February the whole UX team riffed on the problem before anyone committed to a direction. By May the shape was a creation wizard plus our PowerPoint add-in, and instead of iterating internally, we put two concepts in front of customers.

  1. FebDivergent riffing with the UX team
  2. MayWizard and add-in concept
  3. JunConcept tests with 4 orgs
  4. Jun 18Principles set: configure once, no silent refresh
  5. Jul 31MVP scope locked
  6. AugRefresh exploration
  7. Oct 1Final UX locked, beta begins
  8. Late OctGA planned

Two prototypes, four organizations, seven people.

Chief audit executives, internal audit directors, and a professional practice manager, across energy, entertainment, retail, and UK financial services.

Option A · Menu-driven add-in3 of 4 chose AA menu in our PowerPoint add-in. Pick a block and it lands at your cursor.
Option B · Hashtag placeholdersPlaceholders typed into the template, which keep their formatting. Cleverer, and powerful for experts.

What we askedDoes it fit how you report today? Is it valuable even with manual setup, from a template or from scratch? Is it enough AI?

“It’s actually a very admin heavy job. It doesn’t take a lot of insight but having an automated element of this allows us to then focus on the insights.”

Professional practice manager · UK financial services group (FTSE 100)

What research said about automation

What we heardSo I…
Today’s pain was moderate, about 3 out of 5. The value was time back for insight.Pointed the agent at the admin work: gathering, scoping, and assembling.
Reviewers need the numbers they reviewed to be the numbers on the slide.Let the agent propose changes, never apply them silently.
The AI summary was liked, but no one called it a must-have.Treated AI prose as a draft to review, and invested most in automating assembly.
Every team builds a report once and expects to reuse it. Roll-forward is table stakes.Made next quarter the agent’s job: re-scope, regenerate, flag what’s stale.

The reframe

We set out to generate the board deck.

The job was to assemble it from live data, and leave the authorship with the person.

In customers’ own words, somewhere between 60 and 75-plus percent of the report comes straight out of the system. The rest is a person’s judgement, and they sign it. So the system’s job is assembly: gather, connect, keep it accurate. The person keeps the framing, the narrative, and the deck itself.

Where the agent sits

An autonomy ladder, not an on/off switch.

Every task the agent does sits on a rung. Rung 4 is empty on purpose: nothing a board will see changes without a person.

  1. Rung 0

    Suggests

    Starting prompts, content blocks, and replacements for last quarter’s dates.

  2. Rung 1

    Drafts

    The report, new sections, and AI summaries, labeled for review before sharing.

  3. Rung 2

    Acts with approval

    Proposes each data change as a redline. Nothing applies until someone accepts it.

  4. Rung 3

    Acts and reports

    Roll forward re-scopes data and regenerates blocks, then labels what it changed.

  5. Rung 4

    Acts silently

    Empty by design. Anything a board sees waits for a person.

Shipped, in beta

The foundation we shipped

Configure once, reuse every cycle. Everything the agent builds lands on this model, as a configured block a person can open and edit.

  1. Create

    The wizard. Once.

    Report details, audit scoping, and content blocks. Configure it, then leave.

  2. Manage

    The report editor. Every cycle.

    Details, Editor, and Data tabs. Review, edit, and save the version you’ll stand behind.

  3. Inject

    Their PowerPoint.

    Our add-in drops blocks at the cursor. Their template, branding, and layout stay theirs.

Designing the agent

On top of that foundation, I designed and prototyped the agentic layer: creating a report by conversation, drafting sections, reviewing data changes, and rolling a report forward to the next quarter. Three decisions shaped it.

Decision 1 of 3

Create by conversation, with every guess on screen.

The tension
A form is predictable, but it asks people to know the configuration up front. A conversation is easier to start, but it can hide what it decided.
The call
The assistant is the only way in. It asks one clarifying question, then shows its guesses as things you can edit: a scoping table and a content checklist.
The cost
Title and cadence are inferred, not typed, so they must be easy to find and fix. Some power users will want a form back.
The stepper and help card advance with the conversation. Every guess lands in something you can check: a scoping table, then a content checklist.

Drafting

Ask for a section. Get a configured block back.

The agent’s output is configuration, not a pile of text, so anyone can open it and check it, and it rebuilds every cycle.

  1. 01 · Asks only what it needsColumns and sort order come back as one-click answers.
  2. 02 · Writes configurationData source, filter, and columns land in the normal editor, ready to adjust.
  3. 03 · Marked until reviewedAI-written text carries “review before sharing” until a person checks it.

Decision 2 of 3

The agent proposes. A person commits.

The tension
An agent’s job is to keep the report current. But a board deck is a point-in-time record someone signed, so a silent update is the worst failure it can have.
The call
When data changes, sections go Pending Review and the editor keeps the values people reviewed. One click shows every change as an inline redline. Each is Apply or Revert, and a revert asks for a rationale.
The cost
The report shows older numbers until someone acts, and reviewing is still work. I cut a separate refresh mode so review happens in place.
A redline means one thing only: content that changed because its data changed.

Decision 3 of 3

Regenerate the data. Flag the words.

The tension
Next quarter’s report should mostly build itself. But the narrative is the person’s, and an agent that rewrites prose erases the authorship the design protects.
The call
Roll forward re-scopes the data, regenerates data-backed blocks, and labels each section. It never rewrites static text: it flags values tied to the old period and suggests a replacement.
The cost
Spotting period-bound text will miss some values and over-flag others. Detection is the next place a smarter AI assist could help.
Rolled forward from Q4: data re-scoped, blocks regenerated, and three period-bound values flagged in place to Keep or Replace.

The trust layer

Every agent action is reversible and on the record.

An agent you can’t audit is an agent auditors won’t use. This is the layer that makes the rest trustworthy.

  1. Version history

    Undo at report scale.

    Named and automatic versions. Restoring adds a new version, so nothing is overwritten.

  2. Activity log

    A record of every call.

    What was generated, applied, reverted, or edited, by whom, beside the human edits.

  3. Regeneration warning

    No surprise rewrites.

    Editing a block whose data changed says, up front, that saving will regenerate it.

How I design agentic features

Five questions every agentic idea has to answer.

In audit, an agent acts under someone’s authority, so permissions are usually the ceiling, not intelligence.

The questionRoll forward’s answer
DoesWhat action does it take, not what does it know?Re-scopes the data, regenerates data-backed blocks, and flags period-bound text.
ReadsWhat data does it need, and does that exist today?Last report’s configuration, plus the new period’s audits and related records.
RungHow far up the ladder does it act?Rung 3 for data-backed blocks. Rung 0 for the person’s words.
AuthorityWhose permissions does it act under?The report owner’s. Nothing goes to the board until they review it.
WrongWhat is the named recovery when it’s wrong?Every section is labeled Regenerated, Carried over, or Check static text, and version history restores.

What outlasts this feature

  1. 01

    A pattern, not a one-off

    “Show the diff, let the person decide, keep a record” became a shared principle across three kinds of suggestion: user, system, and agent. I presented it alongside two teammates.

  2. 02

    A framework for agentic work

    The autonomy ladder and five-question checklist now frame agentic work beyond reporting. I used them to run a cross-team brainstorm for workflows.

  3. 03

    Prototyping with AI

    I rebuilt the prototype from the revised Figma in a day with a Claude-driven toolkit, so reviews happen on behavior, not static frames.

  4. 04

    A beta designed as a decision

    Four questions and an exit bar: most participants finish a real report unaided, with no launch blockers open at GA.

Where it landed

MVP locked Oct 1.

In beta now.

Agentic layer prototyped.

No outcome data yet, so here’s what I’d hold it to.

What I’d measure

  1. Time from first prompt to a board-ready draft, against the 5 to 20 hour baseline.
  2. How often people apply versus revert the agent’s proposed changes, and the rationales they give.
  3. How much people edit AI drafts before sharing. Heavy edits mean the draft isn’t earning its place.