How an AI Agent for PO Verification Can Save Your Team 2,400 Hours a Year

Nobody wakes up excited to reconcile purchase order confirmations. Yet that's what companies everywhere pay skilled procurement professionals to do: comparing PDFs to ERP records, line by line, day after day.

At Building an AI Agent for PO Verification, a virtual session at Domo BUILD 2026, Amanda Hull, SVP and CFO of Massman, and David Sawyers, Domo AI ecosystem director, walked through a hackathon project that flips this script entirely.

They demonstrated how an AI agent for PO verification can extract data from vendor PDFs, compare it against NetSuite records, and route only the exceptions to human reviewers. The estimated impact was roughly 2,400 hours saved annually—the equivalent of one to one and a half full-time employees—while improving processing speed and reducing manual effort.

Here's what you can take away from their approach, whether you're building something similar or just exploring how AI agents can handle the tedious work your team hates.

Key takeaways

• An exception-based workflow for PO confirmation review can reclaim significant capacity by focusing human attention only on records that need it.
• The entire solution uses native platform building blocks: ProCode UI, Document Collection, Workflow orchestration, AI agent extraction, SQL comparison, and AppDB output.
• Agent-based reasoning outperforms brittle template matching for PDF extraction, enabling self-correcting behavior when documents vary.
• Human-in-the-loop approval for vendor outreach preserves oversight while AI handles the drafting.

Shift to exception-based review

Stop reviewing every confirmation, and focus only on what needs attention

PO confirmation review is important work, but important doesn't mean manual. Amanda's goal was directing human judgment toward records that actually require attention.

As Amanda framed it, "What I worry about is talented people spending time on work that does not create value. And that's where our mantra came from: automate what you hate."

The tool she and David built uploads supplier confirmations, extracts the relevant information, compares it against NetSuite records, identifies discrepancies, and prepares approved transactions for processing. Rather than requiring a buyer to review every confirmation, the goal was creating an exception-based workflow where people focus only on the records that need attention.

If you're considering a similar approach, here's how to think about implementation:

• Map your current workflow: Document how many confirmations your team processes weekly and what percentage actually contain discrepancies worth investigating‍
• Define your exception criteria: What constitutes a mismatch worth human review? Quantity variances above a threshold? Rate differences? Missing line items?‍
• Calculate your baseline: Before building anything, establish how much time your team currently spends on confirmation review so you can measure impact

Build with native orchestration

Connect file ingestion, AI extraction, and comparison in one governed stack

The technical architecture matters here. Amanda and David described four distinct moments where automation takes over, all using native platform components rather than stitching together external tools.

First, when someone drops a vendor PDF into the app, it goes into a document collection. That triggers a workflow automatically. Second, the workflow hands the file to an AI agent that reads the PDF using image-to-text capabilities, extracting structured fields like PO number, expected delivery date, ship-to address, and every line item with quantities, rates, amounts, and part numbers.

Third, the agent runs a SQL query against a dataset synced live from NetSuite—the source of truth—comparing every field line by line. Any quantity mismatches, rate differences, or part number discrepancies are surfaced and flagged with a severity level. Results then get written to AppDB, which the app reads to display the variance report.

Fourth, when a reviewer is ready to reach out about discrepancies, an email workflow kicks in. AI text generation drafts the message based on the specific issues surfaced.

For your own implementation, consider this architecture pattern:

• File drop: Use a document collection or file library that can trigger downstream processes automatically‍
• Extraction: Deploy an AI agent with image-to-text capabilities for unstructured PDF parsing‍
• Comparison: Connect to your ERP-synced dataset as the authoritative source, using SQL for field-by-field validation‍
• Output: Write results to a structured data store that your application layer can query for variance reporting‍
• Communication: Generate context-specific outreach with AI text generation, but keep approval in human hands

Prioritize reasoning over templates

Use AI that adapts to document variation instead of breaking on format changes

One helpful thing to note: The extraction approach isn't pattern matching against a fixed template. The agent is actually reasoning through the document the way a person would, and it knows when something looks off.

This matters because vendor confirmations aren't standardized. Different suppliers send different formats. A template-based approach breaks every time you onboard a new vendor or an existing supplier updates their document layout. An agent that reasons through the document can handle variation without constant maintenance.

The self-correcting behavior described in the session means the agent can flag when something seems inconsistent, not just when it finds a mismatch against your ERP data, but when the document itself doesn't make sense.

If you're evaluating extraction approaches, ask these questions:

• How does the system handle format variation across suppliers?
• What happens when a new vendor sends a confirmation in a layout the system hasn't seen?
• Can the extraction layer flag documents that seem malformed or incomplete, not just those with data mismatches?
• How much maintenance does the extraction logic require as your vendor base changes?

Keep humans in the loop for vendor communication

Let AI draft discrepancy emails while humans approve before sending

The final piece of the workflow addresses what happens after discrepancies are identified. Someone needs to communicate with the vendor, but that doesn't mean a human needs to compose every email from scratch.

Domo's AI text generation drafts the e-mail automatically based on the specific discrepancies that were surfaced. A human reviews it, approves it, and then Domo sends it, keeping a human in the loop, but all the heavy lifting is already done.

This is a good pattern for any AI-assisted communication workflow. The AI handles the tedious part—pulling specific discrepancy details into a coherent message—while humans retain control over what actually gets sent. You get speed without sacrificing oversight.

For your own vendor communication workflows:

• Generate drafts based on specific discrepancy data, not generic templates
• Surface the relevant details (which line items, what the variance is, what action you're requesting) so reviewers can quickly validate accuracy
• Make approval a single action, not a multi-step process that adds friction
• Log sent communications for audit purposes

Watch the full PO agent demo

Amanda, David, and their team built this entire agent in 24 hours during a hackathon. That's not a promise that you'll replicate it in a day, but it does suggest that the building blocks exist to move quickly if you have the right platform capabilities in place.

They had the right mindset, too. Their AI agent for PO verification was never intended to replace the procurement team. Rather, the goal was giving them back the hours they're currently spending on work they (let's be honest) hate doing anyway.

Ready to see the full technical walkthrough? Watch the complete session from Domo BUILD 2026 to see how the extraction, comparison, and communication workflows come together.