Case study
Turning accounts-payable matching from a daily grind into a pipeline that runs itself. Built for a Belgian pharmaceutical distributor.
Every invoice has to agree with an order before it can be booked. Almost none of that agreeing should need a person.
The problem
A distributor receives thousands of supplier invoices a month. Every single one has to be checked against a purchase order before it can go into the books. Did we order this? At this price? In this quantity? Was there a delivery surcharge, and does it belong on this line?
Done by hand, that check is slow, and it does not scale. People clear the easy invoices fast and the awkward ones drift to the bottom of the pile. Backlogs build in the corners where nobody is looking. Suppliers with sloppy paperwork quietly become someone’s afternoon.
And the real risk is not the slow invoice. It is the wrong match: an invoice waved through against the wrong order, booking a number that was never agreed. Slow costs you hours. Wrong costs you money, and you find out much later.
Matching is invisible work. It only becomes visible when it fails.
The assignment
Let the system carry the volume. Hand a person only the invoices that genuinely disagree, and hand them the full context, not a mystery to reconstruct. No new screen to learn. No numbers to retype. At the end, one clean handover into the accounting system, ready to book.
The brief was not “software that reads invoices.” Plenty of that exists. The brief was to close the whole loop, from the moment an invoice lands to the moment it is booked, and to keep a human in exactly one place: judgement, not data entry.
The solution
It runs in stages, and each stage does one job well before handing the invoice to the next.
Invoices arrive in every shape: modern structured e-invoices, plain PDFs attached to an email, one supplier’s format versus another’s. They all funnel into a single front door, so the rest of the system never has to care where an invoice came from.
Every invoice is read and turned into clean, structured data: supplier, references, each line, each amount. This is the step that used to be a person squinting at a PDF. Now it happens automatically, the same way every time.
The invoice is linked to the purchase order it belongs to, the anchor for everything that follows.
Each invoice line is compared to what was actually ordered and agreed. Crucially, this does not happen in one pass. One stage proposes the match, a second verifies it, a third reviews it. Confidence is earned before a single number is allowed near the books, which is precisely how the expensive wrong matches get caught before they happen.
Clean matches flow straight through, untouched. Only the genuine disagreements (a price that moved, an unexpected surcharge, a line that does not fit the order) are lifted out and put in front of a person, with the context already assembled. The pile stops being a pile. It becomes a short, named list of decisions worth a human.
Surcharges and adjustments are coded, and the finished, verified invoice is handed to the accounting system in a single structured export. No re-keying, no copy-paste, no second version of the truth.
Every invoice carries its own status at all times: where it is, what has happened to it, what comes next. Nothing lives only inside a running process. If a step stumbles, work is never lost; it simply resumes from where the invoice actually is.
Because each step only reads and writes status, any one stage can be improved, replaced or sped up without touching the others. The system evolves in place instead of being rebuilt.
Machines are relentless and consistent, which is what matching demands. People are good at the odd, ambiguous, “that’s not right” call, so that is the only place they are asked to stand.
A side effect
Because it reads every invoice the same way, the pipeline can see exactly which suppliers keep sending incomplete or malformed paperwork: the missing references, the wrong fields, the habits that generate the exceptions.
A back-office chore quietly becomes a lever. Instead of absorbing bad invoices forever, you can go back to the handful of suppliers causing them and fix the source.
The results
Thousands of invoices per cycle move through a single pipeline instead of inboxes and spreadsheets. The default is now automatic; manual is the exception, not the rule.
The overwhelming majority match and book without anyone touching them. People spend their time on the invoices that actually need a decision, and nothing else.
The propose-verify-review sequence stops bad numbers reaching the books, the failure that used to surface weeks later as a correction.
The biggest source of stuck invoices, roughly eight hundred sitting on suppliers the system did not yet recognise, was isolated into one clearable queue instead of noise scattered across the pile.
At any moment you can say where a given invoice is and why. The state of the work is no longer folklore held in someone’s head.
The pipeline prunes what is finished so it stays fast and stays within its limits as volume grows. It does not quietly seize up at scale.
The same engine that clears invoices now tells you which suppliers to coach, so the exceptions shrink at the source over time.
The invoices will keep arriving. That was never the problem. The problem was that agreeing with them was a person’s whole day. Now it is a system’s, with a person kept for the one part that is actually a judgement call.
