Knowledge · Technology
Accounts payable intelligence,
the invoice that codes itself.
Accounts payable is the single largest admin drain in most building businesses, and the most mature place AI genuinely helps. This reference explains how a supplier invoice is read, matched to its order and coded to the job, which parts are exact and which are model-assisted, and why a person still approves every bill.
01 / Overview
What accounts payable intelligence is
Accounts payable intelligence is software that turns a supplier invoice from a PDF to be keyed into a coded, matched cost waiting for approval. Forwarded to an accounts inbox, the invoice is read into structured fields, matched to its purchase order, and coded to the job, so what a person receives is a decision to make rather than a form to fill. It is the workflow where most builders first meet AI, because invoices are frequent, roughly consistent and expensive to process by hand, and it sits inside the wider reading capability covered in the document intelligence reference.
The reason it deserves its own reference is that it touches the money, so how it is engineered matters more than how it demos. The trustworthy version is a deliberate blend, a model where language is the problem, exact scoring where the money goes, and a person on every commitment. This page sets out that blend, the workflow, and the design choices that make it safe to run, because a builder handing invoices to software should understand exactly which parts are calculated and which are interpreted.
02 / Process workflow
How an invoice moves from inbox to approved
Five steps. The reading is model-assisted, the matching and money are exact, and the last step keeps a person in control.
- 01
The invoice is captured and read
A supplier invoice is forwarded to an accounts inbox. A model reads it into structured fields, the supplier, invoice number, dates, purchase order reference, line items and totals, with each value citing where on the page it came from.
- 02
It is matched to a purchase order
A deterministic score compares the invoice to open orders across purchase order number, amount tolerance, remaining balance, recency, date proximity, line similarity and supplier alias. The strongest match is proposed, with the reasoning visible.
- 03
Each line is coded to the job
Cost coding draws on the builder’s own learned vocabulary first, at no model cost, and calls the model only for lines it has not seen before. The invoice arrives coded against the job it belongs to.
- 04
High-stakes items are forced to review
A high-value invoice or a low-confidence read is routed to a person automatically, by design. The cost of being wrong, not the system’s confidence alone, decides how much human attention an invoice gets.
- 05
A person approves, and corrections stick
The reviewer sees the match and coding with mismatched lines flagged, approves what is right, and corrects what is not. Nothing posts on its own, and each correction becomes something the system knows for next time.
03 / Key mechanics
Three engines, one invoice
Knowing which part of the workflow is exact and which is model-assisted tells a builder exactly how much to trust each output.
Reading is model-assisted
Turning a varied, scanned or photographed invoice into clean fields is genuine language and layout work, where a model earns its place. Its output is a proposal carrying its sources, never a silent record.
Matching is deterministic
Where the invoice belongs is decided by an exact score across defined signals, not a model guess. The same invoice matches the same way every time, and the logic can be audited line by line.
Coding is learned first, model last
The builder’s own vocabulary codes the lines it has seen, for free and exactly. Only genuinely new lines reach the model, which keeps cost down and accuracy compounding on your own documents.
The blend is the point. Sending an entire invoice to a model and trusting the result is how plausible errors reach the books. Reading with a model but deciding the match with exact scoring, and coding from learned vocabulary first, keeps the probabilistic work confined to language and the money work deterministic and auditable. The exact financial picture these approved invoices feed into is its own capability, covered in the financial intelligence reference, and the control rule that nothing commits without a person is set out in the AI guardrails reference.
04 / Best practice
Running AP intelligence well
An operator observation that captures the real value. The point is not that the software types faster, it is where the reviewer's minutes go. A frame-stage timber invoice keyed by hand is ten minutes of night-time typing with no flag on the beam rate that crept above the quote, because nobody compared the line to the order. Processed this way, the two lines that disagree with the order are flagged, the reviewer spends two minutes on exactly those, and the price rise gets a decision instead of being quietly absorbed. The saved time is real, but the caught money is often worth more.
The habit that makes it work is treating the review queue as a working surface, not a rubber stamp. Correct wrong suggestions rather than waving them through, because the corrections are what teach the system your suppliers and your codes, and they are what make next month faster. And evaluate any product on your own worst invoices, the crumpled docket and the seventeen-line supplier bill, not the clean sample set. The discipline of matching invoices to what was ordered and received is covered in the receiving and invoice matching reference, and the worked end-to-end example is on AI invoice processing.
05 / FAQ
Common questions.
Software that reads a supplier invoice, matches it to its purchase order, codes each line to the job and presents it for approval, so the keying, the order-hunting and the manual coding largely disappear. The important detail is that it is a blend of engines rather than one model. Reading the invoice is model-assisted, because invoices are varied and often scanned. Matching to the order is a deterministic score. Cost coding uses the builder’s learned vocabulary first and the model only for unseen lines. And a person approves everything, with high-value or low-confidence invoices forced to review. That mix is what makes it safe to run on money.
By deterministic scoring across several signals at once, not by a model deciding. The match considers the purchase order number, whether the amount is within tolerance, the remaining balance on the order, how recent it is, date proximity, similarity between the invoice lines and the order lines, and known supplier aliases. Because it is exact scoring, the same invoice matches the same order the same way every time, the reasoning is auditable, and the decision about where your money is committed is never left to a probabilistic model. When the signals do not agree cleanly, the discrepancy is flagged for a person rather than forced.
No. Accounts payable intelligence prepares the work and stops at the decision. It reads, matches and codes, then waits for a person to approve, with high-value or low-confidence invoices forced to human review by design. The reason is accountability, the responsibility for a paid bill stays with the business regardless of what prepared it, so the business should commit it. This is a specific case of the general control rule for AI in a building business, set out in the AI guardrails reference, nothing touching money commits without a human.
Through the corrections. When a reviewer recodes a line or fixes a supplier alias, a well-built system remembers it, so the same supplier’s invoice arrives already coded next month rather than needing the same fix again. This is the difference between a reading system and a transcription treadmill, errors are paid for once. It also means accuracy is highest on your own recurring documents, which are most of the volume, and that the value of the system compounds the longer it runs on your business. The learned vocabulary is the durable asset, not the model behind it.
Because it concentrates frequent documents, expensive errors and a real time drain in one contained workflow. Invoices arrive constantly, so saved minutes add up fast. Keying them by hand introduces transposed totals and invoices paid against the wrong order, and it means price rises get absorbed because nobody compared the line to the quote. Reading, matching and coding remove the transcription and surface exactly those mismatches. The payback is immediate and the checking habit it builds, glance at the source, confirm, tap, carries over to every other AI capability. The wider payables process is covered in the accounts payable guide.
06 / Terms
Glossary for this topic
Accounts payable (the process of approving and paying supplier invoices), purchase order match (linking an invoice to the order it bills against), amount tolerance (an allowed difference between invoiced and ordered value), cost coding (assigning each line to a job and cost code), learned vocabulary (the supplier and coding knowledge the system builds from corrections), forced review (high-value or low-confidence invoices routed to a person automatically), provenance (a value citing its place on the source document). The wider vocabulary lives in the construction glossary. From here the natural next article is financial intelligence, the live money picture these approved invoices feed.
07 / Keep reading
Related knowledge, guides and features
The invoice that codes itself to the job.
VIABUILD gives you a dedicated accounts inbox where Oryn reads what lands there, matches it to your purchase orders by exact scoring and queues it coded for your approval. High-value invoices always get a human look, by design.