First client project delivered: what a real AI system is made of
The problem
A Bay Area CPA firm files between 1,000 and 2,000 tax returns a year.
Every return arrived the same way. A pile of documents in an email. PDFs, scanned pages, photos taken on a phone, handwritten notes. W-2s, mortgage interest statements, the whole 1099 family, brokerage statements running 40 pages, property tax bills from 5 counties.
Someone opened each one, worked out what it was, renamed it, read every field, and retyped the numbers into an Excel work paper.
About 2.7 hours per client, senior review included.
That is the equivalent of two full-time people, all year, moving numbers from one place to another. And it grew with the business. More clients meant more hours, one for one.
The result
It now takes about 17 minutes. At 1,000 tax returns, around 2,400 hours a year, handed back.
The full before and after is in the case study.
But the number is not the interesting part. Plenty of demos can pull a field off a form. Almost none of them survive contact with a real firm's real documents on a real deadline.
So here is what it actually took.
Front end
The hardest part is the review queue. Not building a list of flagged items, which is easy. Making every single flag link back to the exact page of the exact document the number came from, so a preparer can check it in 2 seconds instead of hunting through a 40-page brokerage statement.
That link only works if every value carries its origin with it from the moment the file lands. It is a front-end feature that constrains the entire architecture behind it.
Around it: a production web portal with logins, admin and preparer roles, and a client dashboard. Drag in any format at all. Every file is automatically renamed to the firm's own convention, saved to their own drive, with the original kept exactly as it arrived. Wrong file type, one click re-reads it. Download the whole set as a zip.
AI reading
The hardest part is not reading a form. It is knowing when not to trust the read.
Fields that matter get read twice, by 2 independent paths, with an arithmetic check on top. Where the two disagree, a person sees both values, both confidence scores, and decides. The machine does not quietly pick a winner.
Underneath that, a document is identified before anything tries to interpret it. Known forms are matched exactly, because when a document is unambiguous you do not want a model's opinion about it. The AI only steps in where the exact match fails, and when it does, it says how sure it is.
Every document is identified by reading its content, never by trusting the filename. A file called scan_003.pdf still routes correctly. And the inputs are genuinely messy: scans, phone photos, handwritten notes, 40-page consolidated statements that get split into their interest, dividend and capital gains parts with the totals checked against each other.
28 to 31 distinct form types. That part is just work.
Human in the loop
The hardest part is that a human edit is never overwritten.
Consider what has to be true for that to hold. A preparer corrects a figure on Tuesday. On Thursday a late document arrives carrying a different value for the same field. The system has to layer the new document in, notice the disagreement, keep the human's number, and flag the divergence rather than silently resolving it either way.
Getting that right is the difference between a tool people trust and a tool people stop using after it eats their work once.
Around it: every field carries a confidence score, and flags from 10 different sources arrive in one queue rather than scattered across the interface. Numbers are color coded by origin, blue where a person corrected the machine, purple where a person typed it from scratch, so months later anyone can see which figures a human touched. Duplicates are shown side by side and never merged automatically. Sign-off happens form by form, and the whole thing leaves an audit trail.
And nothing is ever silently dropped. A document that cannot be identified surfaces in a panel that says so. A silent drop was treated as a ship blocker from day one.
Back end
The hardest part is the Excel round-trip.
Preparers finish returns in Excel. They have always finished returns in Excel, and no amount of good interface design changes that. So rather than fight it, the system lets them.
They edit the workbook offline. The server then re-reads the saved file, compares it against what it originally generated, works out which cells a human actually changed, and writes only those back. Everything else refreshes normally.
That single mechanism is why edits survive, and it is the piece I would rebuild exactly the same way.
Underneath it, there is one place every number lives, holding both the value and where it came from, and both the portal and the spreadsheet render from it. The two surfaces cannot disagree. Finished files sync back to the firm's own drive. Big jobs run in the background with per-client locks, so a 1,700-page upload does not freeze anyone and two people cannot overwrite each other. The largest single upload the system has handled is 137 MB.
Security
The hardest part is running the AI inside the client's own cloud.
It is easy to call a public model API. It is considerably harder to provision the AI inside the client's own cloud subscription so that their clients' names, addresses and social security numbers never leave infrastructure the firm controls.
For a firm handling other people's tax data, that distinction is not a nice-to-have. It is the reason the conversation can happen at all.
The rest: their own domain, their own TLS certificate, passwords and keys in a managed vault and never in the code, passwordless deploy authentication, social security numbers never sent to the browser, login attempts throttled, and account activity logged separately from the per-client audit trail.
The security audit closed with zero critical findings.
Development, which is where most demos stop
Everything above is table stakes for something a firm will put their name on. What separates a production system from a good demo is what you build to check it.
Around 4,000 automated checks run before anything ships. A frozen set of reference cases the release is compared against, so the release stops itself if a number moves when it should not have. Browser-level tests that click the real screens rather than asserting on markup. The system renders its own output and looks at it before a human opens the file. And it is tested against corrupt files, oversized files, and files that are not what they claim to be.
None of that is glamorous. All of it is why the thing is still standing.
Where this goes next
Nothing above is specific to tax.
The pattern is: sort it, read it, score the confidence, flag what is uncertain for a person, keep a link back to the original the whole way through, and never let the machine make a call a human should own.
Insurance claims. Loan files. Supplier invoices. Benefits enrolment. Purchase orders. Anywhere a person is retyping a document into a system, the same architecture applies.
If that is happening in your business today, it is worth an hour of conversation.
Let's chat if you want to talk about AI automations.
Automate. Ascend.