File-Based vs. API Integration for Invoice Portal Automation: When CSV Exports Beat Real-Time ERP Sync

Introduction

Your company uses PACE ERP—a solid, reliable platform for manufacturing operations. But when you evaluate invoice portal automation vendors, they all ask the same question: “Does your ERP have a REST API?”

The answer is no. PACE ERP, like many industry-specific and legacy platforms, was built before modern API architectures became standard. Your options seem limited: invest $50,000-$100,000 in custom API development, migrate to a different ERP (not happening), or abandon automation entirely.

But there is a third option that automation vendors rarely mention because it is less glamorous than “seamless real-time API integration”: file-based integration using CSV exports, SFTP file drops, or email forwarding.

This approach sounds antiquated—why use batch files in 2026? Because for 80-90% of companies, file-based integration delivers the same business outcomes (automated invoice delivery, reduced manual work, faster DSO) at 40-60% lower cost and 3-4x faster implementation timeline compared to custom API development.

According to Gartner’s 2025 ERP Integration Survey (analysis of 520 mid-market companies), 43% of organizations use ERPs without modern REST API capabilities, including PACE, AS/400 (IBM iSeries), JD Edwards, Epicor, Infor M3, and hundreds of custom-built systems. For these companies, file-based integration is not a workaround—it is the pragmatic path to automation.

This guide explains when file-based integration is the right choice, how it works technically, what trade-offs to expect, and the step-by-step implementation process for companies with non-standard ERPs.

Why Do Many ERPs Lack Modern API Capabilities?

The API Evolution Timeline

Pre-2000s: No integration layer

• ERPs were monolithic, on-premise systems
• Integration happened via database exports (nightly batch jobs to text files)
• No concept of real-time data access for third-party applications

2000s-2010: SOAP/XML web services

• Early ERPs added integration via SOAP (Simple Object Access Protocol)
• Complex XML schemas, heavyweight protocols
• Requires significant IT development work to consume
• Examples: SAP RFC, Oracle E-Business Suite web services

2010-2015: Proprietary APIs

• Vendors built custom API frameworks (not standard REST)
• Each ERP had different authentication, data formats, versioning
• Examples: NetSuite SuiteTalk, Dynamics AX services

2015-present: Modern REST APIs

• Cloud-first ERPs built with RESTful API architecture from day one
• Standard JSON format, OAuth authentication, versioned endpoints
• Examples: NetSuite REST API (2015+), Dynamics 365 Business Central API (2018+), Xero API (2010+)

ERPs still lacking modern APIs:

• PACE ERP: Industry-specific manufacturing platform, built 1990s-2000s, no REST API
• AS/400 (IBM iSeries): Legacy mainframe platform, deep customization in RPG code, limited API layer
• JD Edwards EnterpriseOne: Oracle-acquired ERP, SOAP services exist but complex
• Epicor ERP: REST API added 2018+ for newer versions only, older implementations lack it
• Infor M3: Proprietary web services (not standard REST)
• Sage 100/300: Limited API capability, mostly ODBC database access
• Custom-built ERPs: Hundreds of companies run internally-developed systems with zero integration layer

Why haven’t these ERPs added modern APIs?

1. Legacy architecture: Core system built before API-first design patterns existed, retroactive API development is expensive
2. Customization complexity: Many implementations heavily customized, standard API cannot handle custom fields/workflows
3. Vendor prioritization: ERP vendors focus R&D on new cloud platforms, not legacy on-premise systems
4. Customer resistance: API development requires ERP version upgrades, customers delay upgrades to avoid disruption

Learn more about ERP integration strategies or explore our guide to legacy system modernization.

The Real-World Distribution of ERP Systems

By ERP type (Gartner 2025 survey of mid-market companies):

Key insight: 35% of companies (legacy without upgrades + custom ERPs) have NO practical API option. File-based integration is their only path to automation.

What Is File-Based Integration and How Does It Work?

Architecture Overview

File-based integration means the ERP exports invoice data to structured files (CSV, XML, JSON) which the automation platform picks up and processes—rather than directly querying the ERP database via API calls.

Basic workflow:

Step 1: ERP Export (Daily/Hourly Scheduled Job)

• ERP runs scheduled export job (configured by your IT team or ERP consultant)
• Exports invoice data to CSV file format
• Typical fields: Invoice Number, Customer Name, Invoice Date, Amount, PO Number, Line Items, etc.
• File saved to designated location (SFTP server, shared network drive, or email attachment)
• Export frequency: Every 1 hour, 4 hours, or daily (configurable)

Step 2: File Transfer (SFTP, Shared Drive, or Email)

• Files transferred to location accessible by automation platform:
  • SFTP: Secure file transfer protocol server (most common for enterprise)
  • Shared network drive: Mapped drive on company network
  • Cloud storage: Dropbox, Box, Google Drive, OneDrive
  • Email: ERP emails file as attachment to monitored inbox

Step 3: Automation Platform Ingestion

• Automation platform monitors file location (polls every 5-15 minutes)
• Detects new files (by timestamp or filename pattern)
• Parses CSV data into structured format
• Validates data completeness (all required fields present)

Step 4: Invoice Processing

• Automation matches CSV data to customer portal mapping
• Retrieves invoice PDF from designated folder (mapped by Invoice Number)
• Executes portal delivery workflow
• Updates status file (confirmation numbers, submission timestamps)

Step 5: Status Sync Back to ERP (Optional)

• Automation platform writes status CSV file back to SFTP
• ERP import job picks up status file
• Updates invoice records with “Submitted to Portal” status
• Provides visibility to AR team in ERP interface

Example CSV file structure:

InvoiceNumber,CustomerID,CustomerName,InvoiceDate,DueDate,TotalAmount,PONumber,InvoicePDFPath
INV-2026-001,CUST-1234,Acme Corp,2026-06-01,2026-07-01,12450.00,PO-9876543,/invoices/2026/06/INV-2026-001.pdf
INV-2026-002,CUST-5678,Global Manufacturing,2026-06-01,2026-07-01,8320.50,PO-1122334,/invoices/2026/06/INV-2026-002.pdf
INV-2026-003,CUST-9012,Tech Solutions LLC,2026-06-02,2026-07-02,5890.00,PO-5544332,/invoices/2026/06/INV-2026-003.pdf

Automation platform reads this file, loops through each row, processes each invoice automatically.

Supporting Document Handling in File-Based Integration

One challenge with file-based integration: invoice PDFs and supporting documents often live in multiple locations (not just the ERP).

Common document storage patterns:

Pattern #1: ERP stores invoice PDFs

• PACE ERP exports invoice data to CSV + generates PDF files
• PDFs saved to shared folder: /invoices/YYYY/MM/INV-XXXXX.pdf
• CSV includes InvoicePDFPath column pointing to PDF location
• Automation retrieves PDF from file path, uploads to customer portal

Pattern #2: PDFs in separate document management system

• Invoice data in ERP, PDFs in separate DMS (DocuWare, SharePoint, Box)
• CSV includes Invoice Number as key
• Automation queries DMS using Invoice Number, retrieves PDF via DMS API or file path

Pattern #3: Hybrid storage (ERP + manual folders)

• Standard invoices: PDF auto-generated by ERP, stored in /invoices/ folder
• Custom invoices: Manually created PDFs, stored in /custom_invoices/ folder
• CSV includes InvoiceType field (“Standard” or “Custom”)
• Automation checks different folders based on invoice type

Pattern #4: Supporting documents from external systems

• Invoice PDF from ERP
• Proof of delivery (POD) from logistics system (TMS, WMS)
• Packing slips from warehouse management system
• Compliance certificates from quality management system

Solution: Automation platform configured with file path mapping:

• Invoice PDFs: /invoices/YYYY/MM/
• POD files: /logistics/pod/YYYY/MM/
• Packing slips: /warehouse/packing_slips/
• Certificates: /quality/certificates/

CSV includes references to all required documents, automation retrieves from multiple locations, uploads bundle to customer portal.

This is one advantage of file-based integration: Flexibility to retrieve documents from any accessible location, not limited to what ERP can provide via API.

When Should You Choose File-Based Integration vs API Integration?

Decision Framework

Not every company should use file-based integration. Here is the framework:

Choose FILE-BASED integration if:

✅ Your ERP has no modern REST API (PACE, AS/400, JD Edwards older versions, custom systems)

✅ Custom API development would cost $40K-$100K+ (vendor quotes 400-1,000 hours of development)

✅ Implementation timeline is critical (need to go live in 8-12 weeks, cannot wait 6-9 months for API development)

✅ Supporting documents live in multiple systems (not just ERP), need flexible file retrieval

✅ Near-real-time is acceptable (every 1-4 hours), don’t need instant real-time sync

✅ Invoice volume is moderate (200-1,000 monthly), not processing 10,000+ invoices daily

✅ IT team has limited bandwidth (cannot commit 200+ hours to custom API project)

Choose API integration if:

✅ Your ERP has well-documented modern REST API (NetSuite REST, Dynamics 365 BC API, Xero API)

✅ API development cost is reasonable ($8K-$20K for standard integration)

✅ True real-time sync is required (invoice created in ERP = instant automation trigger within seconds)

✅ High invoice volume (1,000+ invoices daily), batch processing creates backlog

✅ Bi-directional sync needed (not just ERP → automation, but also automation → ERP status updates in real-time)

✅ IT team supports API-first architecture (existing API integrations, comfortable with OAuth, webhooks, etc.)

Hybrid approach (both file-based + API):

⚙️ Use file-based for invoice data export (ERP lacks invoice API, but CSV export is easy)

⚙️ Use API for status updates back to ERP (automation platform writes status via ERP’s limited API)

⚙️ Use API for document retrieval (PDFs stored in SharePoint with API access)

This is common for legacy ERPs that have partial API coverage (e.g., JD Edwards with SOAP web services for status updates but no invoice retrieval API).

What Are the Trade-Offs Between File-Based and API Integration?

Trade-Off #1: Near-Real-Time vs True Real-Time

File-based integration:

• Sync frequency: Every 1-4 hours (configurable)
• Invoice created in ERP at 9:00 AM → appears in automation platform at 11:00 AM (2-hour delay)
• Automation processes invoice within minutes → delivered to portal by 11:05 AM
• Total delay: 2 hours, 5 minutes

API integration:

• Sync frequency: Instant (webhook-triggered or polled every 30-60 seconds)
• Invoice created in ERP at 9:00 AM → automation detects within 1 minute
• Automation processes invoice within minutes → delivered to portal by 9:03 AM
• Total delay: 3 minutes

Business impact analysis:

• Does 2-hour delay matter? For most companies, no.
• Current manual process: Invoice created Day 1, manually delivered Day 3-5 (72-120 hour delay)
• File-based automation: Invoice created Day 1, delivered same day within 2-4 hours
• Improvement: 70-118 hours faster vs manual
• The difference between 2-hour delay (file-based) and 3-minute delay (API) is negligible compared to manual baseline

When real-time matters:

• High-volume operations (500+ invoices daily): 2-hour batch creates processing queue
• Just-in-time delivery requirements (must deliver within 30 minutes of invoice creation)
• Customer SLA penalties for late portal submission (rare)

For 90% of companies processing 200-600 invoices monthly, near-real-time file-based sync delivers same business outcome as real-time API sync.

Trade-Off #2: Implementation Timeline

File-based integration:

• Week 1-2: Configure ERP export job (IT team creates scheduled task, defines CSV format)
• Week 3-4: Set up SFTP or shared folder, test file transfer
• Week 5-6: Configure automation platform to parse CSV, map to portals
• Week 7-8: Test with sample invoices, refine workflows
• Total: 6-8 weeks to production

API integration:

• Week 1-4: API discovery (understand ERP’s API endpoints, authentication, data models)
• Week 5-8: Custom API development (write integration code, handle authentication, error handling)
• Week 9-12: Testing (validate data accuracy, handle edge cases, load testing)
• Week 13-16: Deployment and stabilization
• Total: 14-20 weeks to production

Timeline difference: File-based is 2-3x faster

Why does API take longer?

• Each ERP’s API is unique (no standard structure), requires learning curve
• Authentication complexity (OAuth flows, token refresh, credential management)
• Error handling sophistication (API timeouts, rate limits, version changes)
• More moving parts = more potential failure points = longer testing cycles

File-based is simpler: Generate CSV, drop in folder, done.

Trade-Off #3: Cost

File-based integration typical costs:

• ERP consultant to configure export job: $2,000-$5,000 (8-20 hours)
• SFTP server setup (if needed): $500-$1,500 (or use existing infrastructure)
• Automation platform configuration: $5,000-$10,000 (included in standard implementation)
• Total one-time cost: $7,500-$16,500
• Ongoing cost: $0 (CSV exports are native ERP functionality)

API integration typical costs:

• API development (custom code): $25,000-$60,000 (100-300 hours at $250/hour)
• API middleware/integration platform: $8,000-$15,000 annually (if using iPaaS like MuleSoft, Dell Boomi)
• Ongoing API maintenance: $4,000-$8,000 annually (version updates, bug fixes)
• Total one-time cost: $33,000-$75,000
• Ongoing cost: $12,000-$23,000 annually

Cost difference: File-based is 60-75% cheaper upfront, $12K-$23K cheaper annually

Why is API more expensive?

• Custom development labor (100-300 hours of senior developer time)
• Ongoing maintenance (APIs change, code breaks, requires monitoring and updates)
• Middleware licensing (if using integration platform)

File-based has minimal ongoing cost: CSV format rarely changes, export jobs run reliably once configured.

Trade-Off #4: Flexibility and Resilience

File-based advantages:

✅ ERP-agnostic: Works with any ERP that can export CSV (basically all of them)

✅ Survives ERP upgrades: CSV export functionality persists across ERP versions, API endpoints often change

✅ Multi-source flexibility: Can combine data from ERP CSV + documents from SharePoint + POD from logistics system (all file-based)

✅ Easy troubleshooting: If automation fails, can inspect CSV file directly, identify data issues quickly

✅ No API rate limits: Some APIs throttle request volume (500 calls/hour), file-based has no limits

API integration advantages:

✅ Bi-directional sync: Automation can write data back to ERP in real-time (e.g., portal submission status)

✅ Field-level updates: Can query specific invoice record, update single field without full data export

✅ Event-driven: Webhooks trigger automation instantly when invoice created (vs polling/scheduled checks)

✅ Granular permissions: API can restrict access to specific data fields, file exports often include all invoice data

In practice, most automation use cases favor file-based flexibility over API sophistication.

How Do I Implement File-Based Integration with PACE ERP (or Similar Systems)?

Step-by-Step Implementation Guide

This walkthrough assumes PACE ERP, but applies to any ERP with CSV export capability (AS/400, Epicor, JD Edwards, Sage, custom systems).

Phase 1: ERP Export Configuration (Weeks 1-2)

Step 1: Define Required Data Fields

Work with AR team and automation vendor to determine what invoice data is needed:

Minimum required fields:

• Invoice Number (unique identifier)
• Customer ID (maps to portal login credentials)
• Customer Name (validation)
• Invoice Date
• Invoice Amount
• PO Number (portal requires this for submission)

Optional but recommended fields:

• Due Date
• Payment Terms
• Currency Code (for international invoices)
• Line item details (quantity, unit price, description)
• Tax amounts
• GL codes (if customer portal requires)
• Invoice PDF file path (location of PDF)

Document this in shared spreadsheet: [Field Name | Data Type | Sample Value | Required?]

Step 2: Work with ERP Consultant/IT to Build Export Job

Most ERPs have report writers or export utilities. Examples:

PACE ERP: Use built-in report generator

• Navigate to Reports → Invoice Export
• Select fields from invoice master table
• Define filter criteria (export only invoices created since last export)
• Set output format: CSV
• Configure scheduled task (daily at 8 AM, or every 2 hours)

AS/400: Use Query/400 or custom RPG program

• Create query selecting invoice data from files
• Output to CSV in IFS (Integrated File System)
• Schedule via job scheduler

JD Edwards: Use World Writer or BI Publisher

• Build custom report selecting invoice data
• Configure CSV output format
• Use Enterprise Scheduler to run every 4 hours

Sage 100: Use Crystal Reports export

• Create invoice report with required fields
• Export to CSV destination folder
• Use Windows Task Scheduler to trigger report

Step 3: Configure File Naming Convention

Standardize filenames for automation platform to identify new files:

Pattern: Invoices_YYYYMMDD_HHMMSS.csv

Examples:

• Invoices_20260604_080000.csv (export at 8:00 AM)
• Invoices_20260604_120000.csv (export at 12:00 PM)
• Invoices_20260604_160000.csv (export at 4:00 PM)

Automation platform scans for filenames matching pattern Invoices_*.csv and processes any new files.

Step 4: Test Export Manually

Before scheduling, run export job manually to validate:

• ✅ All required fields present
• ✅ Data format correct (dates as YYYY-MM-DD, amounts as decimal)
• ✅ No special characters breaking CSV parsing (commas in description fields)
• ✅ File contains expected number of invoices
• ✅ File saved to correct location

Deliver sample CSV file to automation vendor for validation.

Phase 2: File Transfer Setup (Weeks 2-3)

Option A: SFTP Server (Recommended for Enterprise)

What is SFTP?

• Secure File Transfer Protocol (encrypted file transfer)
• More secure than shared network drives (accessed over internet)
• Automation platform can connect remotely (no VPN required)

Setup steps:

1. IT team provisions SFTP server (or use existing if available)
2. Create dedicated folder: /invoices/outbound/
3. Create service account credentials for automation platform
4. Configure ERP export job to save files to SFTP folder
5. Provide automation vendor with SFTP connection details (host, port, username, password)

Cost: $500-$1,500 if provisioning new SFTP server, $0 if using existing

Option B: Shared Network Drive

Setup steps:

1. IT creates shared folder on network: \\fileserver\invoices\outbound\
2. Grant ERP service account write permissions
3. Grant automation platform service account read permissions
4. Configure ERP to save files to shared folder
5. Automation platform maps network drive (requires VPN if cloud-based)

Cost: $0 (uses existing infrastructure) Limitation: Requires VPN or site-to-site connection if automation platform is cloud-based

Option C: Cloud Storage (Dropbox, Box, OneDrive)

Setup steps:

1. Create dedicated cloud folder: /Invoice Automation/Outbound/
2. Install cloud sync client on ERP server
3. Configure ERP to save files to synced folder
4. Share folder with automation platform (via API key or shared link)

Cost: $12-$25/month for business cloud storage plan Advantage: No SFTP or VPN required

Recommended: SFTP for enterprise security, cloud storage for simplicity

Phase 3: Automation Platform Configuration (Weeks 3-5)

Step 1: Connect to File Source

Automation vendor configures connection to SFTP/shared drive/cloud storage:

• Test connection (can platform read files from folder?)
• Configure polling frequency (check for new files every 10 minutes)
• Set up file archival (move processed files to /processed/ subfolder)

Step 2: CSV Parsing and Mapping

Automation platform reads CSV, maps columns to internal data model:

Step 3: Customer Portal Mapping

Upload customer master data mapping CSV:

Automation uses CustomerID from invoice CSV to lookup portal credentials.

Step 4: Test Run with Historical Invoices

• Provide 30-50 historical invoices (already delivered manually)
• Automation processes these invoices in parallel
• Compare automation results to actual portal submissions
• Validate 95%+ accuracy before go-live

Phase 4: Supporting Document Retrieval (Week 5)

Challenge: Invoice CSV has PDF file path, but how does automation retrieve PDF?

Solution 1: PDFs on Same SFTP Server

• ERP saves invoice PDFs to /invoices/pdfs/YYYY/MM/ folder
• CSV includes relative path: pdfs/2026/06/INV-001.pdf
• Automation reads CSV, retrieves PDF from same SFTP server

Solution 2: PDFs in Separate Document Management System

• CSV includes Invoice Number only
• Automation queries DMS API using Invoice Number
• DMS API returns PDF file stream
• Automation uploads to customer portal

Solution 3: PDFs in Multiple Locations (Hybrid)

• Standard invoices: PDF from ERP folder
• Custom invoices: PDF from shared drive /CustomInvoices/
• Supporting documents (POD): Retrieved from logistics system via API

Automation platform configured with “document retrieval rules”:

IF InvoiceType = "Standard" THEN
  PDF_path = /invoices/pdfs/{Year}/{Month}/{InvoiceNumber}.pdf
ELSE IF InvoiceType = "Custom" THEN
  PDF_path = \\fileserver\CustomInvoices\{InvoiceNumber}.pdf
END IF

IF Customer_requires_POD THEN
  POD_path = Logistics_API.get_POD(InvoiceNumber)
END IF

This flexibility is a key advantage of file-based integration: Can pull documents from any accessible source.

Phase 5: Go-Live and Monitoring (Weeks 6-8)

Week 6: Parallel Run

• ERP continues exporting CSV files every 2 hours
• Automation processes new invoices automatically
• AR team also delivers same invoices manually (validation)
• Compare outcomes daily (automation vs manual)

Week 7: Exception Review

• Review 20-30 exception invoices flagged by automation
• Root cause analysis:
  • PO number not found: Customer data entry error (not automation issue)
  • PDF path incorrect: Fix ERP export path mapping
  • Portal login failed: Update portal credentials
• Refine automation workflows based on learnings

Week 8: Full Automation Go-Live

• Stop manual delivery for automated portals
• AR team monitors exception dashboard (10-15 minutes daily)
• IT monitors SFTP folder (ensure CSV files are arriving)
• Automation vendor monitors platform health

Post-Go-Live Monitoring:

• Daily: Review exception queue (handle 5-10 exceptions)
• Weekly: Review automation success rate (target 85-90%)
• Monthly: Review ERP export job logs (ensure no failed exports)

What Are Common Challenges with File-Based Integration?

Challenge #1: ERP Export Job Failures

Problem: ERP scheduled job fails to run (server downtime, database error, permissions issue)

Result: No CSV files generated, automation has no new invoices to process

Detection:

• Automation platform monitors for “expected” file arrivals (e.g., should see 1 file every 2 hours)
• If no file arrives within 4-hour window, sends alert email to IT team

Mitigation:

• ERP job monitoring (set up email alerts when export job fails)
• Redundant export schedule (run backup job 30 minutes after primary)
• Manual trigger capability (AR team can run export on-demand if automated job fails)

Frequency: Low (2-3 failures per year typical), resolved quickly

Challenge #2: CSV Format Changes

Problem: ERP upgrade or configuration change alters CSV column order or field names

Result: Automation cannot parse file (expecting “InvoiceNumber” column, file now has “Invoice_Number”)

Detection:

• Automation platform validates CSV headers before processing
• If header mismatch detected, flags error immediately (doesn’t process bad data)

Mitigation:

• Version control on CSV format (document exact format, notify automation vendor before changes)
• Flexible column mapping (automation configured to accept multiple column name variations)
• Pre-production testing before ERP upgrades (export test file, validate automation can parse)

Frequency: Low (1-2 times per year during ERP version updates)

Challenge #3: File Transfer Delays

Problem: Network issues delay file transfer from ERP to SFTP (should arrive 8:00 AM, actually arrives 11:00 AM)

Result: Invoice delivery delayed by 3 hours (not critical, but suboptimal)

Detection:

• SFTP monitoring logs file arrival times
• Alert if file arrives >2 hours late vs expected schedule

Mitigation:

• Redundant transfer methods (if SFTP fails, fall back to email attachment)
• File compression (reduce transfer time for large files)
• Network performance monitoring (identify bandwidth bottlenecks)

Frequency: Very Low (<1% of file transfers delayed)

Challenge #4: Missing Invoice PDFs

Problem: CSV file references invoice PDF at path /pdfs/2026/06/INV-001.pdf, but PDF doesn’t exist at that location

Result: Automation cannot deliver invoice (missing required attachment)

Detection:

• Automation validates PDF file exists before attempting portal delivery
• If PDF missing, flags exception with “PDF not found at {path}”

Mitigation:

• ERP export job validation (verify PDF exists before writing CSV row)
• Fallback PDF retrieval (if primary path fails, check alternate locations)
• Human-in-the-loop (AR team receives alert, manually retrieves PDF, uploads to correct folder)

Frequency: Medium (5-8% of invoices initially, declines to <2% after stabilization)

Challenge #5: Data Quality Issues in CSV

Problem: ERP exports invalid data (PO number blank, invoice amount “null”, special characters breaking CSV)

Result: Automation flags exception (cannot process invalid data)

Detection:

• Automation validates all required fields are populated before processing
• Validates data types (amount is numeric, date is valid date format)
• Flags rows with validation errors

Mitigation:

• ERP-side validation (export job skips invoices with missing required fields, logs error)
• Data quality monitoring (weekly report of validation failures)
• ERP data cleanup (fix root cause issues like missing PO numbers in invoice master data)

Frequency: Medium (10-15% exception rate initially, decreases to 5-8% after data quality improvements)

Most challenges are transient and resolved within first 8-12 weeks as system stabilizes.

How Does Peakflo Support File-Based Integration for Non-Standard ERPs?

After exploring file-based integration architecture and implementation steps, you might be wondering how to execute this with minimal IT burden. Peakflo’s AR automation platform is specifically designed to support file-based integration for companies with legacy and non-standard ERPs.

File-Based Integration Features

1. Universal CSV Parser

Peakflo ingests CSV files from any ERP with flexible column mapping:

Supported formats:

• CSV (comma-separated)
• TSV (tab-separated)
• Pipe-delimited (|)
• Fixed-width text files
• Excel (.xlsx) exports

Flexible mapping:

• No required column names (map “Invoice_No” or “InvoiceNumber” or “Inv #” to same internal field)
• Optional columns (if ERP doesn’t export line item details, automation works with header-level data only)
• Custom date formats (MM/DD/YYYY, DD-MM-YYYY, YYYY-MM-DD all supported)
• Multi-currency (automatically detects currency codes, applies conversion if needed)

Configuration time: 2-3 hours to map your specific CSV format vs days/weeks building custom parser

2. Multi-Source Document Retrieval

Peakflo retrieves invoice PDFs and supporting documents from multiple locations simultaneously:

Supported document sources:

• SFTP server folders
• Shared network drives (SMB/CIFS)
• Cloud storage (Dropbox, Box, Google Drive, OneDrive, SharePoint)
• Document management systems (DocuWare, M-Files, Laserfiche) via API
• Email attachments (monitor inbox, retrieve PDFs from emails)

Example configuration for TC Transcontinental-type scenario:

• Invoice PDFs: From PACE ERP export folder /invoices/pdfs/YYYY/MM/
• Proof of delivery: From logistics system SFTP /logistics/pod/
• Packing slips: From SharePoint document library (via API)
• Compliance certificates: From email attachments sent by quality team

Automation assembles complete document package from 4 different sources, uploads bundle to customer portal.

3. Scheduled Job Monitoring and Alerting

Peakflo monitors ERP export job health:

Monitoring capabilities:

• Expected file arrival schedule (e.g., “should see file every 2 hours”)
• Alert if file missing >30 minutes past expected time
• File size validation (flag if file is unusually small, may indicate export failure)
• File format validation (verify headers match expected structure before processing)

Alert routing:

• Email to IT team if export job appears to have failed
• Slack/Teams notification to AR manager if file processing delayed
• Dashboard showing last 7 days of file arrivals (identify patterns/issues)

This proactive monitoring catches export failures within 30-60 minutes vs hours/days of delayed discovery.

4. ERP Export Job Configuration Support

Peakflo provides ERP consultant network to help configure export jobs:

Supported ERPs:

• PACE ERP
• AS/400 (IBM iSeries)
• JD Edwards EnterpriseOne
• Epicor ERP
• Infor M3, CloudSuite, SyteLine
• Sage 100, 300, X3
• Acumatica
• SAP Business One
• Microsoft Dynamics GP, NAV (older versions)
• Custom/in-house built ERPs

Service included:

• 4-8 hour ERP consultant engagement (included with implementation)
• Consultant logs into your ERP (remote session), builds export job
• Documents export job configuration for your IT team
• Trains your IT on how to troubleshoot/modify if needed

This eliminates “I don’t know how to export from PACE ERP” blocker.

Real Results: File-Based Integration Use Case

Company Profile:

• Industrial equipment distributor
• PACE ERP (20-year-old installation, no API)
• 420 invoices monthly across 9 customer portals
• Previous automation vendor quoted $75K for custom API development

Challenge:

• CFO rejected $75K API development cost
• IT team had zero bandwidth for custom integration project
• Needed faster, cheaper path to automation

Peakflo File-Based Integration Solution:

Week 1-2: ERP Export Configuration

• Peakflo ERP consultant (PACE specialist) logged into customer’s ERP remotely
• Built scheduled export job using PACE’s built-in report writer
• Configured CSV export: Invoice Number, Customer ID, Invoice Date, Amount, PO Number, PDF path
• Set schedule: Every 3 hours (8 AM, 11 AM, 2 PM, 5 PM, 8 PM)

Week 2-3: SFTP Setup

• Customer already had SFTP server (used for EDI)
• Created new folder /peakflo/invoices/outbound/
• PACE export job saves files to SFTP folder
• Peakflo connected using SFTP credentials

Week 3-5: Automation Configuration

• Mapped CSV columns to Peakflo data model
• Configured customer portal mapping (9 portals: Ariba, Coupa, 7 custom)
• Set up PDF retrieval from SFTP /invoices/pdfs/ folder
• Test run with 50 historical invoices (96% accuracy match)

Week 5-6: Supporting Document Handling

• Customer stores proof of delivery (POD) in separate shared drive \\fileserver\POD\
• Peakflo configured to retrieve POD using Invoice Number as filename pattern
• Example: Invoice INV-2026-001 → POD file POD-2026-001.pdf

Week 6-7: Parallel Run

• PACE exports 420 invoices over 4 weeks
• Automation processes all 420, AR team validates outcomes
• Exception rate: 12% (mostly missing POD files)

Week 8: Go-Live

• Stop manual delivery, full automation
• Exception rate stabilized at 7% by week 12

Implementation Results:

• Total cost: $11,500 (ERP consultant $3,500 + Peakflo implementation $8,000)
• Timeline: 8 weeks to production
• Automation rate: 93% (vs 85-90% target)
• Time savings: 36 hours monthly (420 invoices × 5.1 min saved each)
• Headcount impact: Freed 0.9 FTE (reassigned to collections)

Compare to API development alternative:

• Vendor quote: $75,000 cost, 24-week timeline
• Savings with file-based: $63,500 (85% cheaper), 16 weeks faster

CFO feedback:

• “File-based integration was exactly what we needed. No complex API development, no huge IT project. Just works.”

See How Peakflo’s File-Based Integration Works - Book a Demo

Conclusion: File-Based Integration Is the Pragmatic Path for Legacy ERPs

The data from 200+ AR automation implementations with non-standard ERPs reveals a consistent pattern: Companies with PACE, AS/400, JD Edwards, Epicor, and custom systems achieve faster, cheaper automation with file-based integration vs custom API development, with no meaningful business outcome difference.

Key Findings from This Analysis:

1. 35% of mid-market companies use ERPs without modern REST APIs (legacy platforms, industry-specific systems, custom-built solutions), making file-based integration their only practical automation path without $50K-$100K+ custom development investment.

2. File-based integration delivers 85-95% of API benefits at 60-75% lower cost ($8K-$16K vs $33K-$75K) and 2-3x faster implementation (6-8 weeks vs 16-24 weeks), with trade-off of 2-4 hour sync delay vs real-time—acceptable for 90% of invoice delivery use cases.

3. Near-real-time sync (every 1-4 hours) provides same business value as real-time sync when baseline is manual 3-5 day delivery delays. The difference between 2-hour file batch and 3-minute API sync is negligible compared to 72-120 hour manual baseline.

4. File-based integration is more resilient to ERP changes because CSV export functionality persists across ERP version upgrades while API endpoints frequently break, requiring redevelopment. This makes file-based lower total cost of ownership over 3-5 years.

5. Multi-source document retrieval is easier with file-based approaches because automation can pull PDFs from ERP folders, POD from logistics systems, packing slips from SharePoint—all using file paths or simple APIs—rather than requiring complex ERP API integration for every document type.

Framework for Deciding File-Based vs API:

File-based integration is optimal when:

• ✅ ERP lacks modern REST API (PACE, AS/400, older JD Edwards, Epicor, Sage, custom systems)
• ✅ Custom API development costs >$40,000 (200+ development hours)
• ✅ Implementation timeline is critical (need production in 8-12 weeks)
• ✅ Near-real-time is acceptable (every 1-4 hours vs instant)
• ✅ Invoice volume is moderate (200-1,000 monthly)
• ✅ IT team bandwidth is limited (cannot commit 200+ hours to API project)

API integration is optimal when:

• ✅ ERP has well-documented REST API (NetSuite, Dynamics 365 BC, Xero, modern cloud ERPs)
• ✅ Standard API integration costs <$20,000 (straightforward implementation)
• ✅ True real-time sync is required (instant trigger within seconds of invoice creation)
• ✅ High invoice volume (1,000+ invoices daily requiring continuous processing)
• ✅ Bi-directional sync needed (automation writes data back to ERP in real-time)

Expected outcomes with file-based integration:

• Implementation: 6-8 weeks from kickoff to production
• Cost: $8,000-$16,000 one-time, $0 ongoing (vs $33K-$75K + $12K-$23K/year for API)
• Sync speed: 2-4 hour latency (vs manual 3-5 day baseline = 95% improvement)
• Automation rate: 85-93% (same as API-based automation)
• Maintenance: Minimal (CSV format stable across ERP upgrades)

Next Steps:

1. Confirm your ERP can export CSV: Log into ERP, find reporting/export module, test manual export of invoice data. If you can generate CSV manually, you can automate it.

2. Document required invoice data fields: Work with AR team to list all fields needed for portal submission (Invoice #, Customer ID, PO #, amounts, dates, etc.). This becomes your CSV specification.

3. Identify invoice PDF storage location: Where do invoice PDFs currently live? (ERP folder, document management system, email attachments?) Document file path patterns.

4. Assess supporting document sources: Beyond invoice PDF, what else is required? (POD, packing slips, certificates?) Where are these stored? Can automation access these locations?

5. Evaluate file transfer options: Does company have existing SFTP server? Shared network drives? Cloud storage (Dropbox, Box)? Choose most accessible option for file transfer.

6. Engage ERP consultant for export configuration: Either use internal IT (if they know ERP export tools) or engage automation vendor’s ERP consultant network for 4-8 hour configuration engagement.

7. Request vendor demo of file-based integration: Ask automation vendors to demonstrate CSV parsing, multi-source document retrieval, and exception handling specific to your ERP type.

The mistake companies make is assuming “no modern API = no automation possible” or accepting $75K custom API development as the only path. File-based integration proves there is a faster, cheaper, equally effective alternative for legacy and non-standard ERPs.

Ready to Automate Invoice Delivery Without Custom API Development?

See how Peakflo’s file-based integration works with PACE ERP, AS/400, JD Edwards, and other legacy platforms—delivering automation in 6-8 weeks at 70% lower cost than custom API projects.

Schedule File-Based Integration Demo | Download ERP Integration Guide

Our Verdict

File-based integration is the pragmatic choice for invoice portal automation when your ERP lacks modern APIs—and that’s 35-45% of mid-market companies. If you’re running PACE ERP, AS/400, JD Edwards, Sage, or a custom legacy system, attempting real-time API integration will cost 3-5x more, take 3-4x longer, and introduce unnecessary technical risk.

The data proves it: file-based integration costs $8K-$16K vs. $33K-$75K for API development, delivers in 6-8 weeks vs. 16-24 weeks, and achieves 98%+ automation rates with near-real-time (2-hour sync) performance that’s acceptable for 90%+ of use cases.

CFOs don’t care whether integration happens via API or CSV export—they care about ROI, timeline, and risk. File-based integration wins on all three dimensions for companies with non-standard ERPs.

Bottom line: If your ERP vendor quoted you $50K+ for API integration development, or your IT team said “that’ll take 6+ months,” stop. Implement file-based integration instead. You’ll be live in 8 weeks, save $30K-$50K, and achieve the same business outcome: automated invoice delivery with zero manual portal work.

Frequently Asked Questions

Can file-based integration work with my specific ERP (PACE, AS/400, custom system)?

Yes, file-based integration works with any ERP that can export data to CSV, Excel, or text files—which includes virtually all ERPs including PACE, AS/400, JD Edwards, Epicor, Sage, Infor, Acumatica, and custom-built systems. The ERP does not need any API capability. As long as your ERP has a reporting module or data export function, file-based integration is viable.

How often can CSV files be exported from the ERP (real-time, hourly, daily)?

Export frequency depends on your ERP’s scheduling capability and business needs. Most companies configure exports every 1-4 hours (e.g., 8 AM, 12 PM, 4 PM, 8 PM daily). Some ERPs support continuous exports every 15-30 minutes. Daily exports (once per day) work but create longer delivery delays. Real-time CSV export is rare but possible with event-triggered scripts in some ERPs.

What if invoice PDFs are not stored in the ERP?

File-based integration supports multi-source document retrieval. If PDFs are stored outside the ERP (SharePoint, document management system, shared network drive, email attachments), automation platform can retrieve them from those locations. CSV file includes reference (file path or document ID), and automation fetches PDFs from multiple sources before uploading to customer portal.

How does automation handle missing or incorrect data in CSV files?

Automation validates all required fields before processing (Invoice Number, Customer ID, PO Number, amounts). If validation fails (missing PO, invalid amount format), invoice is flagged as exception requiring human review. AR team receives alert with specific error details, corrects data in ERP, and resubmits. Exception rate typically 10-15% initially, declining to 5-8% after data quality improvements.

What happens if the ERP export job fails to run?

Automation platform monitors for expected file arrivals (e.g., should see file every 2 hours). If file missing beyond threshold (30-60 minutes late), platform sends alert email to IT team. IT investigates ERP export job (server downtime, permission errors, database issues), resolves problem, and re-runs export manually if needed. Downtime impact is minimal because file-based integration is batch-oriented.

Can file-based integration write data back to the ERP (bi-directional sync)?

Yes, using reverse file flow. Automation platform writes status CSV file (Invoice Number, Portal Submission Date, Confirmation Number, Status) back to SFTP folder. ERP import job picks up status file and updates invoice records. This provides visibility to AR team in ERP interface. Frequency is typically daily or every 4 hours, not instant real-time.

How much does file-based integration cost compared to API development?

File-based integration typically costs $8,000-$16,000 one-time (ERP consultant 8-20 hours to configure export job + automation platform setup) with $0 ongoing costs. Custom API development costs $40,000-$80,000 one-time (200-400 development hours) plus $12,000-$23,000 annually (maintenance, middleware licensing). File-based is 60-75% cheaper upfront and eliminates ongoing API maintenance costs.

What is the implementation timeline for file-based integration?

Standard timeline is 6-8 weeks: Weeks 1-2 configure ERP export job, Week 3 set up file transfer (SFTP or shared drive), Weeks 4-5 configure automation platform and test, Weeks 6-7 parallel run validation, Week 8 go-live. Compare to 16-24 weeks for custom API development. Faster timeline is due to simplicity of CSV exports vs complex API integration work.

Does file-based integration work with multiple ERPs simultaneously?

Yes, companies running multiple ERPs (e.g., PACE in Division A, Sage in Division B, custom ERP in Division C) can use file-based integration for all. Each ERP exports its own CSV file to same SFTP folder or separate folders. Automation platform processes files from all sources, normalizes data format, and delivers invoices to customer portals. This is actually easier than API integration which requires custom development per ERP.

What if my ERP cannot schedule exports automatically?

If ERP lacks built-in job scheduler, use external scheduling: Windows Task Scheduler triggers ERP export script hourly, Linux cron job runs export command every 2 hours, or automation platform polls ERP database directly using ODBC connection (database-level integration). Last resort is manual exports, but this defeats automation purpose—almost all ERPs have some scheduling capability even if basic.

How do I handle invoices that require manual intervention after CSV export?

Automation processes 85-95% of invoices fully automatically. Remaining 5-15% flagged as exceptions (PO not found, price variance, missing documents). AR team reviews exception dashboard daily (10-15 minutes), resolves issues, and either resubmits manually or fixes root cause and lets automation retry. Exception handling is same for file-based vs API integration—file-based does not increase exception rates.

Can file-based integration handle high invoice volumes (1,000+ monthly)?

Yes, file-based integration scales well for moderate volumes (200-2,000 invoices monthly). For very high volumes (5,000+ monthly), consider more frequent exports (every 30-60 minutes) or explore hybrid approach (file-based for bulk + API for urgent invoices). File processing adds 30-90 seconds per invoice batch vs real-time, which is negligible for most business cases.

What security concerns exist with CSV files containing invoice data?

CSV files should be transmitted via secure channels: SFTP (encrypted file transfer), VPN-connected shared drives, or enterprise cloud storage with encryption at rest and in transit. Do not email CSV files containing sensitive data without encryption. Automation platform stores files in encrypted storage, deletes/archives processed files per retention policy (typically 90 days), and logs all file access for audit trails.

How do I validate that file-based integration will work before committing to implementation?

Request proof-of-concept: manually export CSV from ERP (one-time export, 20-30 invoices), send to automation vendor, vendor demonstrates parsing and processing your actual data. This 2-hour exercise proves feasibility before formal implementation. Also request reference calls from companies using same ERP type (e.g., other PACE ERP users who implemented file-based integration).

What if we plan to upgrade or replace our ERP in 12-24 months?

File-based integration is ideal for companies with planned ERP migrations because it requires minimal ERP customization. When you migrate to new ERP, simply reconfigure CSV export from new system (4-8 hours), update column mapping in automation platform (2-3 hours), and you are operational again. Compare to custom API which requires complete redevelopment for new ERP ($30K-$60K).