Verwandeln Sie Ihre Excel-Dateien in Entscheidungs-APIs

flowchart TB

    D["<b>Excel-Arbeitsmappe<br/>(Quellcode)"</b>]
    C["<b>CLE<br/>Decision Runtime</b>"]
    A["<b>Unternehmens-<br/>anwendungen</b>"]

    D ==> C

    A -->|"EINGABE<br/><b>  Geschäftsobjekt    <br/>(JSON)</b>"| C
    C -->|"AUSGABE<br/><b>Angereichertes Geschäftsobjekt + Entscheidungsergebnisse</b>"| A

    C:::Rose

    classDef Rose stroke-width:1px,stroke:#FF5978,fill:#FFDFE5

    style A fill:#E3F2FD
    style D fill:#FFF9C4,stroke:#D4AF37

    linkStyle 0 stroke:#D4AF37
    linkStyle 1 stroke:#000000
    linkStyle 2 stroke:#000000

/

Das Problem

Geschäftsentscheidungen verteilen sich über die gesamte Systemlandschaft

Geschäftslogik fragmentiert selten von heute auf morgen.

Eine Preisberechnung wird in ein ERP-System integriert. Eine Validierungsregel wird innerhalb eines Integrationsprozesses implementiert. Die Produktklassifizierung wird in einem PIM-System gepflegt. Zusätzliche Anforderungen tauchen in Skripten, Datenbankprozeduren oder Tabellenkalkulationen auf. Jede Änderung ist für sich genommen sinnvoll, doch im Laufe der Zeit taucht dieselbe geschäftliche Entscheidung an mehreren Stellen auf.

Mit der Weiterentwicklung der Geschäftsanforderungen müssen Teams mehrere Implementierungen derselben Entscheidung über verschiedene Anwendungen und Technologien hinweg pflegen. Kleine Änderungen werden zunehmend kostspielig, da jede Modifikation Koordination, Tests und die Bereitstellung über mehrere Systeme hinweg erfordert.

Eine einfache geschäftliche Änderung wird oft zu einem Softwareprojekt. Ein Preisfaktor ändert sich von 1,5 auf 1,55. Zunächst muss jemand ermitteln, wo diese Logik implementiert ist – sei es im Anwendungscode, in Skripten, Datenbankprozeduren oder Integrationsprozessen – dann die Auswirkungen bewerten, die Implementierung anpassen, die Änderung testen und die betroffenen Systeme neu bereitstellen. Die geschäftliche Entscheidung mag einfach sein. Die Umsetzung ist es selten.

Das Ergebnis ist bekannt:

• Einfache Änderungen werden zu langwierigen und kostspieligen IT-Projekten.
• Doppelte Geschäftslogik
• Inkonsistente Entscheidungsergebnisse
• Langsamere Änderungszyklen
• Höhere Wartungskosten
• Wachsende technische Schulden

Mit zunehmender Komplexität der Entscheidungen wird die Pflege der Logik oft schwieriger.

Die geschäftliche Entscheidung ist in wenigen Minuten getroffen. Die Umstellung der Software kann Tage oder Wochen dauern.

Die Lösung

Trennung von Geschäftsentscheidungen und Anwendungscode

CLE führt eine eigene Ausführungsschicht für Geschäftsentscheidungen ein. Anstatt Preisbildungslogik, Validierungen, Klassifizierungen und Geschäftsregeln direkt in den Anwendungscode einzubetten, werden diese Entscheidungen als eigenständige Entscheidungsmodelle verwaltet und von einer speziellen Laufzeitumgebung ausgeführt.

Anwendungen bleiben weiterhin für Daten, Workflows, Integrationen und Benutzererlebnisse zuständig, während Experten der Fachabteilungen weiterhin dafür verantwortlich sind, zu definieren, wie Entscheidungen getroffen werden sollen. CLE verbindet diese beiden Welten, indem es Entscheidungsmodelle unabhängig von den Anwendungen ausführt, die sie nutzen. So können geschäftliche Änderungen umgesetzt werden, ohne dass der Anwendungscode wiederholt geändert und neu bereitgestellt werden muss.

Anwendungen übermitteln Geschäftsobjekte als JSON. CLE wertet das entsprechende Entscheidungsmodell aus und gibt berechnete Attribute, Klassifizierungen, Validierungen und Entscheidungsergebnisse über REST-APIs zurück.

flowchart TB

    A["Unternehmensanwendungen"]
    C["CLE<br/>Contene Logic Engine<br/>Decision Runtime"]


    A ==>|"JSON-Geschäftsobject"| C
    C ==>|"JSON-Geschäftsobject + Entscheidungsergebnisse"| A

    C:::Rose

    classDef Rose stroke-width:1px,stroke:#FF5978,fill:#FFDFE5
    style A fill:#E3F2FD

    linkStyle 0 stroke:#000000
    linkStyle 1 stroke:#000000

Dadurch wird eine klare Trennung der Zuständigkeiten geschaffen und gleichzeitig sichergestellt, dass dieselben Entscheidungen in allen verbundenen Systemen einheitlich wiederverwendet werden können.

Warum klassische Rule Engines nicht ausreichen

Herkömmliche Regel-Engines basieren häufig auf Entscheidungstabellen und Regelwerken aus Bedingungen und Aktionen. Dieser Ansatz funktioniert zwar gut für relativ einfache Szenarien, doch echte Geschäftsentscheidungen bleiben selten lange so einfach.

Preisentscheidungen hängen von Kundengruppen, Produktstrukturen, Währungen, Mengenstaffeln und der Behandlung von Ausnahmen ab. Veröffentlichungsentscheidungen können von Datenqualitätsprüfungen, Vollständigkeitsbewertungen, Nachfolgebeziehungen und regulatorischen Anforderungen abhängen, während Anreicherungsentscheidungen häufig Berechnungen, Nachschläge, Validierungen und Referenzdaten kombinieren.

Im Laufe der Zeit entwickeln sich diese Entscheidungen zu miteinander verbundenen Netzwerken von Geschäftslogik und sind keine isolierten Regeln mehr. CLE wurde genau für diese Szenarien entwickelt und führt komplette Entscheidungsmodelle aus, anstatt einzelne Regeln isoliert zu bewerten.

Das sind keine einzelnen Regeln. Das sind Entscheidungsmodelle.

flowchart TD

    S["Produktstatus"]
    K["Produktkategorie"]
    P["Preise & Vertriebsfähigkeit"]
    L["Logistik"]

    B["Bilder"]
    D["Datenblätter"]
    T["Technische Merkmale"]

    B --> IQ["Informationsqualität"]
    D --> IQ
    T --> IQ

    EA["Nachfolgeprodukt"]
    SA["Ersatzprodukt"]

    EA --> ER["Nachfolge- & Ersatzlogik"]
    SA --> ER

    S --> V["Veröffentlichbarkeit des Produkts"]
    K --> V
    P --> V
    L --> V
    IQ --> V
    ER --> V

CLE führt vollständige Entscheidungsmodelle aus, die Folgendes kombinieren:

• Berechnungen
• Validierungen
• Nachschläge
• Referenzdaten
• Verschachtelte Logik
• Abhängigkeitsketten
• Abgeleitete Attribute

Anstatt isolierte Regeln auszuwerten, führt CLE miteinander verknüpfte Entscheidungsmodelle aus.

Excel ist das Modellierungswerkzeug. Nicht die Runtime.

Geschäftsentscheidungen werden selten durch eine einzelne Regel bestimmt.

Eine Veröffentlichungsentscheidung kann vom Produktstatus, der Preisgestaltung, der Logistik, der Informationsqualität, technischen Eigenschaften, Ersatzprodukten und vielen anderen miteinander verknüpften Faktoren abhängen. Im Laufe der Zeit bilden diese Abhängigkeiten eher vollständige Entscheidungsmodelle als isolierte Geschäftsregeln.

Fachabteilungen modellieren diese Beziehungen bereits in Tabellenkalkulationen. Sie verwenden Formeln, Nachschlagetabellen, Referenzdaten, Klassifizierungen und Validierungen, um zu beschreiben, wie Entscheidungen getroffen werden sollten und wie verschiedene Faktoren sich gegenseitig beeinflussen.

Anstatt eine weitere proprietäre Modellierungssprache einzuführen, nutzt CLE Excel als Entwicklungsumgebung für diese Entscheidungsmodelle.

Die Arbeitsmappe wird zur zentralen Definition des Entscheidungsmodells.

Excel ist nicht die Runtime.

CLE analysiert die Arbeitsmappe, identifiziert Abhängigkeiten und kompiliert das Entscheidungsmodell zu einem ausführbaren Abhängigkeitsgraphen. Die Arbeitsmappe bleibt die Entwicklungsumgebung, während Produktionssysteme das kompilierte Modell über APIs ausführen.

Die Excel-Arbeitsmappe ist der Source Code. CLE kompiliert daraus einen ausführbaren Dependency Graph. Der Dependency Graph ist das ausführbare Artefakt.

CLE bildet die Ausführungsebene zwischen Fachwissen und Software-Implementierung. Fachexperten pflegen die Entscheidungsmodelle, Anwendungen nutzen die Ergebnisse, und CLE sorgt dafür, dass beide Seiten voneinander unabhängig bleiben.

Anwendungen nutzen Entscheidungsergebnisse

Anwendungen übermitteln Geschäftsobjekte über REST-APIs. CLE wertet das Entscheidungsmodell aus und ergänzt das Geschäftsobjekt um berechnete Attribute und Entscheidungsergebnisse.

flowchart TB

    A["CLE Contene Logic Engine"]
    B["REST APIs"]

    A <==> B
    B <==> E["ERP"] & F["PIM"] & G["CPQ"] & H["CRM"] & I["SaaS"] & n1["Individuelle Softwarelösungen"]


    classDef Engine fill:#FFDFE5,stroke:#FF5978,color:#8E2236
    classDef Api fill:#C8E6C9,stroke:#4CAF50

    class A Engine
    class B,C Api

Anwendungen und Unternehmenssysteme beziehen Entscheidungsergebnisse über REST-APIs.

Eingabe

POST /api/decision
Content-Type: application/json

[{
  "country": "Italy",
  "weight": 205,
  "currency": "EUR",
  "requestedQuantity": 300,
  "purchasePrice": 1.35
}]

Ausgabe

HTTP 200 OK 
(zur besseren Verständlichkeit mit Anmerkungen versehen)

[{
  "country": "ITALY",       // standardisiert
  "iso_code": "IT",         // hinzugefügt
  "weight": 205,
  "weightClass": "heavy",   // hinzugefügt
  "currency": "EUR",
  "requestedQuantity": 300,
  "purchasePrice": 1.35,
  "purchaseTier": 3,        // errechnet
  "marginFactor": 1.81481,  // errechnet
  "salesPrice": 2.45        // errechnet
}]

Das Eingabeobjekt wird um zusätzliche Geschäftsattribute erweitert, wobei seine ursprüngliche Struktur erhalten bleibt.

Nachvollziehbarkeit als Grundprinzip

Geschäftliche Entscheidungen müssen oft noch lange nach ihrer Umsetzung nachvollzogen werden können. Entwickler müssen Fehler beheben, Analysten müssen sie pflegen, Support-Teams müssen sie erklären und Prüfer müssen sie verifizieren. Aus diesem Grund konzentriert sich CLE auf eine deterministische und transparente Ausführung statt auf eine undurchsichtige Regelverarbeitung.

Jede Entscheidung lässt sich zurückverfolgen auf:

• Eingabewerte
• Formeln
• Nachschlagetabellen
• Zwischenberechnungen
• Entscheidungspfade
• Geschäftsdokumentation

Dadurch können Unternehmen nicht nur nachvollziehen, welche Entscheidung getroffen wurde, sondern auch wie und warum.

Entwickelt für komplexe Unternehmensentscheidungen

CLE wurde für Unternehmensentscheidungen konzipiert, die sich schneller ändern als Anwendungs-Releases.

Typische Anwendungsfälle sind:

• Preis- und Rabattberechnung
• Produktklassifizierung
• Produktaufbereitung
• Veröffentlichungsentscheidungen für Produktdaten
• Produktkonfiguration
• Datenvalidierung
• Versandlogik
• Steuerermittlung
• Einhaltung gesetzlicher Vorschriften
• Kundenspezifische Geschäftsregeln

Überall dort, wo sich geschäftliche Entscheidungen schneller ändern als die Software, bietet CLE eine übersichtlichere Architektur.

Stateless. Lightweight. Dockerfähig.

CLE ist als leichtgewichtige Laufzeitkomponente konzipiert.

Die Laufzeitumgebung benötigt keine Datenbank für Geschäftsdaten und wertet Entscheidungsmodelle im Arbeitsspeicher aus. Entscheidungsmodelle werden über REST-APIs bereitgestellt und können von jeder Anwendung genutzt werden, die Entscheidungsergebnisse benötigt.

CLE kann zusammen mit folgenden Systemen eingesetzt werden:

• ERP-Systeme
• ERP-Systeme
• PIM-Systeme
• CPQ-Lösungen
• CRM-Plattformen
• SaaS-Anwendungen
• Individuelle Softwarelösungen

CLE läuft in Docker-Umgebungen und skaliert unabhängig von den Anwendungen, die die Entscheidungsergebnisse nutzen.

Eine Runtime für Geschäftsentscheidungen

Anwendungen sollten nicht jedes Mal neu bereitgestellt werden müssen, wenn sich eine Preisregel ändert.
Geschäftliche Entscheidungen sollten nicht systemübergreifend dupliziert werden.
Entscheidungsmodelle sollten nicht im Anwendungscode untergehen.

CLE bietet eine dedizierte Laufzeitumgebung für Geschäftsentscheidungen. Anstatt Preislogik, Validierungen, Klassifizierungen und Geschäftsregeln direkt in den Anwendungscode einzubetten, werden diese Entscheidungen als unabhängige Entscheidungsmodelle gepflegt und von einer dedizierten Laufzeitebene ausgeführt. Anwendungen nutzen die Ergebnisse, während Geschäftsexperten weiterhin die zugrunde liegende Logik pflegen. Dadurch können sich Entscheidungsmodelle und Anwendungscode unabhängig voneinander weiterentwickeln, ohne eng miteinander gekoppelt zu sein.

Einmal modellieren. Einmal kompilieren. Per API bereitstellen. Überall wiederverwenden.