Ammar Saleem
Many organisations still have people retyping data from PDFs, scans, and phone photos into other systems. Intelligent document processing (IDP) automates that work. It classifies each document, extracts the fields you need, checks them against your rules, and sends only the uncertain ones to a person.
What intelligent document processing is
Optical character recognition (OCR) turns an image of text into text. That alone does not help much: you get a wall of characters with no idea which number is the invoice total and which is a phone number. Intelligent document processing adds the understanding on top. It recognises what kind of document it is looking at, finds specific fields and tables, and returns structured data with a confidence score for each value.
Older systems relied on templates: draw a box where the total sits on each supplier's invoice. That breaks as soon as a supplier changes their layout. Modern IDP uses models that understand layout and language together, so they find the total because of what it says and where it sits relative to other fields, not because of fixed coordinates. Large language models have pushed this further, handling unusual documents with little or no task-specific training.
How the pipeline works, step by step
A dependable IDP system is a pipeline, not a single model call. Each stage has a job, and most of the reliability comes from the stages around the AI.
- Ingest: documents arrive by email, upload, scanner, or API.
- Pre-process: straighten skewed scans, remove noise, and split multi-document bundles into individual files.
- Classify: decide what each document is, such as an invoice, purchase order, ID card, or contract.
- Extract: pull the required fields and tables, each with a confidence score.
- Validate: cross-check the values. Do line items sum to the total? Does the purchase order exist in the ERP? Is the tax number in a valid format? Is the date plausible?
- Review: show low-confidence or failed fields to a person, next to the part of the image they came from.
- Export: post clean data to the ERP, CRM, or database through its API, with an audit trail of what was automated and what was corrected.
- Learn: feed corrections back as new evaluation data, so you can measure whether changes improve accuracy.
Which documents it handles well
Some document types are excellent candidates for automation. Others still need a lot of human help. Knowing which is which keeps expectations realistic.
| Document type | How well it automates | Watch out for |
|---|---|---|
| Supplier invoices | Very well: high volume, consistent fields | Line-item tables across many vendor layouts |
| Purchase orders and receipts | Well | Crumpled or low-light photos of receipts |
| Identity documents | Well for printed fields and the machine-readable zone | Glare and cropping; fraud detection is a separate problem |
| Application and claim forms | Well when typed or printed | Handwriting and ticked boxes |
| Contracts | Well for finding parties, dates, and clauses | Interpreting obligations still needs a lawyer |
| Handwritten notes | Variable | Expect substantial human review |
What accuracy to expect
Vendors quote impressive accuracy figures, but a single number hides what matters. Accuracy varies by field: a printed invoice number is far easier than a handwritten signature date. It varies by document quality: a clean PDF generated by software is easier than a phone photo taken at an angle. And it varies by how many different layouts you receive.
The metric that matters most is the accuracy of the fields the system accepts without review. You can always make automation safer by sending more to people, at the cost of a lower straight-through rate. Good systems make that trade-off per field: a bank account number gets a strict threshold, a free-text description a looser one.
The only trustworthy number is one measured on your own documents. Collect a few hundred real examples with the correct values recorded, run them through the system, and look at the errors field by field before deciding anything.
Designing human review that people trust
Human review is where IDP projects succeed or quietly fail. If reviewers have to hunt through a PDF to check a value, they will either slow down or start approving without looking.
- Show each field beside the exact region of the document it came from.
- Ask people to check only the uncertain fields, not the whole document.
- Make review fast with the keyboard: confirm, correct, next.
- Log every correction, so you know which fields and suppliers cause the most trouble.
- Spot-check a sample of auto-accepted documents too, so you catch confident mistakes.
Build, buy, or both
Cloud services such as Azure AI Document Intelligence, Google Document AI, and Amazon Textract provide strong extraction out of the box, including prebuilt models for invoices, receipts, and IDs. Dedicated IDP platforms wrap extraction in review screens and workflow.
In our experience, the extraction model is rarely what makes or breaks a project. The value is in the parts around it: the validation rules specific to your business, the integration with your ERP or case system, and a review loop your team actually uses. A common, effective setup is a cloud extraction service combined with custom validation, review, and integration. Fully custom models make sense when documents are unusual, volumes are very high, or data cannot leave your own infrastructure.
Data security and compliance
Documents often contain personal and financial data. Decide early where documents are stored and for how long, which region processing happens in, who can see which document types, and whether sensitive fields such as ID numbers should be masked in review screens. Confirm that any AI provider you use does not train on your data, and keep an audit log of every automated and manual change.
How to start
- Pick one document type with high volume and clear fields. Supplier invoices are the classic first choice.
- Collect a few hundred real samples and record the correct values for each field.
- Define the fields you need and the validation rules a person would apply.
- Run a pilot in shadow mode alongside the manual process and compare results field by field.
- Go live with a review queue and conservative thresholds, then loosen them as the data proves it is safe.
- Add the next document type once the first one runs smoothly.
Treat document automation as a pipeline with a person in it, not a model that is simply right or wrong. Validation rules and a good review screen are what make extracted data safe to use.
Frequently asked questions
OCR converts an image of text into machine-readable text. Intelligent document processing goes further: it classifies the document, extracts specific fields and tables, validates them against business rules, and routes uncertain values to human review.
It depends on scan quality and how many supplier layouts you receive, so it should be measured per field on your own invoices. Well-designed systems combine model confidence with validation rules, such as checking that line items sum to the total, so accepted fields are reliable and doubtful ones go to review.
Partly. Modern models read neat handwriting reasonably well, but accuracy drops with messy writing and poor scans, so handwritten fields usually need more human review than printed ones.
It changes the job. People move from typing every field to reviewing the few values the system is unsure about and handling exceptions, which is usually a far better use of their time.
Working on something like this?
See how our AI & Automation practice works, or talk to us directly. No pitch.
