Email?based invoices broke three?way match, invoice extraction to Coupa and SAP maker?checker created a controlled queue

Overview

An industrial manufacturer’s Accounts Payable (AP) team was buried in emailed invoices, manual coding, and stalled three?way matches in SAP. Purchase Orders (POs), Goods Receipts (GRs), and invoices did not reconcile consistently, so approvals lived in email threads and month?end closed late. Intelligex implemented an OCR and data extraction pipeline validated against the vendor master, orchestrated the flow through Coupa and MuleSoft, and added a maker?checker approval in SAP for exceptions. Matching moved from email ping?pong to a controlled queue with clear statuses, fewer handoffs, and consistent evidence for audits—while SAP, Coupa, and existing integrations stayed in place.

Client Profile

• Industry: Industrial manufacturing (multi?plant operations)
• Company size (range): Enterprise with shared services for Finance and Procurement
• Stage: Established SAP ERP and Coupa for procurement; invoice intake handled via email and network folders
• Department owner: Finance & Accounting (Accounts Payable)
• Other stakeholders: Procurement, Plant Receiving, IT/Integration, Internal Audit, Treasury, Legal, Supplier Management, Data/Analytics

The Challenge

Invoices arrived as PDFs, scans, and handwritten adjustments. Many lacked complete PO references, vendor identifiers deviated from the master, and line items did not align cleanly with SAP data. AP analysts manually keyed header and line details, chased buyers for coding, and waited on plants to confirm receipts. Three?way matches stalled when PO tolerances, unit of measure differences, or partial receipts created edge cases. Exceptions lingered in inboxes, and the same disputes resurfaced at quarter end when auditors asked for traceable approvals.

Tools existed but were disconnected. Coupa captured POs and receipts, SAP posted payables and payments, and MuleSoft moved files between systems. None of these ensured invoices were normalized at intake, mapped to the vendor master, or routed through a consistent exception workflow. Duplicate invoices slipped in when suppliers re?sent, non?PO invoices bypassed controls, and urgent payment requests jumped the queue. The team needed an intake and matching layer that enforced data quality, coordinated approvals, and preserved a defensible trail—all without replatforming.

Why It Was Happening

Root causes were fragmented intake, inconsistent data validation, and ad hoc exception handling. Email was the primary channel, so the same invoice could enter more than once. Vendor names, bank details, and addresses varied from the master, and coding rules differed by buyer and plant. Three?way match logic was reliable in SAP, but invoices rarely arrived in a format that made matching straightforward. Without a governed queue and standardized evidence, analysts relied on personal playbooks and memory, which led to rework and audit findings.

Ownership was diffuse. Procurement owned POs and receipts, AP owned postings and payments, plant teams owned GRs, and IT moved files. No single workflow tied incoming documents to the vendor master, PO/GR validation, and controlled approvals. As volume grew, manual methods could not keep pace, and exceptions crowded out routine processing.

The Solution

Intelligex delivered an ingestion?to?match workflow anchored in OCR extraction, master data validation, and controlled exception handling. Invoices were captured from email and folders, parsed into structured header and line data, and validated against vendor master records and open POs. Clean invoices flowed through Coupa to SAP for automated posting. Exceptions—such as vendor mismatches, quantity variances, or price differences—entered a maker?checker queue in SAP with routed approvals. MuleSoft orchestrated handoffs between systems, and dashboards surfaced queue posture and audit trails. Supplier duplicates and non?PO invoices were flagged with reason codes and routed to defined paths.

• Integrations: OCR and layout?aware parsing (for example, AWS Textract); procurement workflows in Coupa; enterprise service orchestration via MuleSoft; postings and approvals in SAP; identity and vendor data from the vendor master; notifications to Microsoft Teams or Slack.
• Canonical invoice schema: Standardized header and line fields (vendor, invoice number/date, PO, currency, tax, lines with item, description, quantity, unit of measure, price, tax/VAT, cost center/WBS).
• Master data validation: Vendor normalization with fuzzy and ID?based matching, bank detail checks, tax ID validation, and enforcement of approved vendor status.
• PO/GR matching: Automated three?way match against open POs and posted GRs, with handling for unit of measure differences and partial receipts; tolerance policies encoded per category or plant.
• Duplicate and exception detection: Invoice number/date/vendor fingerprinting to prevent re?submissions; reason codes for common breaks (price variance, quantity variance, missing PO, tax mismatch, vendor mismatch).
• Maker?checker approvals: Exceptions routed to a two?step review in SAP; preparer attaches evidence (PO, GR, vendor record, annotated invoice), checker reviews and approves/returns with comments; outcomes logged immutably.
• Queues and dashboards: Controlled AP queues by status (ready to post, vendor review, buyer action, plant receipt, exception pending); KPIs focused on queue health and exception aging; exportable evidence packs for audits.
• Security and audit: Role?based access; segregation of duties enforced on maker?checker steps; lineage from document to posting; archived copies with extracted data and decisions.

Implementation

• Discovery: Mapped invoice sources and current triage steps; cataloged vendor master quality and common mismatch patterns; sampled PO categories and tolerance rules; traced how Coupa, MuleSoft, and SAP were connected; gathered audit requests and exception examples.
• Design: Defined the canonical invoice schema and extraction templates; authored validation rules for vendor master and PO/GR checks; specified tolerance policies and reason codes; designed maker?checker roles and routing; mapped integrations in Coupa and SAP with MuleSoft flows; planned dashboards and evidence packs.
• Build: Implemented OCR extraction and normalization; built vendor and PO/GR validation services; configured Coupa ingestion and postings; developed MuleSoft flows for document intake, validation, routing, and status updates; configured maker?checker in SAP; added duplicate detection; assembled dashboards and notifications.
• Testing/QA: Ran in shadow mode: processed live invoices through the new pipeline while AP continued manual posting; compared match outcomes; tuned extraction templates, vendor match rules, and tolerances; exercised exception paths and maker?checker with real invoices; included a human?in?the?loop review for ambiguous fields.
• Rollout: Enabled automated posting for stable categories first; kept manual paths as a controlled fallback; expanded coverage by plant and supplier segment after consistent cycles; turned on duplicate blocking and strict routing after training.
• Training/hand?off: Delivered sessions for AP analysts, buyers, and plant receivers on queue handling, evidence attachments, and approvals; updated SOPs for exceptions and urgent payments; transferred ownership of templates, rules, and dashboards to AP Ops under change control.

Results

Matching moved from scattered emails to a controlled, transparent queue. Routine invoices posted with minimal touch once vendor and PO/GR validations passed, and exceptions carried clear reason codes with routed actions. AP stopped re?keying data and spent time where it mattered—resolving true exceptions with the right stakeholders.

Audits became straightforward. Every posting linked back to the original document, extracted fields, validations, and approvals. Maker?checker decisions included attachments and comments, and duplicate prevention reduced noise. Procurement and plants saw fewer blind escalations because status and evidence lived in one place. The organization kept SAP, Coupa, and MuleSoft; the difference was a governed intake and matching layer that made the process predictable.

What Changed for the Team

• Before: Invoices arrived via email with manual coding. After: OCR captured structured data into a standardized schema with validations.
• Before: Three?way matches stalled in inbox threads. After: Matches and exceptions flowed through a controlled AP queue with statuses and reason codes.
• Before: Duplicate invoices slipped through. After: Fingerprinting blocked re?submissions and flagged potential duplicates.
• Before: Approvals were informal and hard to trace. After: Maker?checker steps in SAP logged preparer evidence and checker decisions.
• Before: Month?end relied on memory and ad hoc lists. After: Dashboards showed queue posture, exception aging, and audit?ready evidence packs.
• Before: Integrations moved files, not decisions. After: MuleSoft orchestrated validation, routing, and status updates across Coupa and SAP.

Key Takeaways

• Normalize at intake; a canonical invoice schema and vendor master validation reduce downstream breaks.
• Automate the match, govern the exception; let systems post what’s clean and route the rest through maker?checker.
• Close the loop across tools; orchestrate SAP and Coupa with integration flows rather than relying on email.
• Prevent duplicates early; fingerprint invoices to avoid rework and confusion.
• Make evidence first?class; attach PO, GR, vendor data, and annotated invoices to decisions for audit readiness.
• Integrate, don’t replace; layer extraction, validation, and approvals onto existing ERP and procurement systems.

FAQ

What tools did this integrate with? Invoices were parsed by an OCR service (for example, AWS Textract) and validated against the vendor master and open POs/GRs. Clean postings flowed through Coupa to SAP, and exceptions entered maker?checker steps directly in SAP. MuleSoft orchestrated ingestion, validation, routing, and status updates. Notifications and dashboards used the client’s existing collaboration and BI tools.

How did you handle quality control and governance? Extraction templates, validation rules, and tolerance policies lived under change control with AP and Procurement ownership. Maker?checker enforced segregation of duties on exceptions. Every action—extraction, validation, approval, post—was logged with attachments and comments. Duplicate detection prevented accidental re?posts, and reason codes standardized exception handling.

How did you roll this out without disruption? The pipeline ran in shadow mode first, processing invoices and producing draft matches while AP continued current methods. Results were compared and rules tuned. Automated posting was enabled for stable categories and suppliers before expanding. Manual paths remained as a controlled fallback early on, and training covered queues, evidence, and approvals.

How were three?way matches handled with partial receipts or tolerances? The matching service aligned invoice lines to PO schedules and posted GRs, applied unit of measure conversions where required, and respected category?specific tolerances. When quantity or price variances exceeded policy, the invoice moved to the exception queue with a reason code and links to PO and GR evidence for buyer or plant action.

How did you manage non?PO invoices and credit memos? Non?PO invoices followed a defined coding and approval path with maker?checker review and required cost center or WBS entries. Credit memos were captured by the same intake and validation steps, matched to prior invoices or POs where applicable, and routed with evidence to ensure appropriate offsets and approvals.

How did you prevent and detect duplicate invoices? The system fingerprinted invoices using vendor, invoice number, date, amount, and line patterns. Suspected duplicates were flagged at intake and blocked from posting until reviewed. Re?submitted documents from suppliers landed in a deduplicated view with the original posting and decision history.