---
title: 'How to Automate Invoice Processing Without Code'
description: 'Build a complete invoice processing workflow with Airtable, Make, and PDF generation tools — covering both outbound client invoicing and inbound vendor invoice intake.'
canonical_url: 'https://www.business-automated.com/tutorials/automate-invoice-processing-no-code'
md_url: 'https://www.business-automated.com/tutorials/automate-invoice-processing-no-code.md'
last_updated: 2026-05-24
---

If you ask any small business owner where automation would save them the most time, "invoices" comes up early. The work is predictable, repeated, and high-stakes enough that mistakes get noticed. It's also one of the cleanest workflows to automate end-to-end — the inputs are structured, the outputs are documents, and the systems involved (your CRM or projects database, your PDF tool, your payment processor, your accounting tool) all have good APIs.

This guide walks through both directions: invoices you send to clients (outbound) and invoices you receive from vendors (inbound). Both run on [Airtable](/airtable-consultant) as the data layer and [Make](/make-automation-agency) as the orchestration layer.

## The Two Flows at a Glance

|             | Outbound (you bill clients)                       | Inbound (vendors bill you)                  |
| ----------- | ------------------------------------------------- | ------------------------------------------- |
| Source      | Project data, time entries, retainers in Airtable | PDF or email arriving in inbox              |
| Key step    | PDF generation from a template                    | Data extraction from PDF                    |
| Approval    | Internal review before send                       | Internal review before pay                  |
| Output      | Invoice in Xero, PDF emailed to client            | Bill in Xero, scheduled for payment         |
| Tools added | Docupilot or PandaDoc, Stripe                     | Mindee or Parseur, optional ERP integration |

The base Airtable schema can serve both, with separate tables for outbound Invoices and inbound Bills.

## Outbound: Client Invoicing

### The Schema

Three tables. If you already have a CRM in Airtable, plug these in alongside.

**Clients**

- Name (primary)
- Email
- Xero Contact ID
- Currency (single-select)
- Payment Terms (number, days)

**Invoices**

- Invoice Number (primary, formula `INV-` + autonumber)
- Client (linked → Clients)
- Status (single-select: Draft / Ready to Send / Sent / Paid / Overdue / Void)
- Issue Date
- Due Date (formula: `DATEADD({Issue Date}, {Client Payment Terms}, 'days')`)
- Total (rollup of Line Items Amount)
- PDF (attachment, populated by Make)
- Xero Invoice ID, Xero Invoice URL

**Invoice Line Items**

- Description (primary)
- Invoice (linked → Invoices)
- Quantity, Unit Price, Amount (formula)
- Tax Code

For the relational patterns, see [Linked Records Explained](/tutorials/airtable-linked-records-explained).

### The Outbound Make Scenario

The scenario fires when an Invoice's status flips to Ready to Send.

1. **Trigger:** Airtable Watch Records on Invoices, view `Ready to Send`.
2. **Search Records** on Invoice Line Items where Invoice = trigger record.
3. **Iterator** over the line items, then **Array Aggregator** to build the line items array for both the PDF and Xero.
4. **PDF Generation:**
   - Docupilot: pass Airtable data into the template, get back a PDF URL.
   - Or Google Docs: copy a template doc, replace placeholders, export as PDF.
5. **Airtable Update Record:** attach the PDF to the invoice record.
6. **Xero Create Invoice:** create the invoice in Xero with line items.
7. **Email Send:** Gmail or Postmark, attach the PDF, body using a template that includes the payment link.
8. **Airtable Update:** Status → Sent, save Xero ID.

The PDF generation step is the part that's new compared to our [base Xero invoice tutorial](/tutorials/creating-invoices-in-xero-with-airtable). The rest follows the same pattern.

### Choosing a PDF Generation Tool

Three options, ranked by complexity:

**Google Docs (free, low complexity).** Build a template doc with `{{placeholder}}` text. Use Make's Google Docs "Create a document from a template" module. Limitations: tables of line items take work to populate (you usually script around it), and formatting control is limited.

**Docupilot (paid, medium complexity).** Purpose-built for document generation. Supports tables of varying length, conditional content, multiple currencies. Templates are built in a Google-Docs-like editor with merge tags. Pricing starts around $29/month.

**PandaDoc (paid, higher complexity).** Heavier tool — supports e-signatures, payment integration, templated proposals. Worth using if you also need contracts and proposals; overkill for invoices alone.

For most agencies and small businesses, Docupilot is the sweet spot. The line-item table support is the deciding factor.

### Payment Tracking

After the invoice is sent, you need to know when it's paid. Three approaches:

**Stripe payment links.** Include a Stripe link in the invoice email. When the client pays, Stripe fires a webhook to Make, which updates the Airtable invoice status to Paid. Cleanest experience but requires a Stripe account.

**Xero reverse-sync.** A second Make scenario polls Xero hourly for invoice status changes (see our [agency receivables guide](/tutorials/agency-receivables-xero-airtable) for the full pattern).

**Bank webhook (advanced).** Plaid, TrueLayer, or your bank's API send notifications when payments hit the account. Useful for businesses without Stripe or where invoices are paid by bank transfer.

Pick one and stick with it — running two payment-tracking flows tends to cause race conditions.

## Inbound: Vendor Invoice Intake

The inbound flow inverts the outbound one. Instead of generating an invoice, you receive one. Instead of pushing data into a PDF, you extract data out of a PDF.

### The Schema Additions

Add two tables to the same Airtable base.

**Vendors**

- Name (primary)
- Email (the invoice-sending address — used for matching)
- Xero Supplier ID
- Default Account Code (Xero account this vendor's expenses post to)
- Default Tax Code
- Approval Required Above (currency — vendor-specific threshold)

**Bills**

- Bill Number (primary — captured from the vendor's invoice number)
- Vendor (linked → Vendors)
- Status (single-select: Received / Awaiting Approval / Approved / Paid / Rejected)
- Issue Date, Due Date
- Total (number — captured from the PDF)
- Currency
- Original PDF (attachment)
- Extracted Data (long text — raw OCR output for reference)
- Approval Owner (collaborator)
- Approval Notes
- Xero Bill ID

**Bill Line Items** — same shape as Invoice Line Items, linked to Bills. Often populated as one or two line items per bill, not per-product detail.

### The Inbound Pipeline

Three stages.

**Stage 1: Intake.** Vendor sends an invoice PDF to a dedicated email address (e.g., `bills@yourdomain.com`). Make watches the inbox, downloads the PDF, creates a Bill record with the PDF attached and Status = Received.

**Stage 2: Extraction.** An OCR service reads the PDF and returns structured data. Make populates the Bill record's fields. Status moves to Awaiting Approval.

**Stage 3: Approval.** Based on amount and vendor, the bill routes to an approver. They open an Airtable interface, review the extracted data alongside the PDF, click Approve. The bill flows to Xero. Or they reject it, and the submitter gets notified.

### Setting Up Email Intake

In Make:

1. Create a scenario triggered by **Email — Watch Emails** on the bills inbox.
2. Filter for emails with PDF attachments.
3. **Airtable — Create Record** on the Bills table with Status = Received, original PDF attached, vendor email captured in a field for matching.
4. (Optional) **Slack — Post Message** to a #bills channel: "New bill received from vendor@example.com."

For the dedicated email, either set up a forwarding alias on your domain (cleanest) or use a free Mailparser/Make-provided address. We prefer the domain alias because it's part of the visible vendor process.

### Setting Up OCR

The most accurate and cost-effective options for invoice OCR in 2026:

**Mindee.** Strong pre-built invoice model. Returns structured JSON with totals, line items, vendor, tax. Free tier covers 250 documents/month. Has a direct Make module.

**Parseur.** Combines OCR with rule-based parsing. You upload a few sample invoices per vendor, and it learns the layout. More accurate for repeat vendors, less accurate for one-off ones. Has a direct Make module.

**Veryfi.** Receipt and invoice-focused, very high accuracy on standard layouts. More expensive per document.

The Make scenario continues:

5. **Mindee — Parse Invoice** (or equivalent), passing the PDF.
6. **Airtable — Update Record** with extracted data:
   - Bill Number ← parsed invoice number
   - Issue Date, Due Date
   - Total ← parsed total
   - Currency
   - Extracted Data ← full JSON for reference
7. **Search Records** on Vendors to match the vendor email. If found, link to the vendor record. If not, create a placeholder vendor record and flag for review.
8. **Update Bill Status** → Awaiting Approval.

### The Approval Routing

Add a router after extraction that branches by amount and vendor:

- Under £500 from a known vendor: auto-approve (skip approval queue, set Status = Approved).
- £500-£5,000: route to the relevant department head as Approval Owner.
- Over £5,000: route to CFO regardless of vendor.
- New vendor (no Vendor record matched): always route to manual review.

The router writes the Approval Owner field on the Bill record. An [Interface Designer](/tutorials/airtable-interface-designer-guide) page filtered to "Current User = Approval Owner" gives each person their own queue.

The approver clicks Approve or Reject. Approve triggers a final Make scenario that pushes the bill to Xero. Reject sends a notification back to whoever forwarded the invoice.

### Pushing to Xero

The final stage of the inbound flow. When a bill's Status flips to Approved:

1. **Trigger:** Airtable Watch Records, view `Ready for Xero`.
2. **Xero — Create Bill** (Type: ACCPAY) with:
   - Contact: Vendor's Xero Supplier ID
   - Date, Due Date
   - LineItems: the line items array
3. **Airtable Update:** Xero Bill ID, Status → Sent to Accounts.

## Edge Cases and Reality

A handful of things break new automations the first time.

**Duplicate vendor invoices.** Vendors sometimes resend the same invoice, or forward it twice. Add a duplicate-detection step before creating the Bill record: hash the PDF (Make has a Crypto Tools module) and check if the same hash already exists. If yes, skip and notify.

**Low-confidence OCR.** Mindee and similar tools return a confidence score per field. For any extracted Total or Vendor below 0.85 confidence, force human approval regardless of amount.

**Multi-page invoices.** Some vendor invoices span 2-3 pages of line items. Make sure your OCR tool handles all pages — Mindee does by default, some cheaper tools only read page 1.

**Currency conversions.** If you receive bills in multiple currencies, capture the currency from the OCR result and convert to your base currency for the approval threshold check. Otherwise a €10,000 bill might look like 10,000 in your base currency and slip past approval.

**Vendor variation in totals.** Some invoices show subtotal + tax + total. Others show only total. Be specific about which field your scenario relies on. Most teams use Total (gross) as the primary amount field.

**Recurring bills.** Subscriptions, retainers, and rent show up monthly with nearly identical data. Either let the same scenario process each one fresh (simplest) or detect recurring vendors and skip the OCR step using stored line items from the last bill.

## Volumes and Costs

For a small business processing 20-50 invoices/month in each direction:

| Tool                     | Approximate cost                        |
| ------------------------ | --------------------------------------- |
| Airtable Team            | $20/user/month                          |
| Make Pro                 | $19/month                               |
| Docupilot (outbound PDF) | $29/month                               |
| Mindee (inbound OCR)     | Free up to 250/month, then per-document |
| Xero Standard            | $33/month                               |

Total: roughly $100-150/month for the full automation, comparable to one or two hours of bookkeeping time per month. The payback comes from the time you reclaim, the late-payment recovery from systematic follow-ups, and the elimination of data-entry errors.

For higher volumes (200+ invoices/month either way), the per-document OCR cost becomes material and tools like Rossum or AppZen start to make sense — they have built-in approval workflows and ERP integrations that compete with the no-code stack.

## When to Stay Manual

A few cases where automating is more trouble than it's worth:

- Under 10 invoices/month either direction. The setup time will never pay back.
- Every vendor has a wildly different invoice layout and you only see each vendor once. OCR accuracy will be poor and you'll spend more time correcting than entering manually.
- Strict compliance requirements (regulated industries) that need every invoice manually approved with an audit trail. Automation is fine, but the cost-benefit shifts toward simpler tools.

## Where to Go Next

For deeper coverage on the outbound side, our [Xero + Airtable invoice tutorial](/tutorials/creating-invoices-in-xero-with-airtable) walks through the line item iterator pattern in depth. For receivables follow-ups, the [agency receivables guide](/tutorials/agency-receivables-xero-airtable) covers the staged reminder cadence.

For Make module references, Make's [Airtable apps documentation](https://apps.make.com/airtable-modules) lists every available action with current limits.


## Sitemap

See the full [sitemap](/sitemap.md) for all pages.