The monthly report: turn your foundation into a close-and-report cycle you trust

Your team already has the reconciliation, spend-audit, and leadership-summary playbooks — the worked recipes for matching a month’s invoices to its payments, scanning the spend for anomalies, and turning a closed month into a summary leadership reads. Each is a good move, done once. This module is the layer that turns those separate moves into a single machine: a monthly cycle that takes a messy export in one end and produces numbers leadership trusts out the other — every month, whether or not month-end felt like a fire drill.

It’s Module 2 of the certifiable Finance & Ops track, and it inherits everything you built in Module 1. Your categorization-rules.md, data-checklist.md, and finance-controls.md are what this cycle runs on. M1 mastered how every number is classified, whether the data beneath it can be trusted, and who’s allowed to approve what; M2 builds the machine that turns that foundation into a reconciliation, an audit, and a briefing every month — and assesses the machine, not a single lucky close.

If the foundation is the rulebook, the report cycle is the machine that runs it every month. A clean close is a good outcome — it needs a calm month, the right person, and an export that happened to be tidy. A cycle is a machine — a raw export goes in one end and a reconciled, audited, briefed month comes out the other, every time, at a quality that doesn’t swing with who survived month-end. The free playbooks teach the moves. This module is where you stop being heroic and start being repeatable.

The cycle, not the scramble

Most finance teams treat month-end as a scramble — a heroic few days where one person pulls the export, reconciles by hand, eyeballs the spend, and writes the summary near midnight because the board meets tomorrow. It usually comes together, which is the trap. A close that came together feels like a win, but it isn’t a cycle: next month needs the same heroics, the quality swings with whoever’s closing, and nothing about it is repeatable or debuggable. The scramble produces a report; it doesn’t produce a system.

A cycle is three named moves that run the same way every month, so the output is trustworthy instead of heroic:

• Reconcile — match the invoices to the payments (or the bank to the ledger) by ID. List what’s unmatched and unpaid, total the outstanding, and flag any payment that has no invoice behind it. This is the move that decides whether the rest of the report stands on real numbers or on hope.
• Audit — scan the month for anomalies: a charge far above its normal run-rate, a duplicate, a vendor you’ve never seen. Categorize every uncategorized row using categorization-rules.md, and surface the one line leadership will ask about before they ask it. This is the move that catches the problem before the board does.
• Brief — turn the closed month into a narrative leadership actually reads: under 200 words, what changed, why, and the two things to watch. Every number traces back to the reconciliation and the rules; every formula stays re-runnable. This is the move that turns a pile of correct numbers into a decision a busy owner can make.

Each move has one job and one input, which buys you two things. First, a different person can own each — the analyst who reconciles isn’t the controller who signs the brief. Second, when a report turns out wrong you can name the broken move: the numbers never reconciled (reconcile), an anomaly slipped through (audit), or the summary buried the one thing that mattered (brief) — not a vague “the close was off.” A cycle you can debug beats a scramble you have to survive.

You run the whole thing in the chat, no terminal on the main path. Open your finance folder in Claude Desktop, approve the read of the export and the foundation docs in the “Ask permissions” prompt, and work the moves one at a time.

Reconcile first — the report stands on matched numbers

A report is only as trustworthy as the numbers underneath it, and the numbers underneath it are only trustworthy once they reconcile. Get the reconciliation right and the rest of the report has something solid to stand on — every total traces to a matched, real figure. Skip it and no amount of clean formatting saves you; a leadership summary built on un-reconciled numbers is polish on sand. The reconciliation is the unit of trust, which is exactly why it’s the thing the free reconciliation playbook can run but can’t teach you to judge.

A reconciliation Claude can build the rest of the report on does four things — and one that skips any of them produces a confident, wrong total:

• Match by ID, not by eye. Every invoice matches to a payment by a shared key — invoice number, charge ID, reference. Matching by amount or by date is how two different AED 1,200 charges get treated as one. The match is mechanical and checkable; that’s the point.
• The unmatched items are the work. The rows that don’t match are the entire value of the exercise — the unpaid invoice, the payment short by a fee, the charge that posted twice. A reconciliation that comes back “all matched” on a real month either got lucky or didn’t look hard enough. Name every unmatched item; that list is your AR and your exceptions.
• Total the outstanding. What’s owed and unpaid, summed and aged, is the number leadership cares about most — the cash that’s earned but not in the bank. It traces straight to the named unmatched invoices, so the total is defensible row by row.
• Flag the payment with no invoice. A payment that matches nothing is its own red flag — a prepayment, a misapplied reference, or money you can’t yet recognize. It never gets quietly absorbed into revenue; it gets named and held until a human resolves it.

Reconcile well and you’ve front-loaded every trust question into one matched, traceable file, so the audit and the brief work from real numbers instead of hopeful ones. That’s the whole reason reconcile is move one: it’s where a person establishes what’s true, so the rest of the cycle can be where Claude produces.

Audit before you summarize

The cheapest anomaly to explain is the one you caught before the board asked about it. Once the numbers reconcile, the audit is where you scan the month for the things that will raise a hand in the meeting — and decide, in advance, how you’ll explain each one. The failure mode is the reverse: shipping the summary, then scrambling to explain the spike after a board member has already circled it in red.

The audit has two jobs, and they run in order:

• Categorize by the rules, never by feel. Every uncategorized row gets bucketed by categorization-rules.md — the same vendor into the same category it landed in last month, the gray areas resolved the way M1 decided them once. This is the leverage of the foundation: feed Claude the rules and it applies yours, so the software line isn’t “hosting” this month and “software” next, inventing a trend that never happened. A new vendor the rules don’t cover stops for a human — it’s never auto-bucketed.
• Surface the one line that needs explaining. Every month has one number that jumps, and the audit’s real job is to find it, decompose it, and hand leadership the explanation before they ask. For Mizan’s May close it’s the Software line: it jumped, and “it went up” is not an answer a board accepts. The audit’s answer is why — how much of the jump is one-time, how much is a new recurring cost, and what the run-rate looks like next month with the one-time piece stripped out.

And every total in the audit shows its work. “Software & tools came to AED 26,000 — summed across these vendors, excluding the 3 blank rows” is a number a reviewer can re-run; “Software is up” is a number a reviewer has to trust. The discipline is the same one M1 set: a total you can’t see the method behind is a black box, and a black box is exactly what you can’t put in front of a board or the FTA. Spot-check one category by hand against the raw export each close; if it matches, you can trust the method on the rest.

The audit is also where the controls gate earns its keep. When the scan turns up a customer charged twice, the fix is a credit note — and a credit note moves money, so the person who found it drafts it and a different person approves it. Claude prepares; the controller signs. The audit finds the problem fast; the gate makes sure the fix is owned.

Brief in plain English — the narrative leadership reads

Here’s the move finance teams underinvest in because it feels like the easy part: the writing. A correct reconciliation and a sharp audit still fail if the summary that carries them is a wall of GL codes a busy owner skims and sets aside. The most expensive report you can write is the accurate one nobody reads.

The brief is a piece of writing with three hard constraints, and the constraints are what make it readable:

• Under 200 words, in plain English. Leadership reads the summary, not the ledger. “Net positive AED 40,000 this month; the one number that moved is software spend, and most of that jump is a one-time annual payment” is a sentence an owner acts on. “Variance in the 6400 cost-center driven by prepaid SaaS amortization” is a sentence an owner forwards to someone else. Cut the jargon; keep the meaning.
• What changed, why, and the two things to watch. Not a data dump — a narrative. What moved this month, the reason behind the one line that moved, and the two things the owner should keep an eye on next. Two, not ten; the discipline of choosing the two is the value. A summary that flags everything flags nothing.
• Every number traces back. Each figure in the brief points back to the reconciliation and the categorization rules underneath it — the AED 40,000 net to the matched revenue and the categorized spend, the Software line to the audited vendors. The brief is authored from the figures, not generated from them as a dump; a person decides what the month means, and Claude helps say it clearly.

This is also the move where verification is non-negotiable, because the brief is the part leadership actually believes. Claude drafts it fast and well — and then a human traces every number in it to source, checks the math is shown, and signs it before it ships. A beautifully written summary built on a number nobody traced is the most dangerous artifact in finance: it’s wrong and convincing.

The Arabic leadership summary — a peer lane, not a translation

Here’s where most MENA teams break the cycle: they run the entire close in English, write the leadership summary, then translate it into Arabic at the very end. The result reads, to an Arabic-reading owner, like a translated finance memo — technically correct, subtly foreign — and in finance, where the whole product is trust in the numbers, reads translated reads untrustworthy.

The fix is the standard M1 set — author, don’t translate — applied now to the actual summary. The Arabic leadership summary is its own narrative, authored from the same figures:

• Authored from the figures, not the English. The Arabic summary is written from the reconciliation and the audit directly — its own sentences, its own emphasis — for an Arabic-reading owner or board. You adapt what the month means to how a Gulf owner hears it; you never translate the finished English paragraph.
• Lead with what a Gulf owner reads first. A Gulf owner-operator tends to read the cash position and the bottom line first, then the one thing that needs explaining — so the Arabic summary leads there, rather than opening on the same line the English chose for a different reader. Same figures, re-sequenced to the reader.
• The conventions are non-negotiable. Numerals stay Western, currency is AED, dates are Gregorian (note Hijri only if the board uses it), and the layout runs right-to-left. A summary that switches numeral systems mid-paragraph or mirrors the column of figures reads amateur — exactly the tell a translated-at-the-end pack leaves behind.
• Same gate, both languages. The Arabic summary clears the same trace-to-source and sign-off as the English. The failure mode is the approver who can’t read the Arabic waving it through — so the gate is cleared by someone who actually reads it.

Done this way, the Arabic summary is a first-class peer of the English, not a post-processing step. In this region that’s the credibility line with the people who sign off on the money — and it’s exactly the part most teams skip and most courses never mention.

Your assignment

Run one real month for one set of books — your own (recommended: the output is a real close your team keeps) or the sample company Mizan, the GCC bookkeeping SaaS whose own finance team runs throughout this track. Everything you produce inherits the three foundation files from M1; if you don’t have them yet, do Module 1 first. Open your finance folder in Claude Desktop, approve each read in the “Ask permissions” prompt, and work in the chat — no terminal needed. You create and edit the output files in the Desktop file pane.

Module 2 deliverable — the monthly report

Inherits from M1: categorization-rules.md + data-checklist.md +
                  finance-controls.md

1. A RECONCILIATION   (of two real files)
   - match invoices <-> payments (or bank <-> ledger) by ID
   - every unmatched / unpaid item named; the outstanding TOTALed and aged
   - any payment with no invoice flagged, not absorbed into revenue
   - every figure traces to a source row (data-checklist.md)

2. A SPEND AUDIT   (categorized by the rules)
   - every row bucketed by categorization-rules.md — no re-guessing
   - anomalies surfaced: the over-normal charge, the duplicate, the new vendor
   - the ONE line that needs explaining, decomposed (one-time vs run-rate)
   - the work shown on every total; one category spot-checked by hand

3. A leadership-summary.md   (under 200 words)
   - what changed, why, the TWO things to watch — plain English, no GL jargon
   - every number traces to the reconciliation + the rules
   - authored from the figures; a human signs it before it ships

Bilingual teams: add leadership-summary-ar.md — authored in Arabic from the
figures, leading with what a Gulf owner reads first; numerals Western, AED,
RTL. Don't translate the English at the end.

The Foundation toolkit you installed in M1 already holds your CLAUDE.md and the three source-of-truth files. The toolkit additions at the end of this module give you the report-system and reconciliation-plus-summary templates, so you’re filling in structure, not staring at a blank export.

How it’s graded — the rubric

This is the part the free playbooks don’t have, and the part that makes the credential mean something. Your three deliverables are scored against five criteria. Each is meets / nearly / not yet, and a “nearly” on any one is a revise, not a pass.

Monthly-report rubric

1. The cycle is repeatable     Three named moves — reconcile, audit, brief —
                               that a teammate could re-run from your files,
                               not a one-time heroic close.

2. The reconciliation holds    Every unmatched item named; the outstanding
                               totaled and aged; any orphan payment (no
                               invoice) flagged, not absorbed into revenue.

3. Traced & categorized        Every number traces to a source row; every
                               row categorized by categorization-rules.md.
                               The work is shown on every total — no black box.

4. Leadership-readable         Under 200 words; what changed, why, the two
                               things to watch; plain English, no GL jargon.
                               The line that jumped is explained, not buried.

5. The Arabic is authored      Its own narrative from the figures, leading
                               with what a Gulf owner reads first; numerals
                               Western, AED, RTL — not translated. (Bilingual.)

The discipline is what a senior controller would demand before a number goes to the board or the FTA: a report that depends on one person’s heroic month, or a summary that’s really English finance wearing Arabic, fails quietly — in the audit, in the board meeting — so it has to be caught here. The bar throughout is the one the whole track holds to: would a CFO sign this number and put it in front of the board?

The bar, shown — a worked model answer (Mizan)

You don’t have to guess what “meets” looks like. Here are passing excerpts for the sample company’s May 2026 close — yours won’t look identical, it just needs to clear the same bar. Every number traces to billing-export-may.csv (1,248 rows; 3 blank, 2 duplicate charge IDs, 14 mis-dated — all handled by the M1 checklist before a single total). Mizan’s English report stays in English; the Arabic summary is authored, not translated.

reconciliation.md — Mizan, May 2026 (excerpt)

Matched — subscription charges (the 1,248-row export)
  1,243 charges matched to a payment, after the M1 checklist removed 3 blank
  rows and resolved the 2 duplicate charge IDs (one was the Al Hosn double-
  charge — see the audit). 1,248 − 3 − 2 = 1,243.

Unmatched / unpaid — the work (partner invoices, quarterly)
  Buraq Accounting        AED 38,500   62 days overdue
  Gulf Ledger Partners    AED 21,000   35 days
  Diwan Books Co.         AED 12,400    8 days
  -----------------------------------------------
  Overdue this batch      AED 71,900   <- traces row-by-row to the 3 above
                                          (full-ledger AR aging is M4's job)

Payment with no invoice — flagged, NOT absorbed
  AED 3,200 received, reference unmatched. Held pending a human — likely a
  prepayment or a misapplied reference. Not recognized as revenue this month.

(Collecting the overdue partners is the M4 cash-levers job; reconcile only
 NAMES them here.)

spend-audit.md — Mizan, May 2026 (excerpt)

Spend by category (rules applied from categorization-rules.md)
  Payroll               AED 312,000
  Hosting & infra (AWS) AED  48,000
  Software & tools      AED  26,000   <- the line that jumped
  Marketing             AED  64,000
  Office & admin        AED  22,000
  -------------------------------------
  Total spend           AED 472,000   (Revenue 512,000 -> net +40,000)

The ONE line that needs explaining — Software & tools (AED 26,000)
  Normal run-rate ~ AED 17,000/mo. May jumped +AED 9,000 (+53%). Decomposed:
   - Figma annual plan, prepaid in May   AED 6,000   ONE-TIME (won't recur
     till next year) — the largest single piece
   - New tool added (DocuSign, e-sign)   AED 2,000/mo   recurring
   - Analytics tool price crept up        ~AED 1,000/mo  (silent hike — M4)
  -> Strip the AED 6,000 one-time and the run-rate steps to ~AED 20,000/mo
     (not 26,000) — the new tool + the hike stay, until M4 trims them back.

Duplicate charge — caught
  Al Hosn Trading billed twice at AED 1,200 (a retry posted as a 2nd charge
  ID). Revenue NOT overstated. Fix = a credit note -> drafted here, approved
  by the controller (preparer != approver — finance-controls.md).

New vendor — flagged for a human
  DocuSign: never seen before, so NOT auto-categorized. Decision: Software &
  tools (a tool the ops team uses), confirmed by the controller.

leadership-summary.md — Mizan, May 2026 (under 200 words)

May closed net positive: +AED 40,000 (revenue AED 512,000, spend
AED 472,000). Cash is healthy — the month adds to the AED 2.4M balance.

The one number that moved is software spend: AED 26,000 against a normal
~AED 17,000. AED 6,000 of that is a one-time annual prepayment (the
design tool, billed once for the year); it won't recur. Strip it out and the
run-rate rose ~AED 3,000/mo: a new e-signature tool and a quiet price
increase on the analytics tool. Nothing structural.

Two to watch:
  1) AR is building. AED 71,900 is outstanding, and AED 38,500 of it is 62
     days overdue with one partner. Cash is fine today, but collections need
     a push this month.
  2) Software vendors. The annual prepay hides a real ~AED 3,000/mo creep —
     worth a vendor review before more tools auto-renew.

(Every figure traces to the May reconciliation and the categorization rules.
 One duplicate charge — AED 1,200 — was caught and is being credited.)

leadership-summary-ar.md — Mizan, May 2026 (note)

Authored, not translated. The Arabic summary LEADS where a Gulf owner reads
first — the cash position and the result — «الشهر أقفل إيجابي: +40,000 درهم،
والسيولة بخير» (the month closed positive: +AED 40,000, cash is fine) — then
the one line that needs explaining (software), framed the way an owner hears
it. Register: lightly-formal MSA with Gulf-natural phrasing, not stiff
fus'ha. Conventions: numerals Western (40,000, not the Arabic-Indic glyphs),
currency AED, dates Gregorian, layout RTL. Same trace-to-source + sign-off
gate; cleared by an approver who actually reads Arabic.

What you keep — toolkit additions

These extend the Foundation toolkit you already installed — same folder, same CLAUDE.md, two more templates and a few more saved prompts. Drop them next to your foundation files, and every month’s close starts from structure instead of a blank export.

# monthly-report-system.md — [Company] monthly close & report

## The three moves   (anyone can re-run; one owner per move)
1. Reconcile  — match invoices <-> payments (or bank <-> ledger) by ID. Name
                every unmatched item, total + age the outstanding, flag any
                payment with no invoice. (the whole report stands on this)
2. Audit      — categorize every row by categorization-rules.md (no feel),
                surface anomalies (over-normal charge, duplicate, new vendor),
                and decompose the ONE line that needs explaining.
3. Brief      — under 200 words: what changed, why, the two things to watch.
                Plain English, every number traced. Authored, then signed.

## When a report is wrong — name the broken move
numbers never reconciled -> reconcile   ·   a spike slipped through -> audit
the one thing got buried -> brief        ·   a category drifted -> the rules

## The controls gate   (never the preparer's to approve)
Anything that moves money — a credit note, a refund, a journal entry the
audit turns up — is drafted by whoever found it and approved by someone
ELSE (finance-controls.md). You prepare; a person signs. And every number
out traces to source with the work shown — no black box goes to the board.

# reconciliation + leadership-summary — [month]

## reconciliation.md   (build BEFORE the audit or the brief)
Matched:        [count] rows matched by [ID/reference] after the checklist
Unmatched/unpaid:[invoice]  [AED]  [days overdue]    <- name every one
                 ...
Outstanding:    [AED total]  <- traces row-by-row to the unmatched above
Orphan payment: [AED]  no matching invoice -> FLAGGED, held, not recognized

## leadership-summary.md   (under 200 words, authored from the figures)
Headline:    [net result this month, in AED — plain English]
Totals:      [revenue / spend / net — each traces to source]
The one line:[the number that moved + WHY — one-time vs run-rate]
Two to watch:[1) … 2) …]    <- two, not ten
Footer:      [every figure traces to the reconciliation + the rules]
(AR lane = its OWN summary, authored from the figures — adapt, don't translate.)

The saved-prompt library (Monthly report) — add to the Foundation set

Reconcile two files
  "Read data-checklist.md, then reconcile invoices.csv against payments.csv.
   Run the checklist first (rows, blanks, duplicate IDs, date formats) before
   matching. Match by invoice ID. Output: matched count, every unmatched/unpaid
   invoice with its amount and days overdue, the total outstanding, and any
   payment with no matching invoice flagged separately. Don't recognize the
   orphan payment as revenue. Show how you matched."

Audit and categorize the month
  "Read categorization-rules.md. Categorize every row in this month's export by
   those rules — never by feel; a new vendor stops for me, don't auto-bucket it.
   Then scan for anomalies: any charge well above its normal run-rate, any
   duplicate, any never-seen vendor. Surface the ONE line I'll have to explain
   to leadership and decompose it (how much is one-time vs recurring). Show the
   formula for every category total; tell me which one to spot-check by hand."

Brief leadership in under 200 words
  "Read the reconciliation and the spend audit. Write leadership-summary.md in
   under 200 words for a busy owner: what changed this month, why the one line
   moved, and the two things to watch — plain English, no GL jargon. Every
   number must trace back to the reconciliation or the rules; don't introduce a
   figure that isn't in them. Draft it; I'll trace and sign before it ships."

Author the Arabic leadership summary (adapt, don't translate)
  "Read the same figures and write leadership-summary-ar.md from scratch in
   Arabic for a Gulf owner — its own narrative, leading with the cash position
   and the result, then the one line that needs explaining. Lightly-formal MSA
   with Gulf-natural phrasing. Numerals Western, currency AED, dates Gregorian,
   layout RTL. An authored summary with its own emphasis, not a translation."

What you’ve proven — and what’s next

Clear the rubric and you’ve proven something a folder of heroic month-end closes never can: that your team turns a raw export into reconciled, audited, leadership-ready numbers predictably — a cycle, not a scramble, in English and Arabic. That’s the Monthly-report stage of “Certified Finance & Ops with Claude.”

From here the track turns a trustworthy monthly close into a finance function that plans ahead and answers to a board, each module assessed the same way:

• Module 3 — plan & forecast: turn the closed month into a 6-month cash-flow model and a budget-versus-actuals you can defend — every formula explained in one plain sentence, the plan the monthly cycle feeds.
• Module 4 — the cash levers, Module 5 — the close & the board, then the capstone — one company’s month closed, planned, and reported end to end into a board pack, graded into the certificate.

First, make the cycle reusable. The toolkit additions above — the report-system and reconciliation-plus-summary templates plus the saved prompts — turn the close you just ran into files your whole team reports from, extending the Foundation toolkit you already installed. And if you’re rolling this across a team, the operating guide is the data, controls, and sign-off layer that belongs underneath the whole cycle.