The problem: 40-minute SLAs, 5-hour reconciliation
A global logistics MNC operates just-in-time wheel assembly operations for a major automotive OEM. The workflow is deceptively simple: the OEM sends a JIT call specifying which wheel assemblies are needed at the production line. The logistics team has 40 minutes to pick components from inventory, assemble the wheels, and deliver them to the line-side point.
The operational execution was efficient. The back-office reconciliation was not.
Every JIT call generates a cascade of documents: a delivery challan when parts leave the warehouse, a goods receipt when the OEM acknowledges receipt, a service invoice for the assembly work, and reconciliation records that map challans to invoices to receipts. Across 80-120 JIT calls per day, the paper trail becomes enormous.
The spreadsheet reconciliation process
Before the migration, the logistics MNC's reconciliation process worked like this: at the end of each day, a coordinator would export JIT call logs from the dispatch system, delivery challan records from the warehouse system, goods receipt data from the OEM's portal, and invoice records from the accounting system. These four data sets would be loaded into a master spreadsheet.
The coordinator then manually matched each JIT call to its delivery challan, verified that the challan quantities matched the GRN quantities, confirmed that the invoice line items matched the challan, and flagged any discrepancies — short shipments, quantity mismatches, missing GRN acknowledgements, or unbilled deliveries.
This process took 4-5 hours daily. It required a skilled coordinator who understood the relationships between documents, could spot patterns in discrepancies, and knew how to resolve common issues (partial deliveries split across multiple challans, credit notes for returned assemblies, rate revisions applied retroactively).
The reconciliation was the bottleneck. Not because the people were slow, but because four separate systems never agreed on what happened.
The architectural shift
The core insight was that reconciliation is not a downstream activity — it is a data architecture problem. When JIT calls, delivery challans, goods receipts, and invoices live in separate systems, reconciliation is inevitable. When they share a single data model, reconciliation becomes a real-time status check.
The solution was to bring all four document types into a single platform where they share the same item master, the same party records, and the same transaction references. When a JIT call is created, the system knows which items are being requested. When a delivery challan is generated against that JIT call, the system automatically links the two. When the GRN comes back from the OEM, it is matched against the challan. When the invoice is raised, it references the challan and GRN.
Each document in the chain carries a reference to its parent. The reconciliation — checking that every JIT call has a challan, every challan has a GRN, and every GRN has an invoice — becomes a database query, not a spreadsheet exercise.
The JIT dispatch workflow
The new system works in real time. Here is the flow for a single JIT call:
- JIT call received: The OEM's production system sends a call specifying part numbers, quantities, and the delivery window. The system creates a JIT Call record and starts a 40-minute countdown timer.
- BOM explosion: The system looks up the bill of materials for each requested assembly, checks component availability, and flags any shortages immediately — before the operator starts picking.
- Dispatch and challan: When the operator confirms dispatch, the system generates a delivery challan automatically. The challan references the JIT call, carries the exact quantities dispatched, and updates inventory in real time.
- GRN matching: When the OEM acknowledges receipt (via their portal or a scan at the receiving dock), the GRN is matched against the open challan. Quantity discrepancies are flagged immediately — not at end-of-day.
- Invoice generation: Service invoices are generated based on confirmed GRNs. The invoice references the challan, the GRN, and the original JIT call. Billing rates come from the contract master — no manual rate lookup.
At any point in this workflow, a coordinator can see the status of every JIT call: dispatched but not received, received but not invoiced, invoiced but not paid. The reconciliation view is a dashboard, not a spreadsheet.
Handling the edge cases
Real logistics operations are messy. The system handles the edge cases that made manual reconciliation so time-consuming:
- Partial deliveries: A single JIT call can generate multiple challans (e.g., when inventory is split across warehouse locations). Each challan links back to the parent JIT call, and the system tracks fulfilment percentage automatically.
- Short receipts: If the OEM receives 95 of 100 units, the GRN records the actual quantity. The system flags the 5-unit shortfall and creates a pending investigation record.
- Returnable assets: Wheel assemblies are delivered on returnable trolleys. The system tracks trolley movements — how many went out, how many came back, how many are overdue — as a parallel ledger.
- Rate revisions: When the OEM revises assembly rates (quarterly or annually), the system applies the new rates to all invoices generated after the effective date. Retrospective adjustments generate credit or debit notes automatically.
- OEM stock: Some components are consignment stock owned by the OEM but stored at the logistics MNC's facility. The system maintains separate inventory ledgers — operator-owned and OEM-owned — on the same items.
The results
The migration from spreadsheet-based reconciliation to an integrated platform produced measurable results within the first month of operation:
- Reconciliation time: From 4-5 hours per day to approximately 40 minutes. The remaining 40 minutes are spent reviewing exception reports, not performing manual matching.
- Discrepancy detection: Issues that previously surfaced at end-of-day (or end-of-week) are now flagged in real time — within minutes of the GRN being entered.
- Invoice accuracy: Manual invoice errors dropped to near zero because invoices are generated from system data, not from manually reconciled spreadsheets.
- SLA compliance visibility: The 40-minute SLA is now tracked with live countdown timers. Historical SLA compliance data is available for any date range, any shift, any part category.
- Audit readiness: Every transaction carries a complete audit trail — who created it, when, against which parent document, and what changes were made. Audit preparation went from a multi-day exercise to a report export.
The broader lesson
This reconciliation problem was not unique. Any operation that generates linked documents across multiple parties — purchase orders and invoices, work orders and quality inspections, dispatch notes and proof-of-delivery — faces the same challenge. When documents live in separate systems, someone has to reconcile them manually.
The solution is not better spreadsheets or smarter macros. It is an architecture where related documents share a data model and maintain references to each other. The reconciliation then becomes what it should be: a status check, not a full-time job.