PlanSource
The deduction audit that went from three days to ten minutes
Cut a multi-day, by-hand deduction audit to a ten-minute run — consistent every time.
May 30, 2026
01
Problem
PlanSource administers benefits and also runs the paychecks, so deductions — benefit premiums, garnishments, and the rest — have to be configured in two separate systems: Benefits Admin and the Backoffice compensation system. Those two systems drift out of sync, and when they disagree the wrong amount can come out of a real person’s pay. Catching that drift was a manual job. Someone exported reports from each system and compared them by hand in spreadsheets — typically about three days of work, longer for larger clients. There was no standard method, so the answer depended on who did it, and a missed mismatch could reach a paycheck.
02
Solution
I built an API-based tool that reads the configuration directly from the Benefits Admin API and the Backoffice API, normalizes both into one shape, and runs a single deterministic comparison across them. It surfaces every place the two systems disagree about how a deduction is set up, links each one back to the record that needs attention, and reports only the mismatches — so a specialist reviews the handful that are actually wrong instead of re-reading thousands of rows that are right. The tool draws the line clearly: it surfaces the inconsistencies, and a human makes the correction. Earning trust in that line was the real work — we ran it alongside the manual audit until the results matched, then retired the manual pass.
03
Results
Time-to-actionable dropped from about three days to at most ten minutes, usually less, and the analysis is now consistent and accurate run to run. One specialist clears several client audits in a day — work that used to take multiple people multiple days. The same two-system reconciliation pattern became the foundation for later projects that folded separate systems into a single UI.
The full story
A multi-day, by-hand deduction audit became a ten-minute run that reads the same every time
PlanSource is a benefits administration platform, and it also runs the paychecks. That second part is where the risk lives: every deduction — a benefit premium, a garnishment — has to be configured in two separate systems, Benefits Admin and the Backoffice compensation system, and those two systems can drift apart. When they disagree, the consequence isn’t abstract. The wrong number comes out of someone’s pay.
Keeping the two in agreement used to be a manual audit. A person exported reports from each system and compared them by hand in spreadsheets — roughly three days of work, more for larger clients. Because there was no standard method, two employees could audit the same client and reach different answers, and a single missed mismatch could land on a paycheck before anyone caught it.
What was done
I built an API-based tool that does the reconciliation directly. It calls the Benefits Admin API and the Backoffice API, pulls each system’s deduction configuration into one normalized shape, and runs a single deterministic comparison across the two. Where they disagree on how a deduction is set up, it surfaces the mismatch and links straight back to the record a specialist needs to look at. It reports only the inconsistencies — not the thousands of rows that already agree.
The design holds one line firmly: the tool surfaces, the human fixes. It never edits either system. It removes the slow part — a person reading correct data to find the few wrong rows — and leaves the judgment, the actual correction, with the specialist who should own it. Two independent systems, reconciled through their APIs into one comparison that reads the same no matter who runs it.
The result
Time-to-actionable went from about three days to at most ten minutes, and usually less. More than the speed, the analysis is now consistent and accurate — the answer no longer depends on who did the audit.
| Before | After | |
|---|---|---|
| How it ran | Manual export-and-compare in spreadsheets | API-driven deterministic comparison |
| Time to actionable | ~3 days (more for larger clients) | At most ~10 minutes, usually less |
| Consistency | Varied by employee, no standard method | Same accurate result every run |
| Throughput | Many people, many days | One specialist, several audits in a day |
One reflection
The engineering wasn’t the hard part. The hard part was earning trust in a deterministic tool that replaces human judgment people had relied on for years. The honest way through was to prove it, not argue it — we ran the tool alongside the manual audit until every mismatch it raised was real and every row it passed was right, and only then let the manual process go.
What makes this more than a one-off is what it left behind. Reconciling two independent systems through their APIs into one comparison turned out to be a reusable pattern, and it became the infrastructure for later projects that pulled separate systems into a single user-friendly UI. The audit tool wasn’t just a faster audit — it was the first instance of a capability the team kept reaching for.
Have a system like this? Tell me what's slipping.
If a system in your world is drifting, slow, or held together by one person, tell me what's breaking — that is exactly the kind of work this was.
Tell me what's slipping →