Meet Muoro's Leadership at Event: Databricks Data + AI World Tour, Atlanta•Date: November 10, 2026•Venue: Atlanta Marriott Marquis, Atlanta|Meet Muoro's Leadership at Event: Databricks Data + AI World Tour, New York City•Date: November 19, 2026•Venue: Javits Center, New York |
Meet Muoro's Leadership at Event: Databricks Data + AI World Tour, Atlanta•Date: November 10, 2026•Venue: Atlanta Marriott Marquis, Atlanta|Meet Muoro's Leadership at Event: Databricks Data + AI World Tour, New York City•Date: November 19, 2026•Venue: Javits Center, New York |
Meet Muoro's Leadership at Event: Databricks Data + AI World Tour, Atlanta•Date: November 10, 2026•Venue: Atlanta Marriott Marquis, Atlanta|Meet Muoro's Leadership at Event: Databricks Data + AI World Tour, New York City•Date: November 19, 2026•Venue: Javits Center, New York |
Muoro logo
Muoro

Intelligent Document Processing Use Cases: Three Case Studies from Financial Services

How lenders, insurers, and wealth firms detect fake bank statements, pay stubs, and AI-generated documents, and why one-document checks fall short.

Table of Contents
Quick Summary

This post walks through three intelligent document processing (IDP) projects Muoro worked on: corporate KYC onboarding, small business lending, and compliance search across policy and contract libraries. For each one, it covers where the client started, what was built, what went wrong, and what other firms can learn from it.

  • KYC onboarding (design stage): An event-triggered pipeline cleans scanned filings, extracts entity data with an LLM, validates it, checks the FATCA registry, and sends unreadable files to manual review.
  • Small business lending: A multi-agent pipeline turns bank statements into structured data, reconciles them with marketplace sales, and proposes a credit line for an underwriter to approve.
  • Compliance search: A retrieval-augmented generation (RAG) platform answers questions from internal documents, filters results by access rights, checks each claim, and cites its sources.
  • Documents cause more trouble than models: In all three projects, much of the engineering effort went into cleaning poor scans, varied layouts, and embedded tables.
  • Put the checks outside the model: Schema validation, registry checks, cross-document reconciliation, and grounding checks catch errors even when the model gets something wrong.
  • Build a clear route to a person: Review queues, underwriter sign-off, and flagged answers keep people responsible for final decisions and anything the system can't verify.
  • Make every figure traceable: Page references, execution traces, versioned rules, and citations let compliance teams, auditors, and examiners check every output.
  • Start with one workflow: Pick a high-volume process, test on your messiest real documents, measure accuracy and catch rate, then scale once the numbers hold up.

Most writing about intelligent document processing (IDP) lists use cases and describes what the technology can do. This post is about what happened when it met real financial documents: scanned corporate filings, bank statements from dozens of institutions, and policy manuals spread across shared drives.

We walk through three intelligent document processing use cases from Muoro projects in detail. For each one, we cover where the client started, what we built, what went wrong along the way, and what we would do differently next time. We have left out client names. Each project also has a shorter write-up in our case study library. For the wider picture of how IDP works in financial services, see our guide to intelligent document processing solutions for financial services.

KPI

What it shows

Target direction

Straight-through processing rate
Share of documents processed with no human touch
Rising, without a fall in catch rate
Exception rate
Share of documents sent to a reviewer
Falling over time
Cycle time
Time from document arrival to verified data
Falling
Cost per document
Total cost, including review time and rework
Falling
Rework rate
Share of files sent back to customers or brokers for documents or corrections
Falling
Confirmed fraud flags
Flags that turn out to be genuine fraud, and the false-positive rate
More true flags, fewer false ones
Comparison of three intelligent document processing use cases: KYC onboarding, small business lending, and compliance search

Case study 1: designing automated KYC onboarding for a global financial group

Where the client started

Onboarding a new corporate client meant a chain of manual compliance lookups. Analysts read formation documents and corporate profiles, re-keyed entity names, registration numbers, and operating details into the onboarding system, and checked tax status by hand. Each step relied on someone reading an unstructured document correctly, and errors could creep in at each handoff.

Slow onboarding has a direct cost. In Fenergo's 2025 survey of 600 senior decision-makers in the US, UK, and Singapore, 70% said their firm had lost clients in the past year because onboarding was too slow.

The same Fenergo survey found that US firms spend an average of $72.2 million a year on AML and KYC operations, yet only about a third of periodic KYC reviews are automated on average.

The goal was to replace the manual lookups with document processing automation that starts the moment a new legal entity enters onboarding, without lowering the quality of the data compliance teams rely on.

What we designed

This engagement covered the architecture and design of the pipeline. We designed four main parts.

  1. An event trigger: A listener picks up each new entity name from the onboarding portal and starts profiling in the background, so no one has to kick it off by hand. Listener scripts also track later changes to corporate data.
  2. An LLM extraction layer: Large language models read the unstructured onboarding documents and pull out entity details, registration numbers, and operating information.
  3. A validation layer: Schema rules sit on top of the model's output to structure, clean, and format it into a compliant dataset, so nothing passes downstream just because the model produced it.
  4. A FATCA check: A tax validation step cross-references the extracted entity details against the official FATCA registry.

The pipeline was designed to plug into the client's counterparty data platform and client lifecycle management system, so verified data lands where onboarding teams already work.

Problems we designed around

Messy documents broke extraction: Early design testing hit a parsing blocker. Messy layouts, multi-column corporate profiles, and poor scans caused extraction errors before the text even reached the model. We added automated image pre-processing and document cleanup to the pipeline, so files are straightened and cleaned before they reach the language model.

The tax registry could not keep up with batch volumes: Calling an external registry for every entity during busy onboarding periods risked throttling and timeouts. We designed an asynchronous queue with back-off retry logic, so verification requests wait their turn instead of failing.

Some files will never parse cleanly: Rather than letting the system guess, we designed fallback paths that send unparsed edge-case paperwork to a manual review queue, with the reason attached.

What it means for your firm

If you onboard corporate or institutional clients, start by testing extraction on your worst documents: old scans, multi-column profiles, and files from unfamiliar jurisdictions. Plan for external registries to be slow, and treat the route to a human reviewer as part of the design from day one. Section 6 of our IDP guide covers where extraction breaks and how to plan for it. The full KYC onboarding case study is on our website.

Design of an automated KYC onboarding pipeline: event trigger, image cleanup, LLM extraction, schema validation, and FATCA registry check, with unparsed files sent to manual review

Case study 2: reconciling bank statements with sales data for small business underwriting

Where the client started

The client is a lender that funds small e-commerce businesses. Underwriting each application meant pulling together two kinds of evidence by hand: sales data from marketplaces such as Amazon, Shopify, Walmart, and TikTok Shop, and the seller's bank statements. Analysts read both, compared them, and decided on a credit line.

The process was slow, and results varied from one analyst to the next. It could also miss the biggest risk in this kind of lending: a gap between the sales a seller reports and the cash that reaches their bank account. Honest errors and deliberate manipulation both show up there, and fraud costs lenders far more than the amount lost.

LexisNexis Risk Solutions puts the true cost of every $1 of fraud at $4.84 for US lenders once fees, recovery, and operations are counted.

Bank statements are the document lenders worry about most. In Inscribe's 2026 survey of 90 fraud and risk leaders, 85.6% named bank statements the document type most vulnerable to manipulation, and 91.2% of the altered documents Inscribe flagged in 2025 had edited financial figures. Ocrolus, which analyzes small business lending applications, reports that unreconciled bank statement balances, where the transactions don't add up to the balance shown, roughly doubled year over year to nearly 20,000 incidents a month in early 2026. Both figures come from the vendors' own data, but they suggest a quick read of a statement isn't enough. It has to be checked against the rest of the file.

What we built

We built a multi-agent underwriting pipeline for automated document processing, in which each AI agent does one job.

A bank statement agent reads statement PDFs from small and large banks across the US, Europe, and Singapore, and turns them into structured, editable data.

Analysis agents work through the sales data from each marketplace and pair it with the bank data, producing a focused report for each marketplace and each bank account.

A master underwriting report brings everything together, with a forensic analysis of the seller's cash flow and a proposed credit line for the underwriter to review.

A model that sorts each bank transaction into business, personal, marketplace, loan repayment, or internal transfer is in development. It will make the match between bank activity and marketplace sales more precise.

Key design choices

  1. Verified output only: Guardrails stop an agent's report from including anything that hasn't passed validation, so the underwriter never sees a figure the system couldn't check.
  2. Separate workspaces: Agents run in separate workspaces per seller, so one applicant's data can't leak into another's analysis.
  3. Versioned prompts and rules: Skills, templates, and guardrails can be edited from a console and are versioned for each seller, so the team can see exactly which rules produced a given report.
  4. Execution traces: Full execution traces, token and cost tracking, an offline test mode, and an automated test suite make the pipeline auditable and cheap to change.

What it means for your firm

If you lend against bank statements, most of the value of IDP comes from checking each statement against everything else in the file. Build the reconciliation step first, keep the underwriter as the decision-maker, and make sure every figure in a report can be traced to its source.

Multi-agent underwriting pipeline: a bank statement agent and analysis agents feed a verified-output guardrail and a master report that an underwriter reviews

Case study 3: compliance search with cited answers from policy and contract libraries

Where the client started

The client's policy manuals, technical specifications, compliance guidelines, and contracts sat across several repositories as PDFs, Word files, and text documents. Many had irregular headers, embedded tables, and multi-column layouts. Teams that needed a specific answer, such as what a policy allows or what a contract says about renewal, had to search by keyword and read.

Keyword search missed meaning: a search for one phrase wouldn't find a document that used a different term for the same thing. A general-purpose chatbot wasn't an option either, because it had no access to internal documents and would risk inventing answers. For a regulated firm, a confident wrong answer about a policy can do more harm than no answer at all.

Adding retrieval helps, but it doesn't remove the risk. When Stanford researchers tested legal research tools built on retrieval-augmented generation in 2024, two of them produced incorrect information more than 17% of the time, and another did so more than 34% of the time. The tools did better than general-purpose chatbots, but they were not hallucination-free.

This project wasn't specific to financial services, but the problem is the same one compliance, operations, and underwriting teams face with their own policy and procedure libraries.

What we built

We built a retrieval-augmented generation (RAG) platform that answers questions from the client's own documents, with a citation for every answer.

  1. Parsing that keeps structure: Ingestion scripts extract text from PDFs and Word files while keeping the file name, section headers, page numbers, and access tags.
  2. Chunking with overlap: Documents are split into passages with a 10% to 15% overlap, so sentences and context aren't cut in half at chunk boundaries.
  3. Semantic search with filters: Passages are stored as vector embeddings with their metadata. A question is matched by meaning, and results are filtered by the user's access rights before anything reaches the model.
  4. Grounded answers: The model is instructed to answer only from the retrieved passages. An output check then compares each claim with the retrieved text, flags anything unsupported, and adds clickable source citations.
  5. Model routing: The platform can switch between several large language models depending on the task, cost, or speed needed.

What we fixed along the way

Weak retrieval: The team analyzed weak results, then refined chunk sizes and overlap and adjusted prompts based on user feedback. Retrieval quality is now measured against a benchmark set of sample questions, checking whether the retrieved passages actually contain the answer.

Too many passages: Sending the top 20 passages to the model added depth but raised cost and slowed responses. Tuning retrieval to send the 4 to 6 most relevant passages kept answers accurate and fast.

Unreadable files: Corrupted or unreadable files go to an error bucket and trigger an alert, while the rest of the batch completes.

What it means for your firm

In our experience, weak RAG answers usually trace back to parsing or retrieval rather than the model. Before you judge the model, check whether the right passage was retrieved, and whether the tables and page structure survived parsing. A compliance team will only use the answers if they come with citations and respect access rights. Our guide explains where LLMs and RAG go wrong on financial documents, and why benchmarks such as FinanceBench show how often retrieval misses.

Retrieval-augmented generation pipeline that parses and chunks documents, filters results by access rights, and checks each answer against its sources before adding citations

Four intelligent document processing best practices from these projects

The three projects used different documents and different models, but four lessons came up in all of them.

  1. The documents caused more trouble than the model: Poor scans and multi-column profiles held up the KYC pipeline. Statements from banks in three regions shaped the lending pipeline. Irregular headers and embedded tables shaped the Q&A platform. In each case, much of the engineering effort went into cleaning and parsing the documents before any model saw them. That matches what firms report more widely: in Cambridge's 2026 survey of 628 organizations, including financial firms, fintechs, AI vendors, and regulators, data availability and quality was the top barrier to AI adoption.
  2. Put the checks outside the model: Schema validation and registry checks in the KYC pipeline, verified-output guardrails in the lending pipeline, and grounding checks in the Q&A platform all sit outside the model, so they still catch errors when the model gets something wrong. Our post on testing and validating generative AI outputs [Internal link: AI governance supporting post, Fri 6 Nov] covers how to set these checks up.
  3. Every system needs a clear route to a person: Unparsed KYC files go to a review queue, underwriters make the lending decision, and unsupported answers are flagged rather than shown as fact. Designing that route early is cheaper than adding it after a failure. Our post on human-in-the-loop AI covers which decisions need human approval. Mortgage lenders are doing the same. In a 2026 survey of 31 mortgage lenders and servicers by the MBA, BCG, and AARMR, 81% used human review as a control on their AI.
  4. Make every figure traceable: Source page references, per-seller version histories, execution traces, and citations mean every figure and answer can be checked. Without that, a compliance team, an auditor, or an examiner has no way to rely on the system.

These are the same principles behind the controls in section 10 of our IDP guide, and the governance practices in our guide to AI governance in financial services.

How lenders, insurers, and wealth firms can apply these IDP use cases

You don't need the same documents as these clients to use the same approach. Here is where we'd start for each kind of firm.

Firm type

Where to start

What to check first

Lenders
Bank statements, pay stubs, and tax returns in the loan file
Whether figures reconcile across documents, and whether statements and pay stubs are genuine
Insurers
Commercial submissions: ACORD forms, loss runs, and broker emails
Whether loss runs in each carrier's format extract cleanly, including multi-page tables
Wealth and asset managers
Account opening and transfer forms
Whether incomplete or inconsistent forms are caught before they go to the custodian
KYC and onboarding teams
Formation documents, ownership records, and tax forms
Whether extraction holds up on old scans and unfamiliar layouts, and how registry checks handle volume
Compliance and operations teams
Policy manuals, procedures, and contracts
Whether answers cite their source, and whether access rights are enforced in search

None of our three projects were for an insurer, but the same lessons apply to intelligent document processing in insurance. At submission intake, the hard part is loss runs that arrive in a different format from every carrier.

Whichever you choose, the steps are the same: pick one high-volume workflow, build a test set from your messiest real documents, measure accuracy and catch rate before you scale, and keep a person on low-confidence fields until the numbers justify stepping back.

Frequently asked questions about IDP use cases

What are the main intelligent document processing use cases in financial services?

The most common are client onboarding and KYC, loan underwriting, insurance submission and claims intake, wealth account opening, and search across policy and contract libraries. Each one runs as a pipeline that cleans documents, extracts the data each process needs, checks it against rules, other documents, and outside sources, and sends anything doubtful to a person. The three projects above cover corporate onboarding, small business lending, and policy search.

What is the difference between IDP and OCR?

OCR turns an image of text into machine-readable characters. It doesn't know which number is the closing balance or which name belongs to the beneficial owner. IDP adds the steps around it: classifying the document, extracting the specific fields a process needs, checking them against rules and other documents, and routing anything uncertain to a person. In all three projects above, reading the text was only the first step.

Which document workflow should we automate first?

Pick one with high volume, a clear definition of a correct answer, and a known cost when something goes wrong. Loan file intake, KYC onboarding, insurance submission intake, and wealth account opening are common starting points. Avoid starting with your rarest or most varied documents, and test on your messiest real files before you commit.

Can IDP handle bank statements from many different banks?

Yes. Modern IDP doesn't rely on a template for each bank, so it can read statement layouts it hasn't seen before. Accuracy still varies by issuer, so test on statements from the banks your applicants actually use and monitor accuracy by issuer once live.

Can IDP read poor scans and handwritten documents?

Often, but accuracy drops. Image cleanup such as straightening, de-noising, and contrast correction helps, as the KYC project showed, but some files will never parse cleanly. Send those to a manual review queue and track how many you get, rather than tuning the system forever for the last few percent.

How do you stop an LLM from inventing figures or answers?

You can't rely on instructions to the model alone. Use checks that run outside it: schema validation, arithmetic and cross-document reconciliation, grounding checks that compare each answer with its source text, and citations that let a person verify the result.

What accuracy is good enough for production?

Judge accuracy per document, not just per field. If a document has 25 fields and each one is extracted correctly 97% of the time, only about 47% of documents will come through with every field right. That's why the share of documents that go straight through, and how reliably the system flags its own mistakes, matter more than a headline accuracy figure.

Does IDP replace KYC analysts or underwriters?

No. It takes over most re-keying and first-pass checking, so analysts and underwriters spend their time on exceptions and decisions. In all three projects, a person stays responsible for the final decision or reviews anything the system can't verify.

What should we measure in an IDP pilot?

Measure field-level and document-level accuracy on your own documents, the share of documents that go straight through without review, catch rate (how many wrong values the system flags), and time per document before and after.

Is it safe to send customer documents to a large language model?

It can be, with the right setup. Customer documents hold personal and financial data covered by the Gramm-Leach-Bliley Act. For non-bank firms under the FTC's Safeguards Rule, that includes encrypting customer information in transit and at rest, using multi-factor authentication, and overseeing service providers, which covers AI vendors. We also recommend running models in your own cloud environment or under an enterprise agreement that rules out training on your data, limiting access by role, and logging every request.

What do regulators expect when AI reads documents in a regulated process?

Expect to show how the system works, how you tested it, and who reviews its output. For insurers, 29 jurisdictions had adopted the NAIC's model bulletin on insurers' use of AI as of November 2026. It asks insurers to keep a written AI program covering governance, risk management, and oversight of third-party AI systems. Lenders and wealth firms face similar questions in model risk and fair lending reviews. Our guide to AI governance in financial services covers what examiners ask for.

Should we build an IDP system or buy a platform?

Buy when your documents are common types a platform already handles well, such as standard tax forms, and you need results quickly. Build, or extend a platform with custom components, when the value sits in steps no product covers: reconciling documents against each other, applying your firm's own rules, or connecting to your decision systems. All three projects here needed custom reconciliation, validation, or retrieval layers around the models.

How long does an IDP project take?

A focused pilot on one workflow typically takes 6 to 12 weeks after a short assessment. Connecting the results to decision systems and adding more document types takes several months more.

Start your project with Muoro!

An engineer (not sales) will reach out within 4 hours with a calendar link.

Start Building Data-First Production AI

Move beyond pilots. Build AI systems that drive real decisions and measurable outcomes.

TALK TO US