What is ReIM?

When a retailer orders merchandise from a supplier, three critical financial documents are created at different points in time:

1. The Purchase Order (PO): Created in RMS by the buyer — "We want 1,000 units of Item X at $10.00 each."
2. The Goods Receipt: Created in RMS when the warehouse or store physically receives the shipment — "We actually received 980 units."
3. The Supplier Invoice: Sent by the supplier — "Please pay us $10,200.00 for 1,000 units at $10.20 each."

Notice the discrepancies? The PO says 1,000 units at $10.00. The receipt says 980 units. The invoice says 1,000 units at $10.20. Who is right? How much should the retailer actually pay?

Oracle Retail Invoice Matching (ReIM) is the system that resolves these discrepancies automatically. It performs a three-way match between the PO, the receipt, and the invoice, applies configurable tolerance rules, and either auto-approves the invoice for payment or routes it for manual review.

The Three-Way Match

The three-way match is the fundamental operation that ReIM performs. It compares three sources of truth:

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│  PURCHASE    │     │   GOODS      │     │  SUPPLIER    │
│  ORDER       │     │   RECEIPT    │     │  INVOICE     │
│              │     │              │     │              │
│ Item: X      │     │ Item: X      │     │ Item: X      │
│ Qty: 1,000   │     │ Qty: 980     │     │ Qty: 1,000   │
│ Cost: $10.00 │     │ Received OK  │     │ Cost: $10.20 │
│              │     │              │     │              │
│ EXPECTED     │     │ ACTUAL       │     │ CLAIMED      │
└──────┬───────┘     └──────┬───────┘     └──────┬───────┘
       │                    │                    │
       └────────────────────┼────────────────────┘
                            │
                   ┌────────▼────────┐
                   │     ReIM        │
                   │  Three-Way      │
                   │  Match Engine   │
                   │                 │
                   │ Qty Match? NO   │
                   │ (980 ≠ 1,000)   │
                   │                 │
                   │ Cost Match? NO  │
                   │ ($10.00 ≠ $10.20)│
                   └────────┬────────┘
                            │
                   ┌────────▼────────┐
                   │ Apply Tolerance │
                   │ Rules           │
                   │                 │
                   │ Within limits?  │
                   │ YES → Auto-pay  │
                   │ NO → Manual     │
                   │      Review     │
                   └─────────────────┘

Match Types

ReIM supports several matching strategies:

Invoice Processing Data Flow

How Invoices Enter the System

Supplier invoices arrive in ReIM through several channels:

1. EDI (Electronic Data Interchange): The most common method for large retailers. Invoices arrive as EDI 810 documents, which are automatically parsed and loaded into ReIM staging tables.
2. Manual Entry: For smaller suppliers without EDI capability, accounts payable clerks manually enter invoice details into the ReIM web UI.
3. Evaluated Receipts Settlement (ERS): In an ERS model, ReIM automatically generates a "self-billed" invoice based on the receipt. The retailer pays what it received at the PO cost, without waiting for the supplier's invoice.

The Processing Pipeline

1. Invoice arrives (via EDI or manual entry) and is loaded into IM_DOC_HEAD / IM_DOC_DETAIL
2. Matching engine compares invoice lines against PO lines and receipt records
3. Tolerance check evaluates cost and quantity variances against configured thresholds
4. Auto-resolution applies rules for variances within tolerance
5. Routing sends out-of-tolerance items to the appropriate reviewer's worklist
6. Approval triggers payment release to Accounts Payable
7. Debit/Credit memo generation for over/underpayments

The ReIM Database Schema

SELECT 
    idh.doc_id,
    idh.supplier,
    s.sup_name,
    idh.invoice_no,
    idh.invoice_date,
    idh.total_cost       AS invoice_total,
    idh.status,
    TRUNC(SYSDATE) - idh.invoice_date AS days_outstanding,
    COUNT(idd.detail_id) AS line_count
FROM 
    im_doc_head idh
JOIN 
    sups s ON idh.supplier = s.supplier
JOIN 
    im_doc_detail idd ON idh.doc_id = idd.doc_id
WHERE 
    idh.status IN ('NEW', 'UNMATCHED')
    AND idh.invoice_date < TRUNC(SYSDATE) - 7
GROUP BY 
    idh.doc_id, idh.supplier, s.sup_name,
    idh.invoice_no, idh.invoice_date, 
    idh.total_cost, idh.status
ORDER BY 
    days_outstanding DESC;

Tolerance Rules

Tolerance rules are the mechanism by which ReIM decides whether a discrepancy is acceptable or requires human intervention. They are configured per supplier, per item category, or globally.

Cost Tolerance Example

A retailer configures: "Accept cost variances up to 2% or $0.50, whichever is greater."

Quantity Tolerance Example

A retailer configures: "Accept quantity variances up to 5% of the PO quantity."

Discrepancy Resolution

When a match fails the tolerance check, the discrepancy enters the ReIM Worklist for manual resolution. Reviewers have several options:

1. Accept Vendor Cost: Pay what the vendor invoiced (useful when the PO cost was genuinely wrong — e.g., a price increase notification was not applied to the PO).
2. Accept PO Cost: Pay the original PO cost and generate a Debit Memo to the supplier for the overcharge.
3. Accept Receipt Quantity: Pay only for the quantity actually received and generate a Debit Memo for the quantity discrepancy.
4. Split Resolution: Accept some line items and reject others on the same invoice.
5. Reject Invoice: Send the entire invoice back to the supplier for re-submission.

Debit & Credit Memos

ReIM automatically generates debit and credit memos to financially reconcile discrepancies:

Debit Memo (Retailer claims money FROM supplier):

• Supplier invoiced at $10.20 but PO says $10.00 → Debit memo for $0.20 × quantity
• Supplier invoiced 1,000 units but only 980 received → Debit memo for 20 × unit cost

Credit Memo (Retailer owes money TO supplier):

• Supplier invoiced at $9.80 but PO says $10.00 → Credit memo for $0.20 × quantity (rare — retailers usually just pay the lower amount)
• Additional freight or handling charges not on the original PO

ReIM Batch Architecture

ReIM operates on a daily batch cycle:

Integration with RMS & AP

ReIM does not operate in isolation. It has deep integration points with RMS and the corporate Accounts Payable system:

From RMS to ReIM

• Purchase Order data (PO numbers, line items, unit costs, quantities ordered)
• Receipt data (quantities received, receipt dates, warehouse/store locations)
• Supplier master data (supplier terms, payment methods, EDI capabilities)

From ReIM to Accounts Payable

• Approved invoices ready for payment with the validated amount
• Debit memos to be deducted from future payments
• Credit memos to be added to future payments
• Payment schedule based on supplier terms (Net 30, Net 60, etc.)

From ReIM Back to RMS

• Cost updates when the actual invoice cost differs from the PO cost and the retailer accepts the vendor cost, RMS updates the item's weighted average cost (WAC)