A surprising amount of office work is a person reading a PDF and typing its contents into a system. Invoices into accounting. Forms into a CRM. Delivery notes into inventory. Applications into a database.

It is mechanical, it is slow, it is error-prone, and it is one of the clearest automation opportunities in most businesses.

How it works now

The older approach was template-based OCR: define where on the page each field sits, read the text at those coordinates. It worked until a supplier redesigned their invoice, at which point it silently started reading the wrong box.

Modern document AI works differently. The model reads the whole document and understands it semantically — identifying which number is the total because of what surrounds it, not because of where it sits. That means it handles layouts it has never seen, which removes the brittleness that made the old approach exhausting to maintain.

The practical consequence: you can process invoices from two hundred different suppliers without configuring two hundred templates.

A typical pipeline

Five stages. Only the second is AI.

1. Ingest. Documents arrive — email attachments, a watched folder, an upload form, a scanner. Normalise format and queue them.

2. Extract. The model reads the document and returns structured data against a schema you define: supplier, invoice number, date, line items, net, tax, total.

3. Validate. The stage that decides whether the system is useful or dangerous. Check the extracted data against reality:

  • Do the line items sum to the stated total?
  • Does the tax calculation work out?
  • Does the supplier exist in your records?
  • Does the invoice number already exist, indicating a duplicate?
  • Is the amount within a plausible range for this supplier?

4. Route by confidence. High confidence and passing validation goes straight through. Anything failing a check, or where extraction was uncertain, goes to a human review queue with the document and the proposed values side by side.

5. Write. Validated data goes into accounting, the CRM, or wherever it belongs, with the original document attached.

Validation is the whole game

It is worth labouring this point, because it is where projects go wrong.

Extraction accuracy is what vendors advertise. Validation is what makes the output safe. An extracted total that is never cross-checked is worse than no automation, because a person retyping would probably have noticed the figure looked wrong, whereas a pipeline will post it without hesitation.

Every extracted field that can be checked against something else should be. Arithmetic that must balance, references that must exist, values that must fall in a range, dates that must be plausible. These checks are cheap to write and they catch the large majority of errors.

Design for uncertainty

The most important design decision: never let the system guess silently.

Three outcomes per document, not two:

  • Auto-processed — high confidence, all validations passed
  • Queued for review — something was uncertain or a check failed
  • Rejected — not a document type the system handles

A review queue that shows the document alongside the extracted values, with the uncertain fields highlighted, lets a person resolve an item in seconds. That is a genuinely good outcome — far better than either a silent error or a human processing everything from scratch.

The metric that matters

Straight-through processing rate: the percentage of documents requiring no human touch at all.

Not accuracy. Accuracy can be high while the straight-through rate is low, if everything gets queued. And a high straight-through rate with weak validation is a disaster waiting to be discovered at year end.

Track both together: straight-through rate, and the error rate found in the documents that did go straight through. Sample the auto-processed ones periodically to confirm the second number is real.

Where it works best

Supplier invoices. The classic case. High volume, defined fields, validatable against purchase orders and arithmetic.

Application and intake forms. Structured by design, often arriving as scans or PDFs.

Delivery notes and receipts. Repetitive, checkable against orders.

Contracts, for specific clauses. Not full understanding, but reliably extracting renewal dates, notice periods and values across a folder of agreements.

Identity and compliance documents. Extracting fields for verification, with human review retained.

Where it struggles

Be realistic before committing:

  • Poor scans. Skewed, low resolution, shadowed phone photos. Quality in, quality out.
  • Free-form handwriting. Printed characters in boxes are workable; cursive is not reliable.
  • Documents needing judgement. Deciding whether a contract clause is acceptable is not extraction.
  • Highly variable one-off documents. If every document is different and there are twelve a month, the build will not pay back.
  • Multi-page documents with cross-references. Harder, doable, more expensive.

Test with your worst inputs, not your cleanest. The demo always uses a pristine PDF; your Tuesday post does not.

A sensible build sequence

  1. Collect a hundred real documents, including the awkward ones, with the correct extracted values recorded. This is your evaluation set.
  2. Define the schema — exactly which fields, with types and formats.
  3. Write the validation rules before building extraction. They will shape the schema.
  4. Build extraction, score it against the evaluation set, iterate.
  5. Build the review queue with the document and values side by side.
  6. Run in parallel with the manual process for a fortnight and compare.
  7. Cut over, monitoring the straight-through rate and sampling auto-processed documents.

The evaluation set in step one is the step that gets skipped and the one that makes everything afterwards measurable.

If you have a document type eating hours each week and want to know whether it is a good candidate, send us a sample set — including the messy ones.