- 12 minutes to read

Order-to-Cash (O2C) Process Demo - Complete Package

This demo showcases an Order-to-Cash (O2C) business process using Nodinite Log Events and the Log API. The scenario follows a complete order lifecycle from initial customer order through final invoice, demonstrating how to log business transactions across multiple domains, systems, and services using multiple message formats (JSON, XML, flat files).

A complete, production-ready package featuring 1000 order interchanges following a probabilistic happy-path scenario, generating approximately 6,530 log events for analysis and visualization in Nodinite.

Business Context

Order-to-Cash Process: A typical enterprise integration scenario where customer orders flow through multiple business domains:

  • Sales Domain - Customer order reception and delivery confirmation
  • Planning Domain - ERP order entry and production scheduling
  • Logistics Domain - Order fulfillment and delivery
  • Finance Domain - Invoice generation and accounting

Each step generates events that create an audit trail, enable real-time monitoring, and populate the Repository Model with integration landscape metadata through Repository Binding context options.

🚀 CRITICAL: To enable automatic landscape creation from log events, the system parameter AllowRepositoryAutomapping must be set to true. This is the entire point of this demo - each log event carries a Repository Binding JSON structure that Nodinite uses to automatically build and maintain your integration landscape (systems, services, and service relations) without manual configuration.

O2C Process Milestones

The following table defines the seven key steps in the Order-to-Cash process. Each step represents a domain-specific action that generates a Log Event. The Message Type Name determines which Search Field Expressions are evaluated to extract business data.

Step # Milestone Domain Message Type Name System Service Direction
1 Order Received from Customer Sales O2C.Order.Received/1.0 Portal INT1337-RCV-Order-Incoming Receive
2 Order Entry in ERP Finished Planning O2C.Order.Entry/1.0 ERP INT1337-ENT-Order-Entry Send
3 Order Confirmation Delivered to Customer Sales O2C.Order.Confirmation/1.0 Portal INT1337-SND-Confirm-Outgoing Send
4 Order Planned Planning O2C.Order.Scheduled/1.0 ERP INT1337-PLN-Order-Scheduled Send
5 Order Completed for Transport Logistics O2C.Order.Ready/1.0 WMS INT1337-PKG-Order-Packed Send
6 Order Delivered Logistics O2C.Order.Shipped/1.0 WMS INT1337-DEL-Order-Delivered Send
7 Order Invoiced Finance O2C.Order.Invoice/1.0 ERP-Finance INT1337-INV-Order-Invoiced Send

Demo Architecture

Systems

  • Portal: Customer-facing portal where orders are received
  • ERP: Enterprise Resource Planning system handling planning and finance
  • WMS: Warehouse Management System for logistics operations
  • ERP-Finance: Finance module within ERP for invoicing

Log Agent Configuration

  • Log Agent Value Id: -5 (Custom logging agent for demo)
  • Endpoint Type Id: 60 (File-based endpoint for demo)
  • Endpoint Direction: 0 (Incoming for receive operations, 1 for send operations)

Demo Data

The demo uses realistic but minimal sample data to preserve clarity:

  • Order IDs: ORD-10001 through ORD-11000 (1000 interchanges)
  • Customer: Single customer record reused across all orders
    • Customer ID: CUST-001
    • Name: Acme Corporation
    • Email: orders@acme.example.com
  • Product: Single SKU
    • SKU: SKU-DEMO-001
    • Description: Demo Widget
    • Unit Price: USD 99.95
    • Quantity: 1
  • Currency: USD

Happy Path Assumption

All demo data follows a happy path scenario where data values remain consistent across message types:

  • Customer ID, name, and email never change
  • Order amount remains constant (USD 99.95)
  • No error states or retry scenarios (all log statuses are 0 for success, except incomplete steps which receive -1337)

Log Event Structure in This Demo

Each Log Event follows the Nodinite JSON formatted Log Event structure with:

  1. Details (mandatory fields + optional context)

    • LogAgentValueId: -5
    • EndPointName: Domain-specific endpoint name
    • EndPointUri: File-based path
    • EndPointDirection: 0 (receive) or 1 (send)
    • EndPointTypeId: 60 (file)
    • OriginalMessageTypeName: Message type from the table above
    • LogDateTime: UTC with random increments between steps

  2. Payload (Body)

    • Base64-encoded message content
    • Alternates between JSON, XML, and flat-file formats
    • All messages preserve the same business data values

  3. Context Properties

    • CorrelationId: Unique per interchange
    • FileName: Order-specific file name
    • OrderNumber: Incrementing order number
    • CustomerID: Static customer reference
    • Future: Repository Binding context options for automatic landscape creation

Demo Execution Strategy

Data Generation

A PowerShell script generates 1000 order interchanges with:

  1. Deterministic Happy Path: Each order starts at Step 1 (Order Received)
  2. Random Step Completion: Not all orders complete all 7 steps
    • Probability of progressing to next step: 90% per milestone
    • This simulates realistic business scenarios where some orders get stuck or are cancelled
  3. Incremental Order Numbers: Starting from ORD-10001, incrementing by 1
  4. Random DateTime Increments: Each step adds 0-5 minutes to simulate realistic processing time
  5. Incomplete Order Handling: The last recorded step for incomplete orders receives log status code -1337 (custom error code for this demo)

Log API Invocation

Each interchange step is sent to the Nodinite Log API with:

  • HTTP Header: x-ms-client-tracking-id = {PREFIX}-{DATEPART}-{SEQUENCE}
    • Example: PIC-20251022-0001, PIC-20251022-0002, etc. (when script runs on Oct 22, 2025)
    • {PREFIX} = Customer code (e.g., PIC)
    • {DATEPART} = Execution date in YYYYMMDD format (generated dynamically at runtime)
    • {SEQUENCE} = Order sequence number (e.g., 0001)
    • PIC = Process Interchange Correlation
  • Endpoint: REST POST to /api/v2/LogEvents
  • Authentication: API key (configured in script parameters)
  • Payload: Nodinite JSON Log Event (base64-encoded body + context)

Repository Binding Context Options (The Key to This Demo)

Each Log Event includes a Repository Binding JSON in the Context section that automatically creates the integration landscape. This is the mechanism that transforms raw log events into a documented, visualized integration landscape.

Context Key: ExtendedProperties/1.0#RepositoryBinding

Structure (for each step):

{
  "Name": "Step Description",
  "Service": {
    "Name": "INT1337-ServiceCode-Description",
    "Direction": "Receive|Send",
    "System": {
      "Name": "System Name"
    },
    "Integration": {
      "Name": "INT1337 - Order-to-Cash"
    },
    "BPMs": [
      {
        "Name": "INT1337 - Order-to-Cash Flow",
        "ArtifactRenaming": "Step Description",
        "Domain": {
          "Name": "Domain Name",
          "Index": 0
        },
        "Step": 0,
        "ServiceRelations": [
          {
            "Name": "INT1337-UpstreamService",
            "Direction": "Receive",
            "Step": -1,
            "Label": "From upstream",
            "ConnectorStyle": 1,
            "SourceAttachmentPoint": 2,
            "TargetAttachmentPoint": 0
          }
        ]
      }
    ]
  }
}

Key concepts:

  • Service: Defines this step's service (e.g., INT1337-RCV-Order-Incoming, INT1337-ENT-Order-Entry)
  • System: The system where the service runs (e.g., Portal, ERP, WMS)
  • Direction: Receive (data comes in) or Send (data goes out)
  • BPMs: Business Process Management array containing process flow metadata
  • Domain: The business domain and its index in the process flow (0=Sales, 1=Planning, 2=Logistics, 3=Finance)
  • Step: 0-based step number in the process (0 for first step, 1 for second, etc.)
  • ServiceRelations: Links to upstream services showing data flow dependency
  • ConnectorStyle: 1 = Orthogonal connector (recommended for process flows)

Processing:

When AllowRepositoryAutomapping is true, the Logging Service:

  1. Reads the Repository Binding JSON from each log event
  2. Creates or updates the Integration entity
  3. Creates or updates the Service entity with proper direction
  4. Creates or updates the System entity
  5. Creates the service relations (ServiceRelations) linking steps together based on step dependencies
  6. Assigns the Domain and step order for BPM visualization with proper connector styling

Without Repository Binding: You must manually create all systems, services, and relations in the UI
With Repository Binding: The landscape is automatically built from logging

Sample Message Formats

The following sections document sample messages for each O2C milestone. Each message uses consistent business data:

  • Customer ID: CUST-001
  • Customer Name: Acme Corporation
  • Order Amount: USD 99.95
  • Product SKU: SKU-DEMO-001

Message Format Rotation

To demonstrate Nodinite's format-agnostic capabilities:

Step Format File
1 - Order Received JSON 1-Order-Received.md
2 - Order Entry XML 2-Order-Entry.md
3 - Order Confirmation Flat File (CSV) 3-Order-Confirmation.md
4 - Order Planned JSON 4-Order-Planned.md
5 - Order Ready XML 5-Order-Ready.md
6 - Order Shipped Flat File (PSV) 6-Order-Shipped.md
7 - Order Invoiced JSON 7-Order-Invoiced.md

PowerShell Data Generation Script

A comprehensive PowerShell script automates the creation of 1000 realistic orders:

  • Location: Generate-O2C-Demo-Data.ps1
  • Documentation: Generate-O2C-Demo-Data.md
  • Generates: ~6,500 log events (1000 orders × ~6.5 steps average)
  • Features:
    • Probabilistic step completion (90% progression rate)
    • Incremental order numbers (ORD-10001 through ORD-11000)
    • Random timestamp increments (0-5 minutes per step)
    • Multi-format payloads (JSON, XML, CSV, PSV)
    • Context properties for business analytics
    • Happy-path data values (consistent customer/product)

Key Features

7-Step Order Lifecycle

# Milestone Domain System Format Status
1 Order Received Sales Portal JSON Complete
2 Order Entry Planning ERP XML Complete
3 Confirmation Sales Portal CSV Complete
4 Order Planned Planning ERP JSON Complete
5 Order Ready Logistics WMS XML Complete
6 Order Shipped Logistics WMS PSV Complete
7 Order Invoiced Finance ERP-Finance JSON Complete

Realistic Data Generation

  • 1000 orders generated with probabilistic step completion
  • 90% progression rate between steps (realistic failures)
  • ~530 orders complete all 7 steps (53% happy path)
  • ~470 orders stop at various stages (47% partial completion)
  • Incremental IDs: ORD-10001 through ORD-11000
  • Consistent data: Same customer, product, amounts across all orders

Multi-Format Support

Demonstrates Nodinite's format-agnostic capabilities:

  • JSON (Orders 1, 4, 7 - 42% of events)
  • XML (Orders 2, 5 - 29% of events)
  • Flat Files: CSV (Order 3), PSV (Order 6 - 29% of events)

Rich Context Properties

  • Correlation ID: {PREFIX}-{DATEPART}-{SEQUENCE} (stored as ApplicationInterchangeId, dynamically generated based on execution date)
    • Example: PIC-20251022-0001 when script runs on Oct 22, 2025
  • LogText: Milestone name only (e.g., "Order Received from Customer") - no order ID to avoid clutter
  • Order and customer data in Context properties
  • Business metrics for Search Field extraction
  • Repository Binding context options with complete BPM structure for automatic integration landscape creation

Technical Characteristics

Data Distribution 

Total Orders: 1,000
Total Steps: ~6,530
Complete (All 7 steps): ~530 orders (53%)
Partial (1-6 steps): ~470 orders (47%)

Order ID Range: ORD-10001 to ORD-11000
Correlation Format: {PREFIX}-{DATEPART}-{SEQUENCE}
ApplicationInterchangeId: PIC-20251022-0001 through PIC-20251022-1000 (when executed on Oct 22, 2025)
LogText: Milestone name without order ID (e.g., "Order Received from Customer")
Base Date: 2025-10-14T09:00:00Z

Message Sizes:
- Avg Log Event: 1-2 KB
- Total Dataset: 2-3 MB (JSON file)
- Generation Time: ~5-10 seconds

Processing Timing

Step Service Domain Processing Time Cumulative
1 RCV Sales 45 ms 45 ms
2 ENT Planning 156 ms 201 ms
3 SND Sales 78 ms 279 ms
4 PLN Planning 312 ms 591 ms
5 PKG Logistics 89 ms 680 ms
6 DEL Logistics 234 ms 914 ms
7 INV Finance 267 ms 1,181 ms

Total Processing Time (Happy Path): 1,181 ms (1.2 seconds per order)

Probabilistic Progression 

Step 1 (Order Received):     100%
Step 2 (Order Entry):         90%
Step 3 (Confirmation):        81% (0.90 × 0.90)
Step 4 (Order Planned):       73% (0.90³)
Step 5 (Order Ready):         66% (0.90⁴)
Step 6 (Order Shipped):       59% (0.90⁵)
Step 7 (Order Invoiced):      53% (0.90⁶)

Demo Package Structure 

Log API/Troubleshooting/Demo/
├── Overview.md                          ← YOU ARE HERE: Complete guide
├── Integration-Landscape.md             ← Systems, services, relations
├── BPM-Order-to-Cash.md                 ← Process flow & orchestration
├── Generate-O2C-Demo-Data.ps1          ← PowerShell script (generates 1000 orders)
├── Generate-O2C-Demo-Data.md           ← Script usage guide
│
└── Step Examples (7 complete steps):
    ├── 1-Order-Received.md             (JSON format, Sales domain, Portal system)
    ├── 2-Order-Entry.md                (XML format, Planning domain, ERP system)
    ├── 3-Order-Confirmation.md         (CSV format, Sales domain, Portal system)
    ├── 4-Order-Planned.md              (JSON format, Planning domain, ERP system)
    ├── 5-Order-Ready.md                (XML format, Logistics domain, WMS system)
    ├── 6-Order-Shipped.md              (PSV format, Logistics domain, WMS system)
    └── 7-Order-Invoiced.md             (JSON format, Finance domain, ERP-Finance system)

Learning Objectives

By completing this demo, you will understand:

  • ✅ JSON Log Event structure (mandatory + optional fields)
  • ✅ Multi-format message handling (JSON, XML, flat files)
  • ✅ Base64 payload encoding
  • ✅ Context property usage
  • ✅ Correlation ID patterns
  • ✅ DateTime timezone handling
  • ✅ Log Status codes
  • ✅ HTTP request structure to Log API
  • ✅ Repository Binding automation
  • ✅ BPM workflow visualization
  • ✅ End-to-end process tracing
  • ✅ Business metrics extraction

Important Implementation Details

Data Generation Options

  • DryRun mode: Generates first 2 orders only (preview)
  • ExportToFile: Saves to JSON file (no API calls)
  • Production mode: (Future enhancement) Direct Log API calls
  • Repeatability: Same random seed = same results (configurable)

Log Status Handling

  • Log Status 0: Success (all completed steps)
  • Log Status -1337: Failed/incomplete (last step of partial orders)
  • Semantic meaning: Allows you to track where orders stop in the pipeline

Correlation ID Format

  • Format: {PREFIX}-{DATEPART}-{SEQUENCE}
  • Components:
    • {PREFIX} = Customer code (e.g., PIC)
    • {DATEPART} = Execution date in YYYYMMDD format (generated dynamically when script runs)
    • {SEQUENCE} = Order sequence number (e.g., 0001)
  • Example: PIC-20251022-0001, PIC-20251022-0342, etc. (when executed on Oct 22, 2025)
  • Example: PIC-20251023-0001, PIC-20251023-0002, etc. (if executed on Oct 23, 2025)
  • Scope: All steps of an order share the same correlation ID
  • Purpose: End-to-end tracing and grouping
  • Benefit: Script is reusable on any date without code changes

Understanding the Architecture Documents

This package includes two complementary architecture documents:

Document Focus Answers
Integration-Landscape.md STRUCTURE - Systems, services, relations, contracts What systems exist? How are they connected? What services? What data flows?
BPM-Order-to-Cash.md FLOW - Process sequence, timing, probability, transitions What's the order? How long does each step take? What's the probability of completion?

How they work together: The Landscape shows all possible paths through the system. The BPM shows the actual execution flow with timing and probability. Together they answer: What landscape gets created? How is it traversed? When does each service execute? What are the expected outcomes?

Example (Order ORD-10001):

  • Landscape path: Portal (RCV) → ERP (ENT) → Portal (SND) → ERP (PLN) → WMS (PKG) → WMS (DEL) → ERP-Finance (INV)
  • BPM flow: 100% → 90% → 81% → 73% → 66% → 59% → 53% (success probability per step)
  • Result: 53% chance completes all 7 steps, 47% stops mid-process with LogStatus -1337

File Index and Quick Reference

Core Files (Required Reading)

File Purpose When to Read
Overview.md This file - Complete guide, data specs, architecture overview First - start here
Integration-Landscape.md System topology, services, relations, contracts After Overview - understand structure
BPM-Order-to-Cash.md Process flow, timing, probability, orchestration After Landscape - understand flow
Generate-O2C-Demo-Data.md PowerShell script documentation and usage Before running generator

Sample Message Files (Reference)

Step File Format Domain System
1 1-Order-Received.md JSON Sales Portal
2 2-Order-Entry.md XML Planning ERP
3 3-Order-Confirmation.md CSV Sales Portal
4 4-Order-Planned.md JSON Planning ERP
5 5-Order-Ready.md XML Logistics WMS
6 6-Order-Shipped.md PSV Logistics WMS
7 7-Order-Invoiced.md JSON Finance ERP-Finance

Implementation Files

File Purpose
Generate-O2C-Demo-Data.ps1 PowerShell script that generates 1000 orders

Reading Paths

Path 1: Understand the Architecture (30 min)

  1. Overview.md (this file)
  2. Integration-Landscape.md
  3. BPM-Order-to-Cash.md

Path 2: Learn Message Formats (45 min)

  1. Overview.md (Key Features section)
  2. Review all Steps 1-7 files

Path 3: Generate Demo Data (25 min)

  1. Overview.md (Demo Data section)
  2. Generate-O2C-Demo-Data.md

Path 4: Complete Deep Dive (2 hours)

  1. Overview.md (entire file)
  2. Integration-Landscape.md (entire file)
  3. BPM-Order-to-Cash.md (entire file)
  4. All Steps 1-7 files
  5. Generate-O2C-Demo-Data.md

Next Steps

  1. Understand Integration Landscape - Review Integration-Landscape.md for systems, services, and service relations
  2. Study the BPM Model - Examine BPM-Order-to-Cash.md for process flow, timing, and event orchestration
  3. Review Sample Messages - Examine each message format in Steps 1-7 to understand the business data structure
  4. Run the PowerShell Generator Script - Follow Generate-O2C-Demo-Data.md to create 1000 realistic O2C interchanges
  5. Analyze Results in Nodinite UI - Observe BPM visualization, Service relations, and Search Field extraction