Pre-Flight Payroll Audit: Catch the Bad Run Before the Money Moves
Compare this run's draft payroll against the last run and your rules, surface the dangerous outliers — pay swings, zero/negative net, missing direct deposit, no-hours actives, terminated-but-still-paid — and make the payroll manager disposition every flag before a single sign-off releases the run.
A web tool where you import the current draft payroll, the prior period, and the active roster; AI runs variance and rule checks and ranks the exceptions; the payroll manager dispositions each flag (expected raise vs. error); and a single sign-off writes an immutable 'cleared to run' record and an annotated export.
Before you start
- A Supabase account (free)
- A Vercel account (free)
- A Resend account (free)
- Your current draft payroll as a CSV/Sheet
- The prior period's payroll as a CSV/Sheet
- Your active-employee roster
- Claude Code or any AI coding agent
The problem this kills
Payroll is the one process where you get a single shot. Once the file is submitted and the money moves, fixing a mistake means off-cycle checks, clawbacks, an awkward call to a panicked employee, and sometimes a tax filing headache. And the mistakes are the boring, easy-to-miss kind: a salaried employee whose pay quietly doubled because a number got fat-fingered, someone showing zero net pay, an active employee with no hours this period, a person who was terminated last week but is still on the run, a new hire whose direct deposit never got set up.
Right now the only "audit" is a tired human scrolling a draft register late on submission day, eyeballing hundreds of rows, hoping nothing slipped. That's not a control — that's a coin flip. You don't need to live like this, and you don't need to be a developer to fix it.
What you'll build
A simple internal web tool that acts as a second set of eyes that never gets tired. You import three things: this run's draft payroll, the prior period for comparison, and your active-employee roster. The tool matches employees across the runs, then applies a set of checks: pay change over your threshold (up or down), zero or negative net, missing direct deposit, an active employee with no hours, and a terminated employee who's still being paid. It produces a ranked exception report — the scariest flags first — and hands it to the payroll manager. The manager reviews each flag and dispositions it: "expected raise," "approved bonus," or "this is an error, fix it." When every flag is cleared, one sign-off writes an immutable "cleared to run" record (who cleared it, when) and produces an annotated export you can keep as proof and feed back to your provider.
What's inside the Implementation Plan
The downloadable plan is a step-by-step file you paste into an AI coding agent. It opens by interviewing you about your business — what your draft register columns are named, how you identify employees across runs, your pay frequencies and groups, the exact variance thresholds you care about, which exceptions are "expected" for you (new hires, bonuses, commissions, seasonal swings), how you mark someone terminated, and your messy edge cases — and then it tailors the data model, the checks, and every later step to your answers. This is not a generic template; the agent reflects a short spec back to you and waits for your thumbs-up before it builds anything. From there it walks the agent through the imports, the employee-matching logic, the variance and rule checks, the ranked exception report, the manager disposition screen, the immutable sign-off, and the annotated export — each step with a ready-to-copy prompt. There's also a fallback so you can build and use the whole thing today off nothing but your current and prior CSVs — no provider API required.
The governance it includes (this is the point)
This tool touches people's paychecks, so it ships with the controls a payroll team needs: login so only your team can use it, row-level security so you only ever see your own organization's payroll data, a complete audit trail of who imported, who dispositioned which flag and how, and who signed off — and when. The human-in-the-loop gate is the whole design: the AI drafts the exceptions, but nothing is "cleared to run" until a person dispositions every flag and gives a single sign-off, recorded as an immutable record that can't be quietly edited later. Duplicate guards keyed on employee + run mean the same person can't be double-counted in an import and the same run can't be cleared twice.
Who it's for
Payroll managers, payroll specialists, and HR/finance leads who own the run and know that "I'll just be careful" isn't a control. If you can describe how your shop spots a bad paycheck today, you can build this — and replace the late-night scroll with a checklist that catches the dangerous stuff every single time.
You've got this — start with the plan, paste the first prompt, answer the interview, and you'll watch your first ranked exception report come together the same afternoon.