Inspiration: every other Friday, Shanin turns detective

Shanin, one of our three teammates, runs a six-figure landscaping company with 15 people. Every other Friday, he spends hours piecing together payroll across Jobber, QuickBooks, Gusto, spreadsheets, and text messages.

The hardest part of payroll isn't calculating pay. It's making sure all the information is accurate first.

Timesheets need to match jobs, expenses need to be reconciled, and commissions and profit sharing depend on accurate job profitability. One missing expense or incorrect timesheet can affect multiple calculations downstream.

Then come the exceptions: overlapping hours, missing pay rates, duplicate expenses, and conflicting records across software. Each one becomes another investigation or text thread before payroll can be submitted.

Shanin got so tired of it that he wrote a 29-page payroll runbook and documented 125 real problems across just three pay periods, roughly 40 things to investigate every payroll.

Existing payroll software handles calculations and payments, but much of the work of gathering information, reconciling records, and resolving discrepancies still falls on the business owner.

Then we walked into Black Forest Kitchen

To see whether this problem extended beyond landscaping, we visited Black Forest Kitchen in Oakland, a restaurant with approximately 25 employees.

They confirmed similar challenges with missed clock-outs, overlapping shifts, tips, and California's daily overtime rules. Walking them through RollPay validated the need for a system that could reconcile information and prepare payroll automatically.

And the opportunity is substantial. The US payroll services industry generated approximately $27.6 billion in revenue in 2022, yet business owners still spend hours manually gathering, checking, and reconciling the information those systems depend on.

Using Shanin's documented problems as a baseline, we estimate RollPay could save a similar 15-person business 250 hours annually, over six full working weeks, across payroll preparation, reconciliation, and employee follow-ups.

We're starting with landscaping, trades, cleaning, HVAC, and restaurants, where disconnected systems and complex compensation make payroll preparation especially painful.

That's why we built RollPay: an autonomous payroll preparation and reconciliation team that learns how your business works.

What it does

RollPay takes the seat of the person who prepares and checks payroll, coordinating the complex workflows between software systems, financial records, managers, and employees.

Learns. Studies historical payrolls, jobs, expenses, and compensation structures across Jobber, QuickBooks, and Gusto. It proposes company-specific rules, shows the evidence, and backtests them against historical payrolls. Nothing becomes active without owner approval.
Runs. Gathers records from all three systems, verifies every data pull is complete, and runs 23 deterministic checks. It reconciles timesheets, expenses, and job costs before calculating dependent compensation like commissions and profit sharing. Then it prepares the Gusto draft. It never submits payroll.
Escalates. When something doesn't match, RollPay identifies who actually knows the answer and drafts one short text for human approval. Only the disputed item and its dependent calculations are held while unrelated payroll preparation continues.
Improves. Every resolved discrepancy becomes a potential lesson. RollPay backtests proposed rules and applies them only after owner approval. In our tests, the number of items needing a person dropped from 28 to 21 to 17 as it learned.

The moment. Sam, a fictional worker in our demo, logged 7:00–15:30 and 12:00–16:00 on the same day, the kind of overlapping hours Shanin found in his real payroll.

RollPay catches the overlap and holds Sam's disputed hours. A manager approves one question, and Sam replies: "The 12 to 4 was the Foxglove wall."

RollPay interprets the answer, proposes a correction, and the owner approves it in RollPay's workbook, without changing Jobber.

And if Sam's hours affect a job's profitability, any commission depending on that job waits until the records are reconciled.

A Friday-night phone call becomes one short exchange, with every decision documented.

How we built it

RollPay is a TypeScript monorepo consisting of a pure checks and payroll engine, a Convex backend, a Next.js dashboard, and a texting worker called the courier.

Our architecture separates responsibilities: AI handles context, investigation, and communication. Deterministic code handles validation, reconciliation rules, and payroll calculations.

One payroll moves through six stages:

Sync. Connectors pull Jobber (GraphQL), QuickBooks Online, and Gusto into a shared Zod schema. Every pull records expected versus retrieved data. Incomplete data blocks affected calculations rather than silently producing incorrect payroll.
Check. The engine runs 23 deterministic checks, including overlapping shifts, open timers, rate mismatches, duplicate purchases, and pay swings exceeding 25%. It reconciles information across systems and tracks dependencies between records. The Creao Auditor investigates what deterministic rules can't interpret; a job match below 85% confidence becomes a question.
Ask. A template or the Creao Messenger drafts a question, which a person approves before sending. The courier (Bun + Photon) sends it through iMessage and relays the reply. It's the only process that accesses phone numbers.
Fix. Code processes structured responses like numbered answers and poll taps. Claude Haiku 5.5 interprets free text when code can't. The system proposes a correction for human approval, updates the payroll workbook, and recalculates affected amounts without modifying source systems.
Learn. The Creao Analyst compares resolved discrepancies with existing company rules. Code backtests proposed improvements against historical payrolls, and the owner approves each new rule before it's activated.
Draft. After the owner's Gate 1 review, RollPay calls Gusto's prepare, update, and calculate operations to populate the payroll draft. There is no submit call anywhere in our codebase.

The three Creao agents run on Claude Opus 5.5, are triggered only by our Convex controller, and return schema-validated proposals. They operate on anonymized context without names, phone numbers, or direct pay calculations.

An append-only audit log traces every calculation and decision back to its source.

How we know it works

We built repeatable evaluations that run on every pull request. If a check stops catching an error or a learned rule stops resolving an expected issue, CI fails.

It catches the errors. On our synthetic landscaping company, with an answer key no model ever sees, RollPay detected 29 of 29 planted errors in cycle 1 and 30 of 31 in cycle 2, with zero false alarms.
It gets better every cycle. We ran the same cycle-2 payroll three times. Without learned rules, 28 items needed a person. With rules learned from four historical payrolls, 21. After incorporating three approved rules from cycle 1, each backtested against four historical cycles, 17. That's a 39% reduction in items requiring human intervention.
It reproduces real payroll. On Shanin's real, anonymized payroll history (283 timesheet entries, 188 payroll rows), RollPay reproduced historical pay to the cent in 35 of 46 worker pay periods and within $1 in 44 of 46. On a synthetic HVAC company with California daily overtime, it matched 120 of 120 results to the cent.
It knows when its data is incomplete. Of 14 sync tests, 13 returned complete data. The one incomplete pull, a deliberately shortened Jobber response containing 75 of 76 time entries, was detected and blocked.

Our demo runs on Shanin's real payroll history, not just synthetic data.

Who built what. Shanin: connectors, payroll math, synthetic data, backtesting, and much of the dashboard design. Devaj: Convex controller, checks, texting and learning loops, Creao integration. Varnika: message templates, courier and texting, live dashboard wiring, privacy tests, and the demo.

Together, we completed approximately 125 pull requests in 36 hours.

Challenges we ran into

Our own completeness check caught us first. The first live Jobber pull was missing two fields, and RollPay refused to trust it, exactly as designed.
Sandboxes that can't do what you need. Jobber's API can't create time entries, and Gusto's demo environment can't create payroll history without submitting. Some data therefore loads from fixtures, clearly labeled throughout the demo.
Texts have no reliable thread ID. Each phone number can hold at most one open question at a time, preventing answers from being attached to the wrong payroll issue.
Real data fights back. Shanin's exports contained missing fields, duplicated entries, and one worker with two separate Jobber accounts.
The one error we missed. In cycle 2, the engine missed a worker deactivated in Jobber but still active in Gusto. Our data model doesn't yet carry Gusto's employment status, so that's the next check to fix.

Accomplishments that we're proud of

Building on a real business problem, backed by a 29-page runbook, 125 documented payroll problems, and actual payroll records.
Catching 59 of 60 planted errors with zero false alarms, and reducing human intervention from 28 to 17 items as RollPay learns.
Reproducing real payroll calculations, matching 35 of 46 worker pay periods exactly and 44 of 46 within $1.
Validating the problem with a real business outside our own team.
Completing a real iMessage round trip, from detecting a discrepancy to receiving an answer and approving a correction.
Keeping pay amounts out of text messages, enforced through automated privacy tests.

What we learned

Payroll is a dependency problem.

Before calculating someone's commission, you need accurate job profitability. Before calculating profitability, you need reconciled revenue, labor, and expenses. Before calculating labor costs, you need accurate timesheets and pay rates.

One unresolved record can affect several calculations downstream.

We learned that automating payroll requires understanding these interconnected workflows and knowing when enough information has been verified to proceed.

AI is most useful when it returns something code can verify.

Our agents handle context, interpretation, and communication, while deterministic code handles calculations and approvals. This lets us use AI for complex workflows without giving it direct control over paychecks.

Most of the challenge is deciding when to ask.

Some problems can be resolved from existing records. Others require the person who actually knows what happened.

An autonomous system that constantly interrupts employees isn't useful, and one that silently guesses wrong is dangerous. RollPay needs to learn which questions are necessary and which it can safely resolve itself.

What's next for RollPay

Pilot with a real business, starting with prospects like Black Forest Kitchen and adding restaurant time-clock and POS integrations.
Gusto production approval and per-company OAuth, allowing owners to securely connect their existing software.
More complex compensation workflows, including commissions, bonuses, profit sharing, and contractor payments that depend on reconciled financial data.
Real manager logins, allowing managers to resolve specific issues without accessing the company's entire payroll.
Fewer questions every cycle, as RollPay learns each company's rules and handles routine reconciliation automatically.

Our goal is for RollPay to become an experienced member of the payroll team, gathering records, reconciling information, coordinating with employees, and bringing owners only the decisions that genuinely need them.

So business owners can spend their Fridays running their businesses instead of investigating payroll.