AI tax prep, rebuilt
FASTMAX
How we helped FASTMAX turn a wall of tax forms into a finished, reviewed, signed return — with zero manual data entry.
- Year
- 2026
- What we did
- Consumer site, guided app, INTELLICORE engine & brand
The problem
Consumer tax software never grew up — even as people’s money got complicated.
Finances stopped being simple. A single household can carry a W-2, freelance income, multiple states, RSUs, crypto, a rental, an LLC. The software that’s supposed to handle all of it still asks people to read their own forms and key the numbers in, box by box.
That makes the person do the work of a clerk. It’s slow, it’s error-prone, and it punishes exactly the people whose returns are hardest. The complexity went up; the tooling didn’t move.
Even the professionals feel it. Most of a preparer’s billable hours go to typing figures off PDFs instead of the judgment work only a human should do. FASTMAX came to us to break that pattern at the root.
What makes it different
The build decisions that made it work.
A tax engine has no margin for sloppy reads or hand-waved math. Every choice served accuracy, trust, and a flow that feels effortless to the person on the other side.
Two document-AI engines, not one
We ran ingestion and extraction through both Azure Document Intelligence and Google Document AI. Two readers on the same form means classification and extraction don’t hinge on a single vendor’s blind spots.
An engine, not a form
INTELLICORE doesn’t just capture numbers — it validates them, builds the schedules, flags anomalies, and assembles the return. The intelligence lives in the engine, so both surfaces stay thin and fast.
A human in the loop, by design
Automation handles the typing; a tax pro reviews before anything is filed. We built the review step in from the start, so speed never comes at the cost of a signed-off return.
One engine, two front doors
A consumer site and a nine-step guided return app sit on the same core. New surfaces inherit the engine instead of reimplementing it, and the logic stays in one place.
A no-login intro that earns commitment
We made the entry deliberately playful and login-free, so people can feel the product before they hand over a single document. The proof comes first; the sign-up follows.
Privacy as a requirement, not a footnote
Enterprise-grade encryption throughout, and customer data is never used to train models. With tax records, trust isn’t a feature you add later — we treated it as a constraint on the whole design.
Upload your forms. Get back a finished return. No box-by-box typing in between.
Under the hood
An AI tax engine, specified.
A Next.js app on Neon and Drizzle, wrapped around a document-intelligence pipeline that turns uploads into a filed-ready return.
Core platform
- Framework
- Next.js (App Router) · React · TypeScript, deployed on Vercel with Analytics and Speed Insights.
- Data layer
- Neon serverless Postgres with Drizzle ORM and drizzle-kit migrations — schema-versioned, with scripted backfills.
- Identity & tenancy
- Clerk for auth and organizations — the same identity layer spans the consumer flow and the preparer back office.
- Pipeline
- Inngest (with Inngest Realtime) orchestrates the read-and-assemble pipeline and streams live status back to the UI.
Document intelligence
- Extraction
- Azure AI Document Intelligence + Azure Content Understanding and Google Cloud Document AI read uploaded tax forms — OCR, classification and field extraction.
- Reasoning
- Anthropic, OpenAI and Google models validate, reconcile and reason over extracted data — the INTELLICORE engine’s logic layer.
- Capabilities
- Document ingestion, OCR, classification, reasoning, validation, schedule creation and anomaly detection — the ‘grunt work’ automated end to end.
Documents, storage & realtime
- Return generation
- pdf-lib + fontkit assemble returns; signpdf with p12 signing produces digitally signed PDF documents; embedpdf renders them in-app.
- Storage
- DigitalOcean Spaces / AWS S3 for uploaded documents and generated packages, with backfill tooling for migrations.
- Realtime & limits
- Ably for realtime updates; Upstash Redis for rate limiting; canvas-confetti for the moment the return lands.
Trust & operations
- Privacy
- Enterprise-grade encryption; customer data explicitly excluded from model training.
- Automation
- Browserbase + Stagehand and a browser-use SDK power agentic automation around the edges of the workflow.
- Surfaces
- Consumer marketing site (fastmax.tax) and a guided nine-step return app (app.fastmax.co) on a shared engine.
The build, on screen
Inside the build.
Technology
What it’s built on.
- TypeScript
TypeScript- Next.js
- React
Next.js
React- Neon (Postgres)
- Drizzle ORM
Neon (Postgres)
Drizzle ORM- Clerk
Clerk- Anthropic
- OpenAI
Anthropic
OpenAI
Google- Inngest
- Ably
- Upstash Redis
Inngest
Ably
Upstash Redis- DigitalOcean Spaces
- AWS S3
DigitalOcean Spaces
AWS S3- Azure Document Intelligence
- Google Document AI
- signpdf
- Browserbase
Azure Document Intelligence
Google Document AI
Browserbase- Vercel
VercelOur approach
How we approached it.
We worked from the moment of pain backwards: the person staring at a stack of PDFs. Every stage exists to move them from that pile to a signed return without making them the data-entry clerk.
- 01
Read the forms, don’t ask for them.
The person uploads what they have. Document-AI handles ingestion, OCR, classification and extraction across both engines — so the source of truth is the actual form, not a retyped copy of it.
- 02
Validate, build, and flag.
INTELLICORE checks the extracted figures, assembles the schedules, and surfaces anomalies for attention. Catching problems mid-pipeline is what keeps the final return trustworthy.
- 03
Put a professional on it.
Before filing, a human tax pro reviews the assembled return — the deliberate seam between automation and accountability. Fast where machines are good, careful where judgment matters.
- 04
Generate and sign.
The finished return is produced and digitally signed as a PDF. The person ends where they wanted to start: with a completed, signed document and none of the keystrokes.
Next case study
How we designed and built GENIUS — an AI phone system that turns the call itself into finished work.