You can build a fully automated AI invoice processing system — intake, data extraction, approval routing, and QuickBooks sync — in three days using off-the-shelf tools, for under $200 a month. We know because we did it for a 12-person construction supply company that was drowning in 300+ vendor invoices every month.
The Starting Point: A Process That Was Technically Working
Before we touched anything, we mapped what the company was actually doing. Two people split invoice duty. Invoices came in by email, sometimes PDF, sometimes a scanned image someone photographed with their phone. Each one got manually keyed into a shared Google Sheet — vendor name, invoice number, line items, total, due date. Then a manager eyeballed the sheet and approved anything under $2,500. Anything over that went to the owner. The approved invoices then got manually entered into QuickBooks Online. Turnaround averaged four days per invoice. Late payment fees had hit $1,800 in the previous quarter alone.
Nobody was lazy. The process was just badly designed for the volume they were handling.
The Tools We Chose and Why
Mindee for Document Parsing
Mindee is an OCR-plus-AI document parsing API built specifically for financial documents. Unlike general-purpose OCR tools, Mindee has a pre-trained invoice model that pulls structured fields — vendor name, invoice number, line items, totals, tax, due dates — without you needing to set up field templates for every vendor. That matters a lot when your vendors include a Fortune 500 distributor, a local hardware outfit printing invoices on Word, and a guy who emails you a picture of a handwritten note.
Pricing sits at around $0.01 per page on their pay-as-you-go tier, which for 300 invoices averaging 2 pages each works out to about $6 a month. The Pro plan at $49/month makes more sense if volume climbs. The real limitation: Mindee’s confidence scoring on low-quality scans can be unreliable. A crumpled invoice photographed under bad lighting will extract something, but the confidence score on individual fields will drop below 0.85 and you’ll want a human to review those before they move forward. Plan for that edge case — it’s roughly 8-10% of intake at this company.
Make (Formerly Integromat) for Orchestration
Make is the automation platform we used to wire everything together. We evaluated Zapier too, but Make’s multi-step conditional routing and its native JSON handling made it the right call here. The visual scenario builder let us build approval branches based on invoice amount without writing a single line of code. The Core plan is $9/month for 10,000 operations — we burned through about 3,600 operations in the first full month, so that headroom is fine for now.
Make’s weakness is the learning curve on error handling. When Mindee returns a low-confidence parse, you need to set up proper error routes in Make or the whole scenario will just fail silently. That took an afternoon to get right. (If you want a comparison of where Make fits against other platforms, the truth about AI automation ROI covers some of the platform selection thinking in more detail.)
QuickBooks Online for the Backend
QuickBooks Online was already in place, which made it the obvious destination. Make has a native QuickBooks connector, so we didn’t need a middleware API. The integration creates a Bill record directly from the parsed invoice data. The one annoying thing: QuickBooks requires vendor records to match exactly before it will attach a bill. New vendors broke the flow until we added a step that checks the vendor list first and creates a new record if needed. This took two hours to debug because the QuickBooks API returns a vague 400 error when that mismatch happens — not “vendor not found,” just “invalid request.”
The Actual Workflow, Step by Step
Here’s the complete flow we built. Seven steps, all automated except the approval click:
- Step 1 — Email Intake: Make watches a dedicated Gmail inbox (invoices@[company].com). Any email with a PDF or image attachment triggers the scenario.
- Step 2 — Parse with Mindee: The attachment is sent to Mindee’s invoice parsing endpoint via HTTP module. The response comes back as JSON with all extracted fields and per-field confidence scores.
- Step 3 — Confidence Check: Make’s router checks if every critical field (total, vendor, due date) has a confidence score above 0.85. If not, the invoice gets flagged and an email goes to the AP person with the raw extracted data for manual correction. If yes, it moves forward automatically.
- Step 4 — Approval Routing: Totals under $2,500 get auto-approved. Totals between $2,500 and $10,000 trigger a Slack message to the manager with an approve/reject button (we used Make’s built-in Slack integration with a webhook callback). Anything over $10,000 goes to the owner’s email with the same button-based approval.
- Step 5 — Vendor Lookup: On approval, Make queries QuickBooks for a vendor name match. If no match exists, it creates the vendor record first.
- Step 6 — Bill Creation: Make pushes the parsed data into QuickBooks as a Bill, including due date, line items where Mindee could extract them, and the PDF attached as a document.
- Step 7 — Logging: Every invoice — approved, rejected, flagged — gets logged to an Airtable base with a timestamp, outcome, and extracted total. This is the audit trail the owner wanted.
Build Day by Day: How Three Days Actually Looked
Day 1 was entirely Mindee. We set up the API key, fed it 40 real historical invoices from their archive, and studied the output. We found three vendors whose invoices Mindee consistently misread — one because they use a dark blue background that tanked scan quality, one because their line item table format is unusual, one because they send invoices as embedded images inside HTML emails rather than PDF attachments. We wrote exception rules for each. None of this was glamorous. It was just careful.
Day 2 was Make scenario building. The basic happy path — email arrives, Mindee parses, QuickBooks bill created — took maybe three hours including testing. The conditional routing, error handling, Slack integration, and the vendor-not-found fix took the rest of the day. We tested with 20 live invoices from that week’s inbox.
Day 3 was the handoff. We recorded a 12-minute Loom walkthrough for the AP person showing what the flagged invoice emails look like and how to correct them. We also set up a simple daily digest that sends the owner a summary of what processed overnight. Then we watched it run for a full business day, fixed two small bugs (one in the Slack callback URL, one in a date formatting mismatch between Mindee’s output and QuickBooks’ expected format), and called it done.
If you’ve worked through a similar project like automating a multi-step client reporting workflow, you’ll recognize that “Day 3 is cleanup day” is basically universal. Budget for it.
Results After 60 Days
Average invoice turnaround dropped from four days to same-day for auto-approved invoices and next-business-day for everything else. The AP person went from spending roughly 11 hours per week on invoice processing to about 90 minutes — mostly handling the flagged low-confidence documents and answering the occasional vendor question. That’s a real 87% time reduction on that specific task.
Late payment fees in the first full month of operation: zero. In month two: $0 again. The $1,800 quarterly loss paid for the tooling in roughly six weeks.
Total monthly software cost for this stack: Mindee (~$12), Make Core ($9), Airtable free tier ($0 for their use case). Call it $21/month excluding QuickBooks, which they already had.
What I’d Do Differently
The biggest thing I underestimated was the vendor master data problem. Before you build any AI invoice system, clean your vendor list. Duplicate vendor records in QuickBooks created a mess where bills were sometimes attaching to the wrong vendor entity. We spent half a day in week three cleaning that up — work that had nothing to do with AI and everything to do with boring data hygiene.
I’d also add a duplicate invoice check earlier in the flow. Right now, if someone forwards the same invoice twice, it gets created twice in QuickBooks. Mindee returns the invoice number, so it’s technically easy to add a check against Airtable before creating the bill. I just didn’t build it in the original three days and the workaround (the manager catching it during Slack approval) is imperfect.
If you’re thinking about going further — building out AI to handle contract review alongside invoice processing, for example — the approach in building an AI contract review system with Claude and Zapier is worth studying as a complement to this kind of AP automation.
My Honest Recommendation
If you’re processing more than 75 invoices a month and manually keying data into any accounting system, this build is worth your time. The Mindee + Make combination is genuinely approachable for a non-developer — but don’t skip the day of testing real historical documents before you build the automation. That’s where you discover your actual edge cases, not hypothetical ones. Start with a dedicated email inbox, keep humans in the approval loop for anything above a threshold you’re comfortable with, and log everything to a simple spreadsheet or Airtable. The AI handles the extraction. Your process handles the judgment calls.
FAQ
Can this workflow handle invoices that aren’t PDFs?
Yes, with limits. Mindee accepts JPG, PNG, and PDF inputs, so phone photos of invoices work. Quality matters though — the confidence scores on blurry or poorly lit images drop significantly and you’ll see those routed to manual review more often. For HTML email invoices with embedded images, you’ll need an extra Make step to extract the image before passing it to Mindee.
What happens if Mindee extracts the wrong total and it gets auto-approved?
This is the right question to ask. We set the confidence threshold at 0.85 specifically to catch most of these cases, but it’s not foolproof. For the auto-approve tier, we kept the dollar limit low ($2,500) so worst-case exposure is bounded. For anything higher, a human sees it anyway. If you have a zero-tolerance policy on errors, raise the confidence threshold and accept more manual reviews — that’s your tradeoff.
How long does it actually take to build this if you’re not technical?
Realistically, four to five days if you’ve never used Make before and you’re patient about testing. The Mindee documentation is solid and they have a working invoice parser you can test in their playground before writing a single automation step. Make’s learning curve is the bigger investment — give yourself a day just to build something simple in Make first before you tackle the full flow.
<<
This article was produced with the assistance of AI, and its featured image was AI-generated. We review for accuracy, but please verify critical details.
