Accounts Payable Management

Accounts Payable Management

Overview

Accounts payable (AP) management covers ingesting supplier invoices, matching them against purchase orders and goods receipts, scheduling payments, capturing early-payment discounts, and reconciling against the vendor ledger. For most e-commerce merchants, a dedicated AP tool or accounting software integration handles this far better than custom code.

When to Use This Skill

• When your AP team is manually keying invoices from PDFs into spreadsheets and payment delays are causing vendor friction
• When you need automated three-way matching between purchase orders, goods receipts, and invoices
• When early-payment discounts (e.g., 2/10 net 30) are being missed because payment scheduling is reactive
• When preparing for an ERP integration (NetSuite, SAP, QuickBooks) and need a clean AP data model
• When audit requirements demand an immutable record of every invoice approval, payment authorization, and GL posting

Core Instructions

Step 1: Determine your current setup and choose the right AP tool

Step 2: Connect your e-commerce platform to your AP system

Shopify

Connect Shopify to QuickBooks Online: 1. Install QuickBooks Online connector from the Shopify App Store (free, by Intuit) or use A2X (paid, more reliable for high-volume) 2. The connector syncs Shopify sales, refunds, and payouts to QuickBooks automatically 3. In QuickBooks → Expenses → Vendors, manage your supplier invoices and payment schedules 4. Enter vendor invoices manually in QuickBooks or forward supplier invoices to your QuickBooks inbox email (QuickBooks extracts invoice data via OCR)

Connect Shopify to BILL: 1. Install BILL from the Shopify App Store or connect via Zapier 2. BILL receives supplier invoices via email (forward to your BILL inbox address) 3. BILL extracts invoice data, routes for approval based on your rules, and schedules ACH or check payments 4. For Shopify inventory vendors: create purchase orders in BILL and match incoming invoices against them

WooCommerce

Connect WooCommerce to QuickBooks: 1. Install the QuickBooks Online plugin from WooCommerce.com (official extension) 2. Configure sync settings: sales orders, refunds, and fees sync automatically 3. Manage supplier invoices in QuickBooks → Expenses

Connect WooCommerce to Xero: 1. Install Xero from WooCommerce.com or use a third-party connector like WooSync or Xero for WooCommerce by Codisto 2. Xero handles AP with a built-in bills module, payment approvals, and bank reconciliation

BigCommerce

Connect BigCommerce to QuickBooks: 1. Use QuickBooks Online connector from the BigCommerce App Marketplace or A2X Accounting 2. A2X is specifically designed for e-commerce accounting and handles Shopify/WooCommerce/BigCommerce → QuickBooks sync accurately

Connect BigCommerce to NetSuite: 1. Use the NetSuite Connector from the BigCommerce App Marketplace or a middleware like Celigo or Boomi 2. NetSuite provides enterprise AP with full three-way matching, multi-entity support, and audit trails

Step 3: Set up invoice capture and approval workflows

Using BILL (best-in-class dedicated AP tool)

1. Invoice capture: Forward supplier invoices to your BILL inbox email or have suppliers submit directly via a BILL supplier portal link 2. AP inbox in BILL: Review captured invoices at BILL → Payables → Inbox; BILL's OCR extracts vendor name, invoice number, date, amount, and due date 3. Approval routing: Go to BILL → Settings → Approval Policies to configure amount-based routing:

• Under $500: auto-approve
• $500–$5,000: AP Manager approval
• $5,000–$50,000: Controller approval
• Over $50,000: CFO approval

4. Approvers receive an email with a one-click approve/reject link 5. Payment scheduling: BILL schedules payments based on vendor due dates; you can also set to pay X days before due date to capture 2/10 early discounts

Using QuickBooks Online for smaller operations

1. Go to Expenses → Vendors → [Vendor] → New Transaction → Bill 2. Enter invoice details manually or forward the invoice PDF to your QuickBooks inbox email 3. Set the due date based on vendor terms (e.g., net 30) 4. To pay: go to Expenses → Pay Bills, select invoices due, choose payment method (bank transfer, check) 5. QuickBooks tracks outstanding AP and generates an aging report (Reports → Accounts Payable Aging)

Step 4: Implement three-way matching

Three-way matching compares: the purchase order (what you ordered), the goods receipt (what you received), and the vendor invoice (what the vendor is charging).

In NetSuite:

• NetSuite handles three-way matching natively — create a PO, receive the goods (Inventory → Receive Inventory), then match the vendor bill against both; discrepancies auto-flag as exceptions

In QuickBooks:

• QuickBooks does not do three-way matching automatically
• Workflow: create a PO in QuickBooks (Expenses → Purchase Orders), receive the items in inventory, then match the bill to the PO manually
• Third-party add-on: Zahara or Lightyear add PO matching and approval automation on top of QuickBooks

In BILL:

• BILL supports PO matching — create POs in BILL, then when an invoice arrives, BILL prompts you to match it against an open PO

Step 5: Capture early-payment discounts

Common vendor terms are "2/10 net 30" — 2% discount if paid within 10 days, full amount due in 30.

In BILL: 1. In your vendor record, set payment terms to "2/10 Net 30" 2. BILL automatically flags invoices where early payment would save money 3. Go to BILL → Payables → Early Pay to see all discount opportunities sorted by savings amount

In QuickBooks: 1. When entering a vendor bill, set the payment terms to "2/10 Net 30" 2. QuickBooks calculates the discount amount automatically 3. When paying: select the bill and QuickBooks shows the discount available if paid today

Key rule: Set a weekly payment run on a fixed day (e.g., every Tuesday). Pay all invoices due in the next 10 days. This captures early discounts systematically without manual review.

Step 6: Reconcile and report

AP aging report

Run monthly to see all outstanding payables by age:

• QuickBooks: Reports → Accounts Payable Aging Summary
• BILL: Reports → AP Aging
• Xero: Reports → Aged Payables Summary

This shows you what's current, 30–60 days, 60–90 days, and 90+ days overdue.

Cash flow forecast

• QuickBooks: Reports → Cash Flow Forecast (shows projected outflows based on bill due dates)
• Float (add-on for QuickBooks/Xero): provides a more accurate 90-day cash flow forecast including AP obligations

Custom / Headless — core AP data model

// Minimal AP invoice schema for custom implementations
interface ApInvoice {
  id: string;
  vendorId: string;
  invoiceNumber: string;      // unique per vendor
  invoiceDate: Date;
  dueDate: Date;
  currency: string;           // 'USD'
  totalCents: number;
  paidCents: number;          // increments as payments are applied
  status: 'received' | 'pending_approval' | 'approved' | 'scheduled' | 'paid' | 'disputed';
  poId?: string;              // linked purchase order for matching
  earlyDiscountRate?: number; // e.g., 0.02 for 2%
  earlyDiscountDeadline?: Date;
}

// Identify invoices where early payment saves money
function findEarlyPaymentOpportunities(
  invoices: ApInvoice[],
  todayDate: Date
): { invoiceId: string; discountCents: number; deadline: Date }[] {
  return invoices
    .filter(inv => inv.status === 'approved')
    .filter(inv => inv.earlyDiscountRate && inv.earlyDiscountDeadline! > todayDate)
    .map(inv => ({
      invoiceId: inv.id,
      discountCents: Math.round(inv.totalCents * inv.earlyDiscountRate!),
      deadline: inv.earlyDiscountDeadline!,
    }))
    .sort((a, b) => b.discountCents - a.discountCents);
}

Best Practices

• Separate invoice approval from payment authorization — the person who approves an invoice should not be the person who initiates the payment; this is a basic internal control
• Run payment runs on a fixed weekly cadence — predictable payment dates reduce bank fees, simplify cash forecasting, and vendors learn to expect payment on those days
• Store original invoice PDFs for 7 years — attach the PDF to every bill in QuickBooks/BILL; required for tax audits and vendor disputes
• Send remittance advice — when paying multiple invoices in one ACH batch, email the vendor a list of which invoices were paid and for what amounts so they can reconcile their AR
• Lock invoice amounts after approval — never edit a bill's total after it's been approved; create a credit memo or debit memo for adjustments instead

Common Pitfalls

Related Skills

• @vendor-management
• @order-management-system
• @returns-refund-policy

AP Database Schema for Multi-Entity Finance Platform

Problem/Feature Description

A mid-size manufacturing company is retiring their legacy spreadsheet-based accounts payable process and migrating to a new in-house finance platform. The AP team processes hundreds of supplier invoices each month across three legal entities, each with its own bank account and chart of accounts. They need a solid PostgreSQL database schema that can support the full invoice lifecycle — from receipt through three-way matching, approval, payment scheduling, and eventual archival.

The finance controller has flagged several recurring pain points with the old system: duplicate payments from the same invoice being entered twice by different AP clerks, inability to track whether invoices were matched against purchase orders and goods receipts, no way to distinguish regular supplier invoices from credit memos (which were causing mysteriously negative balances in aging reports), and slow queries when generating monthly AP aging reports for vendors with hundreds of open invoices. The new schema must be designed to prevent these issues structurally, not just through application logic.

Output Specification

Write a single SQL file named ap_schema.sql containing the complete DDL for the accounts payable tables. The file should include all tables, constraints, and indexes needed for a production-ready AP system. Add brief comments to explain non-obvious design decisions.

Do not include application code — only SQL DDL statements.

Weekly Payment Run Automation with Discount Capture

Problem/Feature Description

A regional retail chain runs weekly payments to its 150+ active suppliers. The treasury team currently picks invoices manually each Friday, misses early-payment discounts worth tens of thousands of dollars annually, and occasionally sends payments to vendors whose bank accounts have recently changed — leading to returned ACH transactions. The CFO wants a TypeScript module that automates the weekly payment run: gather approved invoices that are due, layer in any invoices with expiring early-payment discounts, apply the discounts to the payment amounts, execute everything atomically, and notify vendors of what was paid.

The approval workflow is already in place and enforces a strict rule: whoever approves an invoice must not be the same person who kicks off the payment run. The system needs to support this separation. Additionally, to reduce fraud risk, any invoice from a vendor whose bank account details have changed recently must be held for manual verification rather than included automatically in the payment batch.

Output Specification

Write a TypeScript file named payment_run.ts that implements the following:

• getEarlyPaymentOpportunities(): Promise<DiscountOpportunity[]> — returns approved invoices eligible for early-payment discount, within the correct look-ahead window, sorted appropriately
• buildPaymentRun(options: PaymentRunOptions): Promise<string> — selects which invoices to pay (due invoices + discount-eligible invoices), applies discounts, creates the run and payment records atomically, and transitions invoice statuses
• notifyVendorsOfPayment(runId: string): Promise<void> — sends remittance communication to vendors being paid in this run

Include TypeScript interfaces for all data shapes. Add a brief DESIGN_NOTES.md file (max 1 page) explaining the key design decisions made, including how segregation of duties is enforced and how the bank account change risk is handled.

Invoice Ingestion and Three-Way Matching Engine

Problem/Feature Description

A wholesale distributor has just gone live with a new procurement system that generates structured purchase orders and goods receipt records. Their AP team is drowning in PDF invoices arriving via email from over 200 active vendors. They need a TypeScript module that can automatically ingest invoices from an email inbox, match them against the corresponding purchase orders and goods receipts, and flag discrepancies for human review — all without requiring the AP clerks to manually key in data or hunt down receipts.

The operations manager has identified a few tricky edge cases from their old system: vendors occasionally send invoices in EUR or GBP rather than USD, and in the past the team would convert to USD before saving — leading to reconciliation headaches when the conversion rate changed. Some vendors also send invoices with slightly different unit prices than the PO (e.g., a $10,001 invoice on a $10,000 PO due to rounding) that shouldn't block payment. The matching logic needs to be robust: it should compare quantities received against invoice quantities line-by-line, check for unit price consistency against the PO, and produce clear exception messages when something doesn't match. Once an invoice is approved, the record should be considered immutable — any correction must go through a formal void-and-reissue process rather than allowing quiet edits.

Output Specification

Write a TypeScript file named ap_matching.ts that implements the following functions. You do not need a working runtime — write the logic clearly enough that a reviewer can assess correctness.

• ingestInvoiceFromEmail(email: EmailMessage): Promise<void> — extracts invoice data from PDF/image attachments, resolves the vendor by email domain or extracted vendor name, flags unknown vendors for manual review, and persists the invoice with the correct due date computed from the vendor's payment terms
• performThreeWayMatch(invoiceId: string): Promise<MatchResult> — matches an invoice against its PO and goods receipt, applying appropriate tolerance logic, and returns a structured result with status and exception list
• lockInvoiceAfterApproval(invoiceId: string): Promise<void> — enforces immutability of key invoice fields post-approval

Include TypeScript interfaces for all relevant data shapes. Add inline comments explaining any non-obvious decisions in the matching logic.