Choreography: the recurring report that automates itself
The report you rebuild from scratch every week doesn't need to be rebuilt from scratch. This lesson shows the ladder that turns that repeatable task into a system that almost triggers itself, with you always checking the number before it goes out.
Every Monday morning it's the same thing. You open the spreadsheet, pull the week's numbers, build the same table as always, write the same kind of summary, format it, and send it to the team. Two hours evaporate. The following week, you do it all again, from scratch, as if it were the first time. The report is the same; only the numbers change. And even so you rebuild the whole house every week. This lesson is about no longer rebuilding.
Every month-end you build the same HR report. You open the system, pull headcount, turnover, open positions, average days to fill a role, and rebuild the same climate and recruiting-pipeline presentation for leadership. Hours flowing away into a structure that never changes; only the month's numbers change. Think with me: if the report is the same every time, why do you rebuild it from scratch? You climb the ladder. From hand to a fixed template, from template to a workflow that pulls the data and builds it itself, up to the report already waiting for you, built, on the first business day. But the rung you never automate is the last look: no number about a termination or a performance review goes out before you check it.
Every sprint closes and you build the same product report. You pull activation metrics, retention, feature usage, roadmap delivery status, and rebuild the same view for stakeholders. The structure is always the same; only the sprint's data changes. And even so you rebuild it all by hand, every time. Fair enough, so notice: the recurring product report is a system disguised as a task. You climb the rungs. Fixed template for the sections, then the workflow that pulls from analytics and builds the draft, up to the report firing itself off at the end of every cycle. What you never delegate is the final read: the number that justifies a roadmap decision only goes out after you check it.
Every week you build the same sales forecast. You open the CRM, pull the pipeline, count the deals by stage, calculate the closing forecast, and rebuild the same spreadsheet for the pipeline meeting. Two hours vanish into a structure that repeats every time; only the week's deals change. Think with me: if the forecast has the same format every time, why do you rebuild it from scratch? You install the ladder. From hand to template, from template to a workflow that reads the CRM and builds the draft, up to the forecast already built every Monday. But there's one untouchable rung: the number that goes to sales leadership and the board passes through your eyes before it goes out. Always.
Every month you build the same operations report. You pull the SLA indicators, volume processed, delays, rework, cost per delivery, and rebuild the same dashboard for leadership. The structure never changes; only the period's numbers change. And even so you rebuild the whole house every time. Do the math: that's dozens of hours a year on an assembly that repeats identically. You climb the ladder. Fixed template for the indicators, then the workflow that pulls from the systems and builds it itself, up to the report firing off on a schedule. What you never automate is the approval: no SLA or quality number goes out to the team without you checking it first.
Every quarter you build the same controls report. You pull audit status, data-privacy incidents, internal controls tested, policy exceptions, and rebuild the same structure for the risk committee. The format is always the same; only the period's findings change. Think with me: if the regulatory report has the same anatomy every time, why rebuild from scratch? You climb the rungs. Fixed template for the sections, then the workflow that consolidates the control data and builds the draft, up to the report already waiting for you, built. But here the final rung is sacred: no number that goes to the regulator or the committee goes out before your eyes check it. In compliance, that's not fussiness, it's the rule.
Every sprint you build the same engineering report. You pull deploy metrics, incidents, recovery time, test coverage, technical debt, and rebuild the same view for leadership. The structure repeats every time; only the cycle's numbers change. And even so you rebuild it all by hand, as if it were the first time. Fair enough, notice the pattern: this report is a system waiting to be built. You climb the ladder. Fixed template, then the workflow that pulls from the CI pipeline and monitoring and builds the draft, up to the report firing off on a schedule at the end of every sprint. What you never automate is the final approval: the incident number that goes to leadership passes through your eyes before it goes out.
Every month you build the same UX report. You pull usability data, flow completion rates, user research findings, accessibility scores, and rebuild the same structure for the product team. The format never changes; only the period's numbers and insights change. Think with me: if the report always has the same anatomy, why do you rebuild it from scratch every time? You install the ladder. Fixed template for the sections, then the workflow that pulls from analytics and research tools and builds the draft, up to the report already built and waiting for you. But the rung you never delegate is the final read: the number that turns into a design recommendation only goes out after you check it.
Every quarter you build the same strategy deck for the board. You open the market dashboard, pull performance by business unit, the OKR status, the competitive scan, and rebuild the same narrative you always use for the board meeting. The structure never changes; only the numbers and the market moves change. And yet you rebuild the whole deck from scratch, every single time. Think about it with me: if the deck always has the same anatomy, why rebuild it from zero? You climb the ladder. A fixed template for the sections, then the workflow that pulls from your systems and builds the draft, until the deck fires off ready before the meeting. What you never automate is the final read: no strategic recommendation goes to the board without passing through your eyes first.
Let me do a math problem that hurts. A report that takes you two hours a week is a hundred hours a year. A hundred hours. More than two full weeks of work, entirely, spent redoing the same thing with different numbers. Think with me: if the report is the same every time, why do you build it from scratch every time? The honest answer is that nobody ever showed you the ladder. That's what we're going to do now.
The core idea of this lesson. Every recurring report is, in truth, a system disguised as a task. The first time you do it by hand. From there on, every repetition should cost less, not the same. You climb a ladder: from hand, to a fixed template, to a workflow that builds itself, up to the report that almost fires off on a schedule. But there's one rung you never automate: the final approval. AI builds it; you check the number before it goes out. Always.
01Why you still rebuild everything from scratch
Let's call it what it is. The recurring report is the easiest task to turn into a system, and it's exactly the one most people keep doing by hand. The reason isn't technical, it's habit. You learned to do that report once, it turned out well, and you never stopped to ask whether you needed to do it the same way again.
Notice the anatomy of a recurring report. It has three parts:
- The structure. The same sections, in the same order, every time. This never changes.
- The data. The week's or month's numbers. Only this really changes.
- The reading. What the numbers mean this time. This is yours, and it's the part that matters.
When you rebuild everything by hand, you spend your expensive time on the structure, which is the part that repeats the most and is worth the least. The ladder I'm about to show you does the opposite: it pushes the structure and the assembly onto the machine, and frees you up for the reading. Fair enough?
02The ladder: four rungs from the arm to the click
Think of a four-rung ladder. Each one costs less effort than the one below, and you climb one at a time, at your own pace. Don't skip a rung: each one teaches you the terrain of the next.
Rung one is where you are today: everything by hand. The next three rungs are the next three sections. What matters is seeing the design: effort drops with every rung, but the person who checks the number stays at the top of every one. Automation grows; control never leaves your hand.
03Rungs two and three: the template and the workflow
Rung two is the template. Here you stop writing the request from scratch every time. You write it once, with care, a fixed prompt that describes exactly the report you want: the sections, the tone, what always goes in, what never goes in. Then you paste in the week's numbers and AI hands back the draft in the same structure, always. It's like having a cake mold: you swap the filling, the shape stays the same. That leap alone already cuts a good chunk of your two hours, because you never rebuild the structure again.
A good template records, in writing:
- The fixed sections, in the right order.
- The tone and length of each part.
- The number rules: what to compare with what, which period, which rounding.
- What to highlight and what to leave out.
Rung three is the workflow. Now you climb one more. Instead of you pulling the numbers and pasting them, AI pulls the data from the source, applies the template, and builds the draft, all in one step. You go from being the assembler to being the reviewer: the report arrives ready in front of you, in the usual structure, and your job becomes reading, adjusting the interpretation, and checking the number. The effort left over is no longer construction, it's judgment. Which is exactly where your time is worth the most.
04Rung four: almost one click, never one click
Rung four is the top of the ladder, and it's where the dangerous temptation lives. Here the workflow no longer waits for you to call it. It fires off on a schedule or a trigger: every Monday at eight, the report's draft is already built and waiting for you. You start nothing. You only receive, check, and approve.
Notice the name: almost one click. Not one click. That difference is the single most important thing in this entire module.
The rule is simple and non-negotiable: you automate the assembly, never the approval. The machine can pull, calculate, write, and format on its own. But the report doesn't go out to the team, the board, the client, without a pair of human eyes passing over it first. In finance, this isn't fussiness. It's the same golden rule of the module: the number checked before it goes out. A workflow that fires the report straight to the recipient, with you out of the loop, isn't automation, it's an accident waiting to happen. Remember the lesson on execution governance: AI executes, the human answers for it. It's the same here.
05The math that justifies the ladder
Now the frame that makes this obvious. Take your report and calculate how much time it costs you per month. A weekly report of two hours is eight hours a month, almost a full day of work, every month, just on that. In a year, a hundred hours.
Turning that report into a system doesn't give it all back, because you still check and approve. But it gives back almost everything. The assembly, which was the bulk of the time, becomes minutes. What's left for you is the part that matters: reading the number, understanding what changed, deciding what to do. From two hours, you go down to maybe fifteen minutes, and on top of that, spent on the part that pays your salary.
Notice the pattern, because it's bigger than this one report: every task you repeat is a system waiting to be built. The recurring report is the best place to start because the gain is glaring and the risk is low. You install the ladder once and it works for you every month, forever. Ready to climb the first rung?
Do it now
Take the recurring report that takes up the most of your time, your real task or another one (the weekly close, the monthly summary, the board report).
First, do the math. How much time does it cost you per edition? Multiply by the frequency in a year. That's the size of the prize.
Now describe its structure in writing, as if you were explaining it to someone else to do in your place: which sections, in what order, what always goes in, what never goes in, which numbers to compare with which. That's your rung two, the template. You just turned a task that only lived in your head into a system that can run outside it.
Also note the red line: the exact point where the report needs to pass through your eyes before it goes out. That's the rung you never automate.
Practice
1. What is the correct sequence of the ladder for turning a recurring report into a system?
2. At the highest rung, when the report already fires off on a schedule, what do you never automate?
3. Why is the recurring report the best place to start installing automation in your work?
For the board
On the mathstwo hours a week is one hundred hours a year. More than two weeks redoing the same thing with different numbers.
On the ladderfour steps, one at a time, always checking at the top. Each step costs less effort than the one below.
On the limityou automate the assembly, never the approval. The machine builds, the human checks and releases.
Thanks for the feedback. It helps sharpen the next lesson.