FULLVISION Assessment Report
Invoice Processing & Approval
TechCorp s.r.o. (example)
15 May 2026
AI Agent
Strong AI agent candidate — high volume, document-heavy, with clear rules and excellent API access.
Invoice processing is one of the most compelling automation targets we see: 6,000 runs per year at 22 minutes each represents 2,200 person-hours annually. The process combines document understanding (reading unstructured PDFs), structured data lookup (SAP PO matching), and conditional routing (approval thresholds) — exactly the profile where an AI agent on AWS Bedrock outperforms both RPA and traditional scripted automation. With REST APIs available for all three core systems, integration risk is low. Your Microsoft Azure preference is easy to accommodate: the agent runs on AWS Bedrock while connecting to Azure-hosted SAP and SharePoint via their standard APIs.
Your Azure + Python stack aligns well. The agent logic is pure Python and can be deployed as a container on either AWS ECS or Azure Container Apps — whichever fits your existing infra better.
Process Overview
The accounts payable team receives supplier invoices by email and occasionally by post. Each invoice must be matched to an open purchase order in SAP, validated for amount and line items, routed for approval (invoices above €5,000 require two manager approvals), and then posted to the SAP payment run. The supplier receives a confirmation once payment is posted and the PDF is archived in SharePoint.
The process runs 6,000 times per year at an average of 22 minutes per invoice. About 20% of invoices hit an exception — most commonly a missing or incorrect PO reference or a price discrepancy — and require manual intervention before they can proceed. The remaining 80% follow a predictable, rule-based path that is well-suited to automation.
Path Scores
The combination of unstructured PDF parsing, fuzzy PO matching, and exception reasoning is exactly what an LLM-driven agent handles well. Claude on Bedrock can read invoice PDFs natively, reason about discrepancies, and decide which approval route to trigger.
A strong alternative if your compliance team wants human review on all exceptions. The agent handles the 85% of clean invoices autonomously; a human approves the remaining 15%.
RPA can handle the SAP data entry but struggles with unstructured PDF extraction and the judgment calls on discrepancies. You'd still need a separate OCR layer and brittle screen-scraping rules.
Workflow tools handle the orchestration well but lack the document understanding depth needed for reliable invoice extraction across different supplier formats.
A rules-based script would need a separate OCR tool and brittle regex patterns per supplier template. The 12% missing-PO exception rate alone would require more exception-handling code than business logic.
At 6,000 invoices per year, manual processing is costing roughly €110,000 in staff time annually. This is not sustainable and the process has no characteristics that require it to stay manual.
Process Dimensions
Eight dimensions drive the recommendation — scored 0–10 with a note on each.
Mix of structured SAP data and unstructured supplier PDFs
Approval thresholds and matching rules are well-defined
~20% of invoices hit an exception requiring judgment
REST APIs available for SAP, SharePoint, and Exchange
6,000/year × 22min = 2,200 person-hours; ROI is compelling
Business rules change rarely; supplier formats change more often
Most decisions are rule-based; ~5% require genuine judgment
GDPR and 7-year audit trail require careful data handling
ROI Estimate
€110,000
Current annual cost
78%
Estimated time saved
€85,800
Annual savings
3mo
Payback period
Cost estimate based on 6,000 invoices/year × 22 min × €50/hr fully loaded. Build cost assumes an experienced Python developer at €800/day; the 20% exception rate requires more agent testing time than a simpler process.
Implementation Roadmap
Audit the SAP REST API endpoints needed for PO lookup and invoice posting. Confirm SharePoint Graph API permissions and Exchange webhook availability. Collect 50 representative invoice PDFs (clean + exception cases) for agent testing.
Build the invoice extraction module using Claude's native PDF support. Define the extraction schema (vendor, invoice number, date, line items, VAT, PO reference) and validate accuracy against the 50-invoice test set. Target: >95% field accuracy on clean invoices.
Implement the main agent loop: extract → lookup PO in SAP → validate amounts → decide route. Register SAP REST endpoints as agent tools. Implement the approval routing logic (single vs. dual approval thresholds).
Build the exception queue: a simple web UI or Teams notification for AP staff to review flagged invoices. The agent pauses and waits for human decision before continuing. This is the human-in-the-loop gate.
Implement structured logging to Azure Blob Storage (or AWS S3) for the 7-year retention requirement. Each agent run produces a JSON audit record: invoice ID, extracted fields, PO match result, approval decision, timestamps.
Run parallel with manual processing for 2 weeks on 10% of invoice volume. Compare agent decisions with human decisions. Fix edge cases. Roll out to 100% of volume with AP staff monitoring the exception queue.
Risks & Considerations
The biggest risk is supplier invoice format variability. Claude handles most PDF layouts well, but unusual formats (scanned handwritten invoices, non-standard table structures) will surface exceptions that the AP team must review. Budget for ongoing prompt refinement as new supplier formats appear — this is maintenance cost, not a one-time build.
SAP integration deserves careful attention: test in a sandboxed SAP environment before connecting to production. A bug that posts incorrect amounts or duplicate payments could be expensive to unwind. The human-in-the-loop exception gate is not optional — it is a compliance safeguard as much as an accuracy backstop.
Architecture Overview
Hover to zoom · click for fullscreen
Why This Approach
Invoice processing lands squarely in AI agent territory for three reasons. First, the inputs are unstructured: invoices arrive as PDFs in dozens of different layouts from hundreds of suppliers. Traditional scripted OCR fails on format variation; Claude's native document understanding handles it reliably. Second, the matching and validation logic involves fuzzy comparison — amounts within tolerance, PO references that are present but slightly malformed — that requires genuine reasoning rather than string equality checks. Third, the exception rate (20%) is high enough that the system needs to make sensible decisions about what to escalate rather than failing on anything unusual.
RPA was considered and rejected. The invoice PDF extraction problem alone would require a separate OCR layer with vendor-specific templates, making the solution brittle and expensive to maintain as supplier formats change. RPA is the right call when the process is entirely UI-based and inputs are already structured — this one is neither.
Your Azure + Python stack aligns well with the recommended approach. The agent is written in Python and can be containerised and deployed to Azure Container Apps or AWS ECS — the Bedrock API call is the only AWS dependency. Everything else (SAP, SharePoint, Exchange) uses standard REST APIs that work identically from either cloud.
Comparing the Top Approaches
Between AI agent (score: 9) and hybrid (score: 8), the difference is a question of risk appetite rather than technical capability. A pure AI agent handles the full 100% of invoice volume autonomously, escalating only genuine exceptions. A hybrid approach sends all flagged invoices to a human queue regardless of whether the agent is confident. For a first deployment, hybrid is the safer choice: AP staff stay in the loop on exceptions, which builds trust and surfaces edge cases faster. Once the team is confident in the agent's accuracy, the human gate can be narrowed to only the highest-value or most ambiguous cases.
RPA (score: 5) is not competitive here because the document extraction problem is genuinely hard for rule-based systems. If all your invoices arrived as structured EDI files, RPA would score higher. They don't.
How to Build It
The agent runs as a Python service triggered by an Exchange webhook when a new invoice email arrives. It calls Claude on AWS Bedrock with the attached PDF, instructing it to extract structured invoice data into a defined JSON schema. This gives you vendor name, invoice number, date, line items, VAT breakdown, and PO reference — all extracted natively without a separate OCR tool.
The extracted PO reference is used to call the SAP REST API and retrieve the matching purchase order. The agent compares invoice amounts to PO amounts with a configurable tolerance (default ±2%). If everything matches and the amount is below €5,000, the agent calls the SAP invoice posting endpoint directly. If the amount exceeds €5,000, it creates an approval request in SharePoint via the Graph API and waits for the approval callback before posting.
Exceptions — missing PO reference, amount outside tolerance, vendor not in SAP master data — are routed to an exception queue. This is a lightweight web interface (or a Teams bot) where AP staff see the flagged invoice, the agent's reasoning, and the available actions: approve anyway, reject, or request correction from the supplier. The agent resumes once a decision is recorded. Every run produces a structured JSON audit log stored in Azure Blob Storage for the 7-year retention requirement.
Risks in Detail
The primary operational risk is supplier invoice format variability. Claude handles the vast majority of PDF layouts reliably, but edge cases — scanned handwritten invoices, non-standard column structures, invoices in languages outside the training distribution — will surface over time. Budget for ongoing extraction prompt refinement; treat it as routine maintenance rather than a project failure. The exception queue is your early-warning system: spikes in exception rate are usually a signal that a new supplier format needs handling.
SAP integration requires careful testing. A bug that double-posts a payment or posts to the wrong GL account is expensive to unwind. Run the agent in parallel with manual processing for at least two weeks before giving it write access to production SAP. Use SAP's sandbox environment for the initial integration tests and maintain a dry-run mode that logs intended actions without executing them — useful for debugging and for regulatory audit demonstrations.
Claude Code Starter
A scaffolded project ready to open in Claude Code. Unzip, open the folder, and Claude starts building immediately.
Claude Code Starter (.zip)
Your own assessment includes a ready-to-use project scaffold: CLAUDE.md, pyproject.toml, src/agent.py and .env.example — open the folder in Claude Code and it starts building.
What's next?
Let Fullvio take it further
This assessment gives you the direction. Fullvio can help you get there — whether that's a full process audit across your organisation or hands-on implementation of this specific process.