The Challenge
One of our clients is a procurement organization acting as an intermediary between global enterprise buyers — such as Shell, Cargill, and others — and over 7,000 suppliers. They manage the entire Source-to-Pay lifecycle, including Punchout catalogs, RFQs, Purchase Orders, Confirmations, Invoices, Goods Receipts, and Payment Remittances.
The buyers primarily use SAP Ariba, which communicates through the CXML protocol.
The Result
- Delivered end-to-end automation of the Source-to-Pay lifecycle — including complex Punchout scenarios
- Replaced fragmented, manual ordering with error-resistant, traceable flows
- Enabled onboarding of dozens of large buyers through a config-driven architecture — no flow duplication required
- Adapted seamlessly to buyer-specific CXML quirks, legal entity logic, and evolving use cases
This integration empowered our client to operate as a fully digital procurement hub for 7,000+ suppliers and some of the world’s largest enterprises — using Celigo as a unified, extensible middleware layer between NetSuite, SAP Ariba, and the real-world complexity of B2B trade.
Deep Dive: Inside the Integration
What is CXML?
CXML (Commerce eXtensible Markup Language) is an XML-based B2B protocol used in procurement systems to standardize transactions such as orders, invoices, confirmations, and Punchout sessions. It’s widely used by platforms like SAP Ariba to facilitate electronic data interchange (EDI) between buyers and suppliers.
While CXML has a defined standard, real-world implementations vary significantly — which leads to the core technical challenges in this integration.
The Real-World Challenges
1. CXML Fragmentation and Misuse
Despite the protocol standard, each buyer can use CXML differently, including:
- Adding custom
<Extrinsic>fields with buyer-specific data structures - Using document types outside their intended scope — e.g. sending planned services as if they were unplanned
- Omitting expected fields or using structural workarounds that diverge from the standard
2. ERP-Protocol Mismatch
Our client's ERP (NetSuite) supports line-by-line transaction handling, while SAP Ariba expects document-level actions. This made order confirmations, partial updates, invoicing, and cancellations complex to align — especially for:
- Long-running service orders
- High-volume POs with 100+ lines, each with its own lifecycle
3. One Ariba Network, Many Legal Entities
Large buyers (like Shell or Cargill) often operate under a single Ariba Network ID, but represent dozens of separate legal entities across countries — e.g. 20+ companies in the Netherlands, another 20+ in the UK.
Each of these companies corresponds to a separate customer record in our client’s ERP. Every inbound and outbound document had to be:
- Correctly routed to the right customer
- Processed using entity-specific rules and settings
This required intelligent entity resolution logic to match CXML input with the correct internal context — without relying on hardcoded mappings.
Our Solution on Celigo
We designed a scalable, multi-buyer integration framework using Celigo, enabling automated document exchange and Punchout handling across the entire Source-to-Pay lifecycle.
Document Types Supported
We implemented full support for the following CXML documents:
- OrderRequest (catalog, non-catalog, planned/unplanned services)
- ConfirmOrder (line-by-line confirmations + partial updates)
- OrderChange (PO versioning / change orders)
- Invoice (Material / Service)
- Goods Receipt
- Payment Remittance
- DocumentStatusUpdate
Each document type had its own logic, including custom validation, dynamic transformations, and edge case resolution.
Buyer-Specific Logic: Configurable & Scalable
To support dozens of buyers without duplicating flows, we implemented a configuration-driven model using NetSuite customer records+saved searches and Celigo scripting.
- Each buyer (or subsidiary) had integration settings stored in NetSuite, including routing rules, field mappings, and custom behavior flags.
- In Celigo, settings and JavaScript hooks allowed flows to adapt dynamically per buyer — even within the same Ariba Network ID.
This made the solution flexible, maintainable, and ready to scale across highly variable CXML implementations.
Punchout Flow Handling
Punchout enables buyers to access a supplier’s external catalog from within their own procurement system — while maintaining full control over pricing, approvals, and process.
In our case, the Punchout process followed this flow:
- The client ERP initiated the Punchout session via SAP Ariba.
- Ariba redirected the user to the client’s Punchout website, where they could select items — often from multiple underlying suppliers.
- The selected items were returned to the ERP as a Purchase Requisition (PR).
- Once approved, the PR was converted into a Purchase Order (PO) and sent to Ariba.
Celigo then processed the inbound PO CXML, performing the following:
- Extracted embedded Punchout session metadata
- Fetched Punchout Order data during processing of the flow
- Linked the order back to the original Punchout session — completing the full traceable cycle from selection to order