Even with numerous advances in enterprise applications, accounts payable (AP) processes still have stubbornly manual workflows in the enterprise.
Invoices arrive in different layouts, languages and file qualities. Some reference purchase orders that have changed over time. Others are missing key metadata that an Enterprise Resource Planning (ERP) requires before anything can be posted. Traditional automation tools can typically extract fields from a document, but edge cases can create operational cost, such as supplier-specific formatting, non-PO invoices, ambiguous line matching, fragmented enterprise data and business rules that vary by company.
To address that gap, we built InvoiceIQ, a tool we use internally at Snowflake.
Figure 1: Invoice detail in InvoiceIQ.
Instead of treating invoice processing as a document-parsing problem, we rebuilt it as a governed data and workflow problem running directly on Snowflake. The result is a Snowflake native accounts payable application that combines document understanding, enterprise enrichment, business rules and ERP submission in one system.
In this post, we’ll cover:
- Why traditional AP automation leaves too much value on the table
- Why we chose a Snowflake native architecture
- How InvoiceIQ turns raw invoices into finance-ready records
- What we learned about running AI-driven workflows in production
The real bottleneck in AP automation #
Modern multimodal models are already capable of reading invoices. The technical challenge is no longer whether AI can see text on a page. Rather, the harder question is how to make the model’s understanding dependable inside a real finance workflow.
In practice, AP automation fails less because a model cannot read a document and more because the workflow around that document is fragmented. Data lives in multiple systems. SaaS AI features are often general-purpose and difficult to adapt to company-specific AP workflows. Integration patterns are not designed for adaptive workflows. And the exceptions that matter most are often unique to a company’s suppliers, policies and ERP requirements.
That is the last mile InvoiceIQ was designed to bridge. Internally, we framed the problem as building a system that could reduce manual review, improve control and create a reusable pattern for AI applications built directly on governed enterprise data.
Why we built this natively on Snowflake #
We took a simple architectural position early: Keep the workflow close to the data, keep deterministic parts deterministic, and use AI as one layer in a broader system rather than turning the entire workflow into an opaque agent.
That decision mattered because the data we needed was already in Snowflake. Purchase orders, supplier primary data, historical invoices, configuration, queue state and downstream submission records were already available or could be modeled there. Rather than exporting that context into a patchwork of external services, we brought the application logic to the data.
InvoiceIQ runs inside Snowflake using Snowpark Container Services (SPCS), with workflow coordination, configuration and audit history also staying in Snowflake. That gives us a single security boundary, simpler operations and a system that is easier to inspect when something goes wrong.
How InvoiceIQ works #
At a high level, InvoiceIQ processes each invoice through six stages: classification, extraction, translation, matching, enrichment and decision-making. Each stage has a narrow responsibility, and together they turn a raw PDF into a finance-ready record that can be submitted to Workday or routed to an analyst with clear reasoning.
Figure 2: InvoiceIQ pipeline overview.
Classification
The first step is deciding whether an uploaded file is actually an invoice.
That sounds trivial, but in practice AP teams receive receipts, purchase orders, statements and supporting documents alongside invoices. InvoiceIQ filters those out early using AI_PARSE_DOCUMENT together with AI_CLASSIFY, so the rest of the pipeline only spends time on documents that matter to the invoice workflow.
Extraction and document understanding
Figure 3: Document extraction pipeline, from PDF intake to invoice understanding.
Extraction is a deliberately multistage process.
InvoiceIQ uses Snowflake document intelligence services to build a structured view of each invoice, recover text and layout information and preserve traceability back to the source document for analyst review.
Once that text is assembled, AI_COMPLETE converts it into structured invoice data such as header fields and line items. This is the point where the system moves from raw document content to a representation the business can actually operate on.
Translation and normalization
Figure 4: Language detection and translation workflow.
Invoice translation is not treated as generic preprocessing.
The pipeline first detects language using invoice-aware signals from the document itself, then translates targeted sections using CORTEX.TRANSLATE while preserving the original document position and keeping both the original and translated text for review.
This matters because invoices are often sparse, numeric and structurally irregular. Translating the exact fields that affect workflow quality is more useful than doing a generic full-document translation and losing context along the way.
Matching
Figure 5: Invoice matching approaches.
For PO-backed invoices, matching is where AI becomes operationally meaningful. InvoiceIQ uses three different matching methods for three different jobs. Exact matching acts as a low-cost short circuit when strings already line up. JAROWINKLER_SIMILARITY helps resolve messy supplier and legal-entity names. And AI_COMPLETE performs semantic invoice-line to PO-line matching when the wording differs but the business meaning is the same.
That allows the system to connect invoice lines such as “Professional Services Q1” to a purchase-order line with a more formal or differently worded description, without forcing an analyst to reconcile every mismatch by hand.
Enrichment
Figure 6: Smart enrichment for invoices.
Extraction tells us what is on the invoice. Enrichment tells us what the final business record should be.
Once lines are matched, InvoiceIQ pulls in enterprise context from systems of record residing in Snowflake. That includes fields such as spend category, cost center, location, company code, service dates, payment terms and tax-related values.
This is one of the most important design choices in the system. We do not assume the PDF should be the final source of truth for every field. Instead, teams can choose which data should come from the document and which should be overridden by internal systems and business policy. For PO-backed invoices, the PO system of record can take precedence. For non-PO invoices, supplier and historical context can fill in what the document lacks.
That makes the application much more adaptable to company-specific AP operations than a stand-alone parser ever could.
Decisioning-making and submission
Figure 7: InvoiceIQ invoice lifecycle.
After the matching and enrichment stages, the system determines the next action.
Invoices enter through an email integration process or manual load, move through AI processing and then receive an initial outcome such as approved, rejected, duplicate or review required. Items that need attention are assigned to analysts, while clean cases can move forward with far less human effort than a traditional AP queue requires.
The important point is not that every invoice becomes fully autonomous. It is that human review is reserved for the cases where judgment is actually needed, and those cases arrive with structured context instead of a blank screen.
Running AI workflows in production #
Shipping AI features is only half the job. Running them reliably at scale — securely, observably and without a dedicated ops team — is the other half. InvoiceIQ leans on Snowflake’s platform to handle every one of these concerns natively.
Figure 8: The five pillars that let InvoiceIQ run in production on Snowflake: scalability, observability, audit trail, security and evaluation.
Scalability: SPCS autoscaling and parallel AI inference
InvoiceIQ can absorb fluctuating invoice volume without manual intervention because SPCS automatically scales compute up and down with demand, while Snowflake Cortex AI Functions run concurrently inside Snowflake’s compute layer. That lets multiple inference steps execute in parallel within a single pipeline, without extra network hops, custom rate-limit handling or a dedicated ops team.
Observability: Every token counts
Observability in InvoiceIQ is about runtime behavior: Every pipeline run writes operational metrics into Snowflake, including per-stage latency, token usage for each Cortex AI call, and error and retry counts. That telemetry powers a Streamlit dashboard that helps engineers spot bottlenecks, understand per-invoice costs and monitor model performance over time.
Audit trail: Auditing as a top-level citizen
The audit trail serves a different purpose: It records what happened, not how efficiently the system ran. Every AI-driven or human action writes an event to a Snowflake audit table, making the full history queryable with SQL, easy to join with related account data and readily available for compliance or operational reporting.
Security and access control: Snowflake RBAC and SPCS
Security follows the same Snowflake role-based access control model used across the rest of the account. Each SPCS service runs under a dedicated Snowflake role with only the permissions it needs, and analysts, engineers and service accounts all operate under scoped roles. The result is a single least-privilege model across humans and services, without separate IAM layers, manual credential rotation or external-secrets infrastructure.
Evaluation: TruLens and regression testing
InvoiceIQ measures quality continuously rather than treating accuracy as a one-time check. TruLens traces and scores LLM calls across the pipeline for signals such as relevance and groundedness, while a regression suite tests every change against real invoices with human-verified ground truth. That benchmark-first approach makes it safer to adopt new prompts, models and Snowflake AI capabilities while giving the team a way to detect quality regressions before they reach production.
Closing #
There is still plenty of room to improve invoice automation. But the foundation is now in place.
By rebuilding AP around Snowflake native services, governed enterprise data and targeted AI functions, we moved beyond invoice extraction and toward a system that can actually operate in real business conditions. The result is not a fully autonomous black box. It is something more useful: a controllable, inspectable and extensible workflow that puts AI where it helps most and keeps the rest of the system grounded in enterprise truth.
What changed for the business
InvoiceIQ was built to improve both efficiency and control.
In the internal rollout, the team successfully shifted the majority of supplier invoices to processing through InvoiceIQ, enabling an agentic AP workflow built on our own data, with AI-driven analytics and insights instantly available at go-live using Snowflake CoCo. Just as important, the system created a stronger technical foundation for future AP automation: one where business rules, enrichment logic, model behavior and auditability can evolve together.
Clean invoices can move from inbox to ERP in minutes. Exceptions arrive prepopulated with context. And teams have a path to keep improving accuracy over time without rebuilding the application around each new model cycle.