Celonis Learning Path

Process Analytics & Knowledge Model

Object-Centric Process Mining Mastery

📊
Data Integration
🔗
Objects & Events
⚙️
Advanced Topics
🎯
Best Practices

Training Package · 2026

Training Objectives

What to expect from this day

🎯 Focus

  • Deepen technical terms and concepts of Celonis
  • Discuss real scenarios already faced by the MPWA team
  • Practice directly in the environment already connected to SAP

🛠️ Format

  • Short presentations + Guided Hands-On
  • New Space exclusive for the training
  • Open discussions based on real Context Points

Agenda

Outline of the day

  1. Introduction to Process Mining & OCPM
  2. Data Integration — advanced topics (Sharing, Delta, Replication Cockpit)
  3. Objects & Events — modeling, Foreign Keys, Overwrites, Versions, and Perspectives
  4. Troubleshooting — common errors in Objects, Transformations, Perspectives, and Views
  5. PQL & Views — differences from SQL, essential commands, and performance cheats
  6. Action Flows — orchestration and integrations (specific reinforcement)
  7. Process Orchestration — Orchestration Engine, Forms, Events & end-to-end automation
  8. Wrap-up & Q&A
01

Process Mining & OCPM

A brief and direct introduction

From Case-Centric to Object-Centric

The conceptual shift in one picture

Before Case-Centric

1 case = 1 linear timeline of events.

  • Forces you to pick one perspective (e.g., the PR)
  • Other related entities (POs, GRs, Invoices) are flattened or lost
  • Works well when the process really is linear

Now Object-Centric

Multiple objects interact — each with its own life.

  • 1 PR can spawn N POs, each with N GRs and N Invoices
  • Same data, multiple lenses (PR-centric, PO-centric, Material-centric)
  • Reflects how SAP/P2P actually works

What changes in practice

When Celonis migrates from Case-Centric to OCPM

Before — Case-Centric Now — Object-Centric
Raw SAP tables (EBAN, EKKO, EKPO, MARA) Business objects with friendly names (PurchaseRequisitionItem, PurchaseOrderItem, Material)
Single Event Log — one timeline per case Process Explorer — graph with multiple object types interacting
CASE_ID as the anchor key Relationships between objects (1:N, N:M) modeled in the Knowledge Model
Locked into one perspective Same data, multiple perspectives — switch lenses without re-extracting
Custom SQL needed for cross-entity logic PU functions (PU_FIRST, PU_SUM) walk the graph automatically

The 4 layers of Celonis Platform

From raw data at the bottom, to user interaction at the top

4. STUDIO Views · Apps · Packages · Spaces
↑ Where the user interacts — dashboards, KPIs, drill-downs, action buttons
3. KNOWLEDGE MODEL Objects · Attributes · KPIs · Relationships · Augmented Attributes
↑ Business semantic layer — the "dictionary" that turns tables into meaning
2. DATA MODEL / OBJECTS & EVENTS Logical model with relationships, ready for PQL
↑ The "read model" — what PQL queries actually traverse
1. DATA POOL Extractions · Transformations · Replication · SQL
↑ Where raw data lands and gets cleaned · the foundation

Studio vocabulary — Cheat-sheet

The names you'll hear all day long

Term What it is Analogy
Space Top-level folder grouping multiple Packages Drive root / department area
Package Versioned bundle of Views, Apps, Knowledge Models & Action Flows Git repository
Knowledge Model Definition of objects, attributes, KPIs and relationships Semantic schema / dictionary
View A single screen — KPIs, charts, tables, filters Dashboard page
App Multiple Views chained with navigation rules Mini business application
Action Flow No-code automated workflow (triggers + modules) Zapier / Power Automate
Process Orchestration Engine that coordinates humans, AI, bots and Action Flows end-to-end Conductor of the orchestra

Where AI & Agents fit in

Three levels of intelligence inside the platform

🤖 Level 1 — AI in Studio (Assistive)

Celonis Assistant: generates PQL, explains KPIs, suggests visualizations.

Already available — no setup required. Helps you build faster.

🧠 Level 2 — AI Embedded in Apps (Predictive)

Action Flows with OpenAI / LLM modules · Smart Forms that pre-fill fields based on context.

Example for our app: suggest the 3 most likely Materials for each Free-Text PR — done in PQL + ML signals.

🎯 Level 3 — Agents (Autonomous)

AI that reads context, decides and acts inside Process Orchestration — with human escalation when needed.

Example: an agent that triages 80% of Free-Text PRs autonomously, only escalating ambiguous cases to a Buyer.

02

Data Integration

Advanced topics beyond the Get Data into Celonis training

Data Integration Overview

From SAP tables to Celonis objects — the pipeline journey

1. SAP TABLES
EKKO, EKPO, EBAN, MARA, LFA1... — raw transactional and master data
↓ EXTRACTOR
2. DATA POOL
Tables extracted & staged — transformations happen here (SQL, joins, cleaning)
↓ DATA MODEL RELOAD
3. DATA MODEL (Objects & Events)
Logical model ready for PQL — relationships defined, perspectives materialized
↓ KNOWLEDGE MODEL
4. KNOWLEDGE MODEL
Business semantics — attributes, KPIs, augmented data. What users see.
↓ DEPLOY
5. STUDIO (Views & Apps)
Dashboards, KPIs, drill-downs, action buttons — end-user experience

Extraction Strategies

Full, Delta, and Replication — when to use each

Type How it works When to use Precautions
FULL Re-extract entire table on each run Small master tables (T001, LFA1, MARA with filters) High cost in volume; execution window
DELTA Only new/changed records (filtered by timestamp/CHANGEDATE) Large volatile tables (EKKO, EKPO, BKPF, EBAN) Requires reliable delta column; deletes handled separately
REPLICATION Continuous / near real-time copy via Replication Cockpit Low-latency use cases; real-time monitoring Requires Replication Cockpit setup & monitoring

Pipeline Health & Governance

Replication Cockpit + Sharing — keeping the pipeline safe and collaborative

📊 Replication Cockpit

  • All tables in replication
  • Status: Healthy · Warning · Failed
  • Metrics: Last Run, Latency, Δ
  • SLA alerts · Troubleshooting

🔐 Sharing (Data Integration)

  • Share Data Pools & Transformations
  • Centralize governance
  • Permissions: read vs. edit
  • Changes via versioning
SAP
Scheduler
📥 Full/Delta
Load
💾 Data
Pool
SAP
📦 Full Load
(Init)
Real-time
Extractor
🔄 Delta
Records
📝 Change Data
Capture
Rep. Cockpit
Buffer
💾 Data
Pool

Replication Cockpit — Reading the signals

What each column tells you about pipeline health

Signal What it means How to react
Healthy Last run succeeded, latency within SLA Monitor periodically
Warning Latency above threshold OR row anomaly Check logs · validate delta column
Failed Last run errored — table is stale Open log · identify error · re-trigger
Last Run Timestamp of most recent extraction If older than SLA → check scheduler
Latency Delay between source change and Celonis High = downstream views are stale
Row Δ Variation of records since last run Sudden drop = possible filter issue

Transformations Deep Dive

Adding intelligence to raw data

🔧 What it is

  • SQL in the Data Pool
  • Runs after extraction, before Data Model
  • Can join, filter, derive columns
  • Creates the clean, business-ready tables

💡 Common patterns

  • Derived columns — CASE WHEN, COALESCE
  • Joins — enriching with master data
  • Filters — exclude test/deleted records
  • Aggregations — pre-compute expensive logic
Pattern When to use Example
CASE WHEN Conditional logic · categorization Map document types to categories
COALESCE Handle NULLs defensively COALESCE(WAERS, 'USD')
LEFT JOIN Enrich with master data EKPO LEFT JOIN MARA on MATNR
WHERE Filter before Data Model WHERE LOEKZ = ''
GROUP BY + AGG Pre-aggregate heavy logic Sum by PO Header before linking Items

Hands-On — Expose SAP Flag as Object Attribute

Adding EBAKZ (Purchase Requisition Closed) visibility for PR analytics

⚡ HANDS-ON · 20 min

Expose EBAKZ flag to Knowledge Model

  1. Replication Cockpit → verify EBAN healthy, EBAKZ present
  2. PurchaseRequisitionItem Transformation → confirm extracted:
    "EBAN"."EBAKZ" AS "IsClosed"
  3. Run transformation · validate Y vs N distribution
  4. Knowledge ModelPurchaseRequisitionItem → add attribute IsClosed (Type: String)
  5. Save → Version → Deploy
  6. Validate in PQL:
    FILTER [PurchaseRequisitionItem].[IsClosed] = 'Y'
    COUNT(DISTINCT PurchaseRequisitionItem.ID)

SAP ECC → S/4HANA Migration

What changes from a Data Integration perspective — future-proofing

  • Tables that change name or structure — e.g., BSEG/BKPF coexist with ACDOCA; MSEG with MATDOC.
  • Extractor: the S/4HANA connector already provides its own templates — pay attention to the version used today by MPWA.
  • Impact on Transformations: SELECTs need to be reviewed; old fields may become compatibility views.
  • Recommended strategy: validate end-to-end (Extractor → Data Pool → Transformations → Knowledge Model → View).
03

Objects & Events

The heart of OCPM

Objects and Events — Introduction and Context

What they are, how they relate

🧱 Object

A business entity with its own attributes.

  • PO Header, PO Item, Vendor, Material…
  • Defined by a unique key
  • Can have augmented attributes

⚡ Event

An activity/occurrence in time, linked to one or more objects.

  • Create PO, Approve, Goods Receipt…
  • Always has a timestamp
  • Defines the process variant

Relationships: Foreign Keys vs. Dedicated Tables

Modeling 1:N and M:N correctly

Scenario How to model MPWA Example
1 : N Foreign Key in "N" object PO Item → Header (FK EBELN)
M : N Dedicated table (junction) PO Item ↔ Invoice Item (junction)

1 : N — Foreign Key

PO Header EBELN (PK)
1 → N
PO Item EBELN (FK)

Simple join, no duplicates

M : N — Dedicated Table

PO Item
M ↔ M
Junction FK_POItem + FK_Inv
M ↔ M
Invoice Item

Prevents duplicates

Event Ordering & Determinism

Why timestamp alone is not enough

❌ Without sort attribute:

3 GRs at 14:30:00 → no tiebreaker → ambiguity → perspective fails

✅ With sort attribute:

3 GRs at 14:30:00 + MIGO # → deterministic → clear sequence

Sort Attribute Example Impact
❌ None 3 events, same timestamp Perspective fails
✅ Document # MIGO #5001, #5002, #5003 Deterministic order

Cardinality & Relationship Design

When to use each pattern

1:N — Foreign Key

Structure: FK in the "many" side
1 PO Header
  ├─ PO Item 1 (FK: EBELN=5001)
  ├─ PO Item 2 (FK: EBELN=5001)
  └─ PO Item 3 (FK: EBELN=5001)

M:N — Junction Table

Structure: Dedicated relationship table
PO Item ─┐
          ├─ Relationship (junction)
Invoice Item ┘
Avoids duplicates on BOTH sides

❌ Anti-pattern

FK in M:N → duplicates on "1" side → cardinality broken

Overwrites & Custom Attributes

Customizing without breaking the template

✏️ Overwrites

Override an existing attribute/event from the default template.

  • Used when the client has a specific rule
  • Preserves the link with future upgrades
  • Example: redefine what "Completed" means for a step

➕ Custom Objects/Events

New objects/events, created from scratch.

  • Client-specific, not in Marketplace
  • Requires careful cardinality modeling
  • Example: custom "Internal Approval" event

Perspectives Under the Hood

How a perspective materializes the "lens"

What a Perspective Does:

  1. Root object — picks which entity is the focus
  2. Traverses relationships — gathers context from related objects
  3. Validates cardinality — ensures 1:N and M:N are correct
  4. Materializes tables — creates flat SQL tables for PQL queries

🔍 Validations During Materialization:

Check If it fails Why it matters
1:N Card. Duplicate keys Cardinality mismatch
Event Sort Same timestamp Events can't be ordered
Junction Empty/broken M:N broken

Versions, Deploys & Perspectives

The lifecycle of Knowledge Model changes

📦 Version

Immutable snapshot of the Knowledge Model state.

  • Like a Git commit or database backup
  • Can be tested in DEV before going live
  • Traceable history of changes

🚀 Deploy

Activates a version for consumption by end-users.

  • Makes all perspectives in that version live
  • Only one active deployment per Package
  • Instant impact on all dependent views

🔄 Typical Workflow:

1. Create new version → 2. Build & Test in DEV → 3. Verify perspectives work → 4. Deploy to PROD

Augmented Attributes — Deep Dive

Extending objects with data that doesn't live in SAP

🎯 When to use

  • User decisions (triage, classification)
  • Notes, justifications, comments
  • Workflow status outside ERP

📝 Supported types

  • String — free text
  • Number — numeric
  • Enum — dropdown

💡 Augmented vs. Native

Aspect Native Augmented
Source SAP (Data Pool) Celonis only
Editable No Yes — in views
Use case Analysis & metrics Decisions & annotations

🎯 MPWA Examples

PR Item

  • Triage_Decision (Enum)
  • Buyer_Notes (String)

Purchase Order Item

  • Payment Terms Mismatch Justification (Enum)
  • Payment Terms Mismatch Comments (String)

Hands-On — Augmenting the PR Item object

Adding triage attributes so Buyers can record decisions in the View

⚡ HANDS-ON · 25 min

Add triage attributes to PR Item

  1. Open Knowledge ModelPR Item object
  2. Click Augmented Attributes tab
  3. Add Triage_Decision
    • Type: Enum
    • Values: Approve, Reject, Need Info
  4. Add Buyer_Notes
    • Type: String (multi-line)
  5. Save → VersionDeploy
  6. Validate in a View: both attributes should appear and be editable
04

Troubleshooting

The most common errors and how to solve them

Troubleshooting — Objects & Events

Symptoms, root cause, and solution

FK Conflict

📋 INV-001 12:34:56
⚠️
📋 INV-002 12:34:56

Same timestamp = FK ambiguity

Knowledge Model Lock

👨‍💻 Deploy 🚀
💥
👩‍💻 Edit ✏️

409 Conflict: concurrent access

Troubleshooting — Transformations

When the pipeline complains

-- Before (problematic)
SELECT a.id, b.name
FROM ekko a LEFT JOIN lfa1 b ON a.lifnr = b.lifnr;

-- After (defensive)
SELECT
  COALESCE(a.id, 'UNKNOWN') AS id,
  b.name
FROM ekko a LEFT JOIN lfa1 b ON a.lifnr = b.lifnr
WHERE a.id IS NOT NULL;

Troubleshooting — Perspectives

The 3 most common errors

Duplicate Keys

ID: 001
ID: 001
ID: 001
🔄

Multiple keys on "1" side

Empty Tables

No records after transformation

M:N Mismodeled

A
B
X
Y

Chaotic M:N relationships

Troubleshooting — Views

Most frequent errors in MPWA Views

Hands-On — Troubleshooting a View

Read the errors, find the root cause, fix the Free-Text Requisition Processing App

⚡ HANDS-ON · 20 min

Fix the two broken components

  1. Open the Studio — load the pre-built View Free-Text Requisition Processing App · confirm both KPI & Histogram render "Error"
  2. 🐛 Bug #1 — KPI "Free-Text PR Items"
    • Click the KPI · read the error message carefully
    • Inspect both the COUNT_TABLE(...) query and the FILTER clause
    • Hint: object names are inconsistent — one form is right, the other isn't
    • Fix & save → KPI must display a number
  3. 🐛 Bug #2 — Histogram "Days since assignment"
    • Read the error · the referenced attribute doesn't exist on the object
    • What should it measure? The histogram needs to plot how many days have elapsed since each Purchase Requisition Item was created — essentially: today's date minus creation date
    • Cross-check available attributes in the Knowledge Model — find the correct attribute name
    • Fix the reference & save → histogram renders with SLA annotations
  4. Discussion — what's the signal in each error message that pointed you to the fix? How would you avoid these bugs from the start?
05

PQL & Views

The calculation engine of Celonis

SQL Window Functions vs. PQL

How to replicate SQL window logic in Celonis

SQL Function Syntax PQL Equivalent / Workaround ⚠️ Issue
LAG (prev value) LAG(col) OVER (ORDER BY x) LAG ( column [, ORDER BY ( sort_column [sorting], ... )] [, PARTITION BY ( partition_column, ... )] [, offset ] ) ✅ Supported
ROW_NUMBER ROW_NUMBER() OVER (ORDER BY x) INDEX_ORDER ( column [, ORDER BY ( sort_column [sorting], ... )] [, PARTITION BY ( partition_column, ... )] ) ✅ Supported
RANK / DENSE_RANK RANK() OVER (ORDER BY col DESC) Manual ranking via PU_SUM ⚠️ Manual workaround needed

PU_COUNT_DISTINCT(
[APPROX|EXACT] DOMAIN_TABLE(col),
col,
col > PU_FIRST(DOMAIN_TABLE(col), col)
) + 1
Running Total SUM(col) OVER (ORDER BY x) RUNNING_SUM(col, ORDER BY x) ✅ Supported
Rolling Avg (7 days) AVG(col) OVER (ROWS BETWEEN 6 PRECEDING...) WINDOW_AVG ( column, start, end [, ORDER BY ( sort_column [sorting], ... )] [, PARTITION BY ( partition_column, ... )] ) ✅ Supported

SQL Date Functions vs. PQL

Date manipulation — native support in Celonis

SQL Function Syntax PQL Equivalent ⚠️ Difference
Truncate to Month DATE_TRUNC('month', date) ROUND_MONTH ( table.date_column ) ✅ Supported
Days Difference CURRENT_DATE - signup_date DATEDIFF ( time_unit, table.date_column1, table.date_column2 ) ✅ Same result (PQL in chosen time unit)
Extract Year/Month EXTRACT(YEAR FROM date) YEAR ( table.column ) / MONTH(date) ✅ Supported
Add Days date + INTERVAL '7 days' ADD_DAYS ( table.base_column, table.days_column ) ✅ Supported
Filter Last N Days WHERE date >= CURRENT_DATE - INTERVAL 'N days' FILTER date >= TODAY() - ADD_DAYS ( table.base_column, -N ) ✅ Supported (with negative values)
Month Relative to Event FLOOR((date - start) / 30) MONTHS_BETWEEN(date, start) ⚠️ PQL returns X.0 (float value)

PQL — Basic commands

The ones that appear in almost every view

CASE WHENConditional logic, same as SQL FILTERApplies a filter to an isolated expression PU_FIRST / PU_LASTFirst/last value of an attribute at the parent object level PU_SUM / PU_COUNTAggregations at the parent object level PU_STRING_AGGConcatenates strings (with or without DISTINCT) DOMAIN_TABLECreates a virtual table (e.g., a list of KPIs as rows) LOOKUPFinds a value in another table of the data model RUNNING_SUM / RUNNING_TOTALCumulative sum over an ordering INDEX_ORDERPosition of the record in an ordering INTERPOLATEFills missing points in time series BINDLinks a view's parameters to the PQL filter

MPWA Real Case — INDEX_ORDER

Filtering directly in Get Rows 🔗

Applied solution: use INDEX_ORDER to generate a position for each row within each category, and filter directly in the Get Rows of the Action Flow.

-- Position of the case ordered by date, within the status
INDEX_ORDER(
  "PO_Header"."Document_Date",
  "PO_Header"."Approval_Status"
)

-- In Get Rows, filter relevant records
FILTER INDEX_ORDER(...) <= 50;

MPWA Real Case — RUNNING_SUM & RUNNING_TOTAL

Accumulating over time 🔗

-- Cumulative Net Order Value by document date
RUNNING_SUM(
  "PO_Header"."Net_Order_Value",
  ORDER BY "PO_Header"."Document_Date" ASC
)

-- RUNNING_TOTAL — equivalent, with partition
RUNNING_TOTAL(
  "PO_Header"."Net_Order_Value",
  ORDER BY "PO_Header"."Document_Date" ASC,
  PARTITION BY "PO_Header"."Vendor"
)

MPWA Real Case — PU Functions + BIND

AFP View — displaying the last Invoice number 🔗

-- Last Invoice Number per PO Item, via m:n relationship
PU_LAST(
  "o_celonis_PurchaseOrderItem",
  BIND(
    "o_celonis_RelationshipThreeWayMatch",
    "o_celonis_IncomingMaterialDocumentItem"."SystemIncomingMaterialDocumentNumber"
  )
)

Why BIND? The objects PurchaseOrderItem and IncomingMaterialDocumentItem are not directly related on AccountsPayableExtension perspective, but they are indirectly related by RelationshipThreeWayMatch object (via a SQL perspective, this table is the junction table between both previous Celonis objects).

MPWA Real Case — PU_STRING_AGG_DISTINCT

Condensing data at the PO Header level

PU_STRING_AGG_DISTINCT(
  "PO_Header",
  "PO_Item"."Broad_Category",
  ', '
)

MPWA Real Case — LOOKUP

PO Terms Checker App — justification corrections 🔗

PU_LAST(
  "o_celonis_PurchaseOrder",
  LOOKUP(
    "O_CELONIS_PURCHASEORDER_AUG_BUYER_JUSTIFICATION",
    "o_custom_CelonisMembers"."NAME",
    (
      "O_CELONIS_PURCHASEORDER_AUG_BUYER_JUSTIFICATION"."CHANGED_BY",
      "o_custom_CelonisMembers"."ID"
    )
  )
)

MPWA Real Case — INTERPOLATE

Users & Value Tracking — continuous line even when granularity changes 🔗

INTERPOLATE(
  COUNT("User_Activity"."Activity_ID"),
  "User_Activity"."Activity_Date",
  '${time_range}'           
)

Performance Cheats — PQL & Views

Top tips for fast views

  1. Pre-aggregate in the Transformation whenever possible — don't leave the heavy lifting for the view.
  2. Avoid redundant FILTERS — one well-placed filter is worth more than several scattered ones.
  3. Use PARTITION BY in RUNNING_* and window functions to reduce the calculation scope.
  4. Be careful with large DOMAIN_TABLES — they explode the Cartesian product.
  5. Limit columns in analytical tables — the front-end renders everything.
  6. Cache KPIs: define KPIs in the Knowledge Model and reuse them, don't recalculate.

Hands-On — Build & Extend the Free-Text PR View

Add KPIs, an analytical table, and a detail panel for Material recommendations

⚡ HANDS-ON · 30 min

Complete the Free-Text Requisition Processing App

  1. KPI · Total value [USD] — sum of net value across all Free-Text PRs · reuse the same filter (Material_ID IS NULL, ProcessingStatus='N', DeletionIndicator IS NULL) · format as currency
  2. KPI · Approved Opportunities — count of PR Items where Triage_Decision = 'Approve' · this is the progress signal for Buyers and managers
  3. Analytical Table — list every Free-Text PR awaiting triage. Columns:
    • PR ID · Short Description · DaysSinceAssignment · ProcessingStatus
    • Triage_Decision & Buyer_Notes — make both editable (augmented attributes)
    Apply the same filter as KPI #1. Row count must match.
  4. 🔗 Detail Panel — wire it up
    • The Detail View is pre-built (Requisition details + Material recommendations cards filtered by only Materials used by POs, with SavingsPerUnit)
    • Configure row-click on the Analytical Table → opens Detail View · pass PRItemID, Unit Value, Quantity as the variables
  5. End-to-end test — open as a Buyer · click a PR · review recommendations · save the decision · confirm Approved Opportunities KPI ticks up

Hands-On — Historical context with PU_STRING_AGG_DISTINCT

Show Buyers where each recommended Material has been used recently

⚡ HANDS-ON · 25 min

Add a "Recently used in plants" attribute to the Material cards

  1. Open the Detail View built in the previous hands-on
  2. On each Material recommendation card, add a new field labeled "Recently used in plants"
  3. Use the following PQL:
    PU_STRING_AGG_DISTINCT(
      "o_celonis_Material",
      "o_celonis_PurchaseOrderItem"."CreationDate",
      ', '
    )
  4. Wrap with a FILTER so only POs from the last 90 days count:
    FILTER "o_celonis_PurchaseOrderItem"."CreationDate" >= ADD_MONTHS(TODAY(), -3);
  5. Save · open as a Buyer · confirm each card now shows the list of Plants (e.g. "Plant 1, Plant 2, Plant 5")
06

Action Flows

Specific reinforcement — orchestration and integrations

Action Flows — Recapping

What to highlight from the Process Orchestration training

🚦 Common Triggers

  • Scheduled — runs at a fixed time
  • Process Orchestration Event — triggered by an orchestration event
  • Webhook — external call

🧩 Most used modules at MPWA

  • Celonis Get Rows + PQL filters
  • HTTP to call SAP / other APIs
  • Email with tables in the body
  • Iterator to process a batch

Trigger

📊

Get Rows

📁

Operator

Hands-On — Daily digest Action Flow for Free-Text PRs

Email Buyers their Top 20 oldest PRs every morning · using INDEX_ORDER

⚡ HANDS-ON · 35 min

Build the Free-Text PR daily digest

  1. Create a new Action Flow in the training Package · trigger: Scheduled · daily 8 AM
  2. Module 1 — Celonis Get Rows · select the Free-Text PR Knowledge Model · apply the standard filter (Material_ID IS NULL, ProcessingStatus='N', DeletionIndicator IS NULL, Triage_Decision IS NULL)
  3. In the same module, add the PQL filter for Top 20 per Buyer:
    FILTER INDEX_ORDER(
      "o_celonis_PurchaseRequisitionItem"."DaysSinceAssignment" DESC,
      "o_celonis_PurchaseRequisitionItem"."BuyerID"
    ) <= 20;
  4. Module 2 — Iterator · group by Buyer email (check if "Users" object is in your Perspective)
  5. Module 3 — Aggregator (Text) · build an HTML table with: PR ID · Description · Days · Net Value
  6. Module 4 — Email · subject "You have N Free-Text PRs awaiting triage" · body = the HTML table + a deep-link to the View
  7. Test with one team email · validate Top 20 logic per Buyer
  8. Discussion — why INDEX_ORDER instead of SLICE?
07

Process Orchestration

Orchestration Engine — coordinating systems, AI agents, bots and humans end-to-end

Process Orchestration — What it is & why it matters

🧠 What it is

  • Orchestration Engine — Celonis capability to design, run and coordinate end-to-end business processes
  • Coordinates data from systems, apps, AI agents, bots and human users
  • Sits on top of the Process Intelligence Graph — the digital twin of the enterprise
  • Enables the Autonomous Enterprise: automation + human oversight

💎 Why it has value

  • Turns process insight into real action automatically
  • Frees teams from repetitive coordination work
  • Keeps humans in control on high-judgement steps (forms / approvals)
  • Uses Celonis data already extracted — no parallel stack

Process Orchestration — Core components

🧱 Process Steps

  • Containers for events and actions
  • Start Process — entry point, triggered by an event
  • Resume Process — reactivates a paused flow (e.g. after form submission)

⚡ Events

  • Triggered Events — user click, email received, vendor reply…
  • Timer Events — daily run, resume after N days
  • Completion Events — log details & pass context to next step

📋 Forms & Process Context

  • Forms — interactive UI to collect structured human input
  • Process Context — JSON object that carries data through the whole orchestration instance

🔧 Action Flows & Cloud Functions

  • Action Flows — automated workflows used as building blocks of steps
  • Cloud Functions — authenticated API calls from a step
  • Process Copilot — conversational AI inside a step

Hands-On — Free-Text PR "Need Info" orchestration

Close the loop: Buyer asks → Requester answers → Process resumes

⚡ HANDS-ON · 45 min

Build the Need-Info orchestration end-to-end

  1. Process Orchestration asset — create Free-Text PR Need-Info · trigger event: Triage_Decision changed to 'Need Info' · Deploy
  2. FormRequester Clarification Request with: PR ID (read-only), Original Description (read-only), Clarified Description (text), Suggested Material category (dropdown), Urgency (dropdown)
  3. Process Step 1 — Send Form · Action Flow:
    • Get Process ContextGet Rows (PR details)
    • Create Public Form LinkSubmit Form Draft (pre-fill PR ID & Description)
    • Send Email to Requester with the form link
  4. Resume Process step — event: Form Submitted · bind to the form link module
  5. Process Step 2 — Write back · Action Flow:
    • Read form answers from Process Context
    • Update augmented attribute Buyer_Notes on the PR Item with the clarified description + urgency
    • Reset Triage_Decision to NULL so the PR re-enters the Buyer queue
  6. End-to-end test — open a PR · set Triage_Decision = 'Need Info' · receive form email · submit · confirm the PR reappears in the Buyer queue with updated Buyer_Notes

Day's Recap

Our key takeaways

📚 Concepts

  • OCPM — modeling with objects and events
  • 1:N FK vs. M:N dedicated tables
  • Versions, Deploys, Perspectives
  • PQL vs. SQL differences
  • Process Orchestration — Engine, Steps, Events, Forms

🛠️ Hands-On — one app, end-to-end

  • Custom column on Material (Has_Active_PR_Last_90d)
  • Augmented attributes (Triage_Decision · Buyer_Notes)
  • View troubleshooting + KPIs + detail panel
  • Historical context with PU_STRING_AGG_DISTINCT
  • Daily digest Action Flow with INDEX_ORDER
  • Need-Info orchestration end-to-end

Q&A — Open Space

Which MPWA scenarios do you want to break down?

  • Any recurring error in transformations that hasn't been solved yet?
  • Any view with performance issues today?
  • Use cases for Action Flows that are in the queue?
  • Doubts about the post-migration roadmap for SAP S/4HANA?
  • Augmented attributes — other possible uses?

Thank you!

Good extractions, good deploys, and good views.