Read once · checked · posted

Stop retyping what a document already says.

Invoices, purchase orders, receipts, delivery notes, application forms. Somebody in your business opens each one, reads the same six fields, and types them into another system. It is dull, it is slow, and it is where a surprising number of errors originate.

Extraction reads the document, pulls out the fields that matter, and hands them to your accounting or operations system in the right shape. The part that makes it usable rather than alarming is what happens next: every field carries a confidence score, and anything the system is not sure about stops for a person instead of quietly entering a wrong number.

Move over the page
fields 0confidence drag to scan
Every fieldScored
UnsureStops for review
OriginalsKept and linked
OutputYour schema

Reality

Why this is harder than "just read the PDF"

Every business assumes their documents are basically standard. Nobody's are. These six problems account for most of the work in any extraction project.

01

No two suppliers agree

Forty vendors, forty layouts. The total sits bottom-right on one, top-left on another, and is labelled "Amount Due", "Balance", "Total Payable" or nothing at all.

Why it matters: template-based tools break the moment a supplier redesigns.

02

Half of them are photographs

A phone picture of a receipt taken at an angle, in bad light, slightly creased. Perfectly readable by a person, considerably harder for software.

Mitigation: de-skew, enhance, and lower confidence rather than guess.

03

Tables are a genuine problem

Line items spanning pages, merged cells, subtotals mid-table, a column that only exists on some invoices. Naive text extraction turns this into unusable soup.

Reality: line-item extraction is roughly twice the work of header fields.

04

Handwriting still exists

Delivery notes, job sheets, signed forms. Accuracy on handwriting is far below print, and it varies wildly between one person's writing and another's.

Approach: extract, but assume a person confirms.

05

The same document arrives twice

Emailed, then posted, then re-sent because nobody replied. Detecting that three files are one invoice is its own problem, and paying twice is expensive.

Needed: deduplication before anything reaches your ledger.

06

Right shape, wrong meaning

A date read as 03/04 could be March or April. A total read correctly but assigned to the wrong currency. The extraction was accurate and the record is still wrong.

Fix: validation rules, not better reading.

Interactive

The extraction viewer

Three documents of decreasing quality, run through the same system. Hover a field to see where it came from on the page, and drag the threshold to change how cautious the system is.

This control is the entire commercial trade-off in one slider. Raise it and errors approach zero while the review pile grows; lower it and almost everything posts automatically, including the occasional mistake. Where you set it depends on what a wrong number costs you — which is a business decision, not a technical one.

auto-posted needs review

The stack

From the inbox to the ledger

Extraction is a pipeline, not a product. Documents arrive somewhere, get read, get checked, and land in the system that actually runs your business — usually one of the accounting platforms below.

Where documents arrive

Email inbox
Google Drive
Dropbox
Box
Amazon S3
MinIO

Reading the page — OCR & vision

PDF parsing
OpenCV de-skew
PyTorch
TensorFlow
Google Document AI
AWS Textract

Understanding & extraction

OpenAI vision
Anthropic Claude
Google Gemini
Hugging Face
Ollama (self-hosted)
LangChain

Structuring & validation

Python
Pydantic schemas
pandas
NumPy
JSON output
scikit-learn

Where the data lands

QuickBooks
Xero
Sage
SAP
Salesforce
HubSpot

Records, search & storage

PostgreSQL
MongoDB
Elasticsearch
Redis
SQLite
Google Sheets

Applications

Six documents worth automating first

Ordered roughly by how quickly they pay for themselves. The first is where most projects start, and usually for good reason.

Document 1 of 6
01 — Payables

Supplier invoices

The classic. Header fields, line items, tax treatment, and a match against the purchase order and the goods received note before anything is approved.

  • Three-way matching where you use POs
  • Duplicate detection before posting
  • Tax handled per line, not assumed

Highest volume, clearest payback

02 — Expenses

Receipts and card statements

Photographed receipts, reconciled against card transactions, categorised and coded — with the original image attached to the entry for the auditor.

  • Handles crooked phone photos
  • Matches to the card feed
  • Flags anything missing a receipt

The one staff notice immediately

03 — Orders

Purchase orders and confirmations

Incoming orders from customers who send PDFs rather than using your portal, turned into sales orders without anyone rekeying part numbers.

  • Maps their codes to yours
  • Checks pricing against the agreement
  • Queries mismatches rather than accepting

Wholesale, distribution, manufacturing

04 — Logistics

Delivery and shipping documents

Packing slips, bills of lading, proof of delivery — frequently handwritten, photographed in a yard, and needed against the invoice later.

  • Reads signed and annotated copies
  • Links to the order automatically
  • Flags short deliveries

Where paper still genuinely rules

05 — Onboarding

Forms and applications

Applications, registrations and intake forms that arrive as scans or PDFs and currently get retyped into a CRM by whoever has the time.

  • Validates against your own records
  • Flags incomplete submissions
  • Keeps the original for the file

Clinics, brokers, professional services

06 — Contracts

Agreements and renewals

Key dates, notice periods, values and parties pulled out of agreements so renewals stop being discovered a month after they auto-renewed.

  • Surfaces dates into a calendar
  • Quotes the clause it read
  • Never a substitute for legal review

Extraction, not interpretation

Honesty

What we will tell you before you commit

Extraction projects fail in predictable ways, and almost all of them are visible at the start if anyone bothers to look.

01

There is no hundred per cent

Any vendor quoting perfect accuracy is quoting it on clean, printed, single-layout documents. On a real mixed pile, the honest target is a high automation rate with a review queue you can live with.

02

Low volume does not pay

Below roughly a few hundred documents a month, the build and supervision cost more than the typing. We will say so.

03

Someone must own the queue

Flagged documents need a person who checks them daily. If nobody owns that, the queue grows until the system is abandoned.

04

The destination is often the blocker

Reading the invoice is the easy half. Getting it into an accounting system with a closed or awkward API is frequently where the real effort sits.

05

Bad process, faster

If approvals are unclear or coding rules live in one person's head, automating the typing just moves the bottleneck. Sometimes the process needs fixing first.

06

Handwriting is a different tier

Print extraction is mature. Handwriting is not. If your documents are mostly handwritten, expect meaningful human review permanently, not temporarily.

07

Retention needs deciding

Where originals are stored, for how long, and who can retrieve them. This is a records question with legal weight, and it belongs in the plan.

08

Accuracy needs measuring

Without a labelled test set of your own documents, nobody can tell you what accuracy you will get — including us. Building one is part of the work.

09

Off-the-shelf may be enough

If you only need standard invoices into a mainstream accounting package, an existing product may do it for a subscription. We would rather point you there than build it.

Scope

What an extraction build includes

The document sample comes first. Everything else is shaped by what is actually in the pile.

01

Document survey

A real sample across your suppliers and formats — including the awkward ones people apologise for. That pile determines the whole design.

02

Field specification

Exactly which fields matter, their types, their formats, and what a valid value looks like. Written down, because "the total" is less obvious than it sounds.

03

Intake

Watching a mailbox, a folder, a scanner or an upload form, with the original preserved and linked to every record produced from it.

04

Classification

Working out what each document is before trying to read it, because an invoice and a statement need entirely different handling.

05

Extraction and scoring

Pulling the fields with a confidence value on each, plus the region of the page each value came from so a reviewer can check it in one glance.

06

Validation rules

Arithmetic that must balance, dates that must be plausible, references that must exist. This catches the errors that confidence scores miss.

07

Review interface

A screen showing the document beside the extracted fields, built for speed — because someone will use it every day.

08

Posting

Into your accounting, ERP or operations system, idempotently, so a retry never creates a duplicate entry.

09

Accuracy tracking

Measured against a labelled set, reported per field, so you can see where corrections cluster and improve that field specifically.

Questions

Document extraction, answered

How accurate is it, really?

On clean printed documents with a consistent field set, high — comfortably enough that most documents post without anyone looking. On photographed, handwritten or unusual layouts it drops, sometimes considerably.

The honest answer for your business needs a sample of your documents and a labelled test set. Anyone quoting a percentage before seeing your pile is quoting somebody else's.

Do we still need someone checking?

Yes, for the flagged minority. The threshold slider above shows the shape of it: a higher bar means a bigger review queue and fewer errors reaching your ledger.

What changes is the volume. Reviewing the uncertain tenth is a different job from typing every document.

Can it handle our specific suppliers' layouts?

That is the point of the modern approach. Rather than a template per supplier, the system reads the document the way a person does — by understanding the labels and structure — so a new supplier usually works without configuration.

Genuinely unusual formats may still need attention, which is why the survey happens first.

Where do the extracted values go?

Into whatever system you already run — accounting, ERP, CRM or a database — through its API. Posting is idempotent, so a retry after a network failure never creates a duplicate entry.

Where a system has no usable API, options are a scheduled file import or direct database writes, decided case by case.

What happens to the original documents?

Stored and linked to every record produced from them, so anyone reviewing an entry later can open the source in one click. That link matters more than the extraction for audit purposes.

Retention period and storage location are decided with you before launch.

Can it read handwriting?

Some. Printed handwriting on a form is often workable; cursive on a creased delivery note frequently is not.

Where handwriting dominates, we design for permanent human confirmation rather than pretending it will improve away.

How long does a first version take?

For one document type into one destination system, usually weeks — with the document survey and the labelled test set taking a meaningful share of that.

Additional document types afterwards are considerably faster, because the pipeline already exists.

Is our data sent to a third party?

Usually some of it, if you use a cloud model or OCR service — configured so the provider excludes it from training. We will tell you exactly what leaves your systems and where it goes.

For sensitive documents, an on-premise or self-hosted model is possible. It costs more and is occasionally the right call.