This is a sample report. Start your own assessment below. Start Your Assessment →

FULLVISION Assessment Report

Invoice Processing & Approval

TechCorp s.r.o. (example)

15 May 2026

01/Recommendation

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.

02/Process Overview

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.

03/Path Scores

Path Scores

AI Agent Recommended
9/10

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.

Hybrid
8/10

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
5/10

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.

AI Workflow
5/10

Workflow tools handle the orchestration well but lack the document understanding depth needed for reliable invoice extraction across different supplier formats.

Traditional Code Not recommended
3/10

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.

Stay Manual Not recommended
1/10

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.

04/Process Dimensions

Process Dimensions

Eight dimensions drive the recommendation — scored 0–10 with a note on each.

Data Structure 7/10

Mix of structured SAP data and unstructured supplier PDFs

Rule Clarity 8/10

Approval thresholds and matching rules are well-defined

Exception Frequency 6/10

~20% of invoices hit an exception requiring judgment

Integration Readiness 9/10

REST APIs available for SAP, SharePoint, and Exchange

Volume / ROI 10/10

6,000/year × 22min = 2,200 person-hours; ROI is compelling

Process Stability 7/10

Business rules change rarely; supplier formats change more often

Human Judgment Required 5/10

Most decisions are rule-based; ~5% require genuine judgment

Compliance Requirements 6/10

GDPR and 7-year audit trail require careful data handling

05/ROI Estimate

ROI Estimate

€110,000

Current annual cost

78%

Estimated time saved

€85,800

Annual savings

3mo

Payback period

Build cost estimate: €18,000 – €28,000

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.

06/Implementation Roadmap

Implementation Roadmap

1
Discovery & integration mapping 1–2 weeks

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.

2
Document extraction layer 2–3 weeks

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.

3
Agent core + SAP integration 3–4 weeks

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).

4
Exception handling & human escalation 2 weeks

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.

5
Audit trail & compliance layer 1 week

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.

6
Pilot & go-live 3–4 weeks

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.

07/Risks & Considerations

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.

08/Architecture Overview

Architecture Overview

flowchart LR subgraph Inputs A([Invoice Email]) B([Invoice Post]) end subgraph Agent["AI Agent (AWS Bedrock)"] C["Extract invoice data"] D["Lookup PO in SAP"] E{"PO match?"} F{"Amount > €5k?"} G["Route for approval"] H["Post to SAP"] end subgraph External I(SAP S/4HANA) J(SharePoint) K(Outlook/Exchange) end subgraph Human L{"AP Review Queue"} end M([Payment Posted]) A --> C B --> C C --> D D --> I D --> E E -- No match --> L E -- Match --> F F -- Yes --> G F -- No --> H G --> J L --> H H --> I H --> K H --> M

Hover to zoom · click for fullscreen

09/Why This Approach

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.

10/Comparing the Top Approaches

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.

11/How to Build It

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.

12/Risks in Detail

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.

📁 your-process/
📄 CLAUDE.md
📄 pyproject.toml
📁 src/agent.py
📄 .env.example
Start Your Assessment

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.