Cutting invoice processing time by 80% for a mid-size manufacturer

Last fall, a mid-size manufacturer reached out with a problem we hear often: their accounts payable team was drowning. Three full-time staff spent most of their week processing supplier invoices by hand — typing numbers from PDFs into the ERP, chasing missing POs, fixing data entry errors downstream. The CFO knew there had to be a better way. He just didn't know what "better" looked like.

Three weeks after kickoff, we delivered an AI document-processing system that cut their invoice processing time by 80% and freed up 40+ hours per week. Here's exactly what we built, why we built it that way, and what we learned.

Manual invoice processing is one of the most common high-value automation targets across industries. The Institute of Finance and Management estimates the average cost to process a single invoice manually ranges from $12 to $30 depending on complexity — a number that compounds quickly at scale.

The situation

The client is a 200-person specialty manufacturer with roughly 2,500 supplier invoices per month, arriving as PDFs by email or supplier portal. The AP team's workflow looked like this:

1. Open each PDF and read the invoice manually
2. Type vendor name, invoice number, line items, totals, and tax into the ERP
3. Match against the corresponding purchase order — if one existed
4. Flag exceptions (missing PO, price mismatch, duplicate) for follow-up
5. Route for approval based on dollar threshold and department

Average time per invoice: 11 minutes. Error rate downstream: about 4%. Three FTEs spent 70% of their week on this single process.

Our approach

We started where we always start: with discovery, not technology. In week one we shadowed the AP team for two days, audited a sample of 200 invoices across the supplier base, and mapped every exception path. That audit produced three insights that shaped the entire build:

• ~85% of invoices follow recognizable patterns. Most suppliers use the same template every month. Once we extract from one, we can extract from all of them.
• The ERP integration was the bottleneck — not the AI. Even with perfect extraction, manually typing into the ERP would still consume hours. The system had to write directly to the ERP via API.
• "Exceptions" weren't really exceptions. 60% of "exceptions" were the same three issues repeating — duplicate invoice numbers, missing POs, and price mismatches. Each could be auto-flagged.

What we built

The system has four components, all running on the client's cloud infrastructure:

We deliberately kept the model layer thin. The AI's only job is structured extraction — it doesn't make business decisions. Every rule about what's "approvable" lives in the validation layer, where it's auditable and easy for the AP team to update without us.

Human-in-the-loop, by design

One non-negotiable from the start: no invoice gets paid without human eyes on it. The system doesn't auto-approve anything. It extracts, validates, and presents — the AP team reviews and clicks. For invoices flagged as exceptions, they review in detail. For "clean" invoices, they review in seconds.

Rollout

We rolled out in three phases:

1. Week 1: Discovery, audit, system architecture
2. Week 2: Build extraction, validation, ERP integration; test on 500 historical invoices
3. Week 3: Limited live rollout to top 50 suppliers, then expansion to full supplier base

By the end of week 3, the system was processing every incoming invoice. The AP team's role shifted from data entry to review and exception handling.

Results after 90 days

• Average time per invoice: 11 minutes → 2.2 minutes (80% reduction)
• Hours saved per week: 40+ across the AP team
• Extraction accuracy: 96% across the supplier base (98%+ for top 50 suppliers)
• Downstream error rate: 4% → 0.6%
• Exception resolution time: 2 days → same-day

What the AP team did with the recovered time was just as interesting as the time savings: they took on supplier relationship management, finally negotiated early-payment discounts, and started catching billing errors that had been going through unnoticed for years. On the communication side, the team adopted Speakeasy for routine supplier outreach, keeping response times fast without adding to anyone's workload. The hours saved became revenue, not just cost cut.

What we learned

Three things from this project we now apply to every document-processing engagement:

• Audit before architecting. Two days of shadowing saved us from building three features nobody actually needed.
• The integration is the project. The AI is rarely the hard part. Connecting it to the system of record always is.
• Make the team faster — don't replace them. The wins compound when humans are reviewing at 10× speed, not removed from the loop.

If you're staring at a similar process — invoices, claims, applications, anything PDF-heavy that's burning team hours — the pattern in this case study is repeatable. Book a free strategy call and we'll talk through what it might look like for your specific situation.