Introduction and Feature Preview
With the latest release of the Process Cloud Service (17.1.3), Oracle has released a preview version of its much awaited Decision Model and Notation (DMN) engine. The DMN standard provides a powerful meta-model, notation and semantics for modeling of operational decision and business rules. It is a critical addition in the process, case and decision modeling framework providing an open standard for modeling the data and logic associated within a process.
The notation standard aims at defining requirements and decision logic for manual and automated decision-making by representing a complete, executable model which can either be used independently or in conjunction with a business process. Similar to BPMN, it aims to support designing of decision models, providing guided operational decision and potentially automation of operational decisions. A combination of process and decision modeling simplifies business processes by eliminating and replacing sections of a process model with a decision model. The decision logic of the process model is captured as a separate yet linked model. By focusing on decisions and processes independently the requirements process is more focused. A decision-driven process acts on the outcome of the evaluation of decision logic in several possible ways, including:
- Changing the sequence of activities that are taken after a decision, including what the next activity or process that is required to meet the directive of the process.
- Selecting between the paths on the diverging or the splitting side of a gateway.
- Deciding who or what participant should perform the needed activity.
- Creating data values that will be consumed later in the process.
A decision can be thought of as a meta gateway with merging inputs (events and data) and splitting outputs that direct the process in an overarching way (i.e., participants, tasks, and gateways).
Integrating business process modeling with decision modeling, as well as event processing, can create comprehensive, agile solutions that are easy to change and enhance. Without decision modeling, process modeling in BPMN can both overcomplicate a model with logic and miss critical design details. As decisions are modeled, things will be discovered that the process must do to accommodate the results of those decisions.
By associating a decision model with an activity in a business process model, it becomes an executable specification for the decision-making to be carried out in that activity. If the decision model is encapsulated in a decision service, the business process can execute the decision-making automatically at the correct point in the process. The following diagram provides a high level overview of how process and decision model can be used together.
This blog post intends to provide an introduction to the basic concepts of DMN, its constructs, illustration of a real like use case and how to get started with DMN in Oracle Process Cloud Service.
First Things First: DMN Fundamentals
The objective of a decision model is to create a shared understanding about logic, data and process that are fully traceable from business requirements to IT implementations. The Decision Modeling and Notation standard from the Object Management Group (OMG) is a notation that accomplishes these goals. The true value proposition of DMN lies in providing a common language that bridges the gap between across business, IT and analytics department within organisations, thereby improving collaboration, reuse and ability to implement accurate and consistent decision management solutions. The DMN semantics are based on the following principles:
- Bridge the gap between requirements and technical implementation by mapping graphical notation to the underlying constructs of a business rule execution environment.
- Specify standard and easy to understand decision requirements diagrams that communicates processing information.
- Link business rules and analytics to business objects in order to share and tune decision information across process implementers.
- Provide a format to share decisions and copy decision models between process improvement tools.
In the context of DMN, a Decision is an act of determining an output value, based on a number of input values, using logic defining how the output is determined from the inputs. A Decision Model is a formal model of an area of decision-making, expressed as decision requirements and decision logic. A decision model is defined in two levels, the Decision Requirements Level and the Decision Logic Level which is explained in a bit of detail here. At the decision requirements level, the notation is simple enough to make the structure of the model immediately apparent; yet, the decision logic level provides a specification of the decision-making which is precise enough to allow full automatic validation and execution.
Decision Requirements Level
The Decision Requirements Level is an abstract level of modeling comprising of a Decision Requirements Graph (DRG) represented in one or more Decision Requirements Diagrams (DRD). It defines the decisions to be made, the interrelationships, and the required components for the decision logic. The DMN decision requirements diagram is a notation depicting important elements of decision-making and their dependencies. The following table outlines the DMN decision diagram constructs, their symbols and meaning.
Decision Logic Level
A DMN diagram does not depict the decision logic of a particular decision. DMN decision logic level is used to specify a complete expression of logic, potentially sufficient for automation. Each decision in a decision model has a value expression that describes how a decision outcome is derived from its required input, possibly invoking a business knowledge model. In addition a decision logic level allows boxed expressions to be associated with elements in the decision requirements level. Boxed expressions allow the decision logic to be decomposed into small pieces that can be notated in a standard way and associated with elements at the decision requirements level. The type of DMN boxed expressions supported in Oracle PCS are:
- Function Construct – Allows creating parameterized logic that can apply multiple times to a set of input with different parameter values.
- If Then Else Construct – Decision function with three logic parts: If (Boolean test), Then (result if the test is true), and Else (result if the test is not true).
- Context Construct – Provides a mechanism to create a list of named logic elements, where logic lower in the list may reference logic results higher in the list by name.
- List Construct – This construct provides a list of independent logic elements whose output contains outputs of all logic elements.
- Relation Construct – Allows creating a relational table where each cell contains a logic element. For example, a cell in a relation construct could be a function, decision table, expression or if-then-else.
- Friendly Enough Expression Language (FEEL) – Create logic that evaluates to a single value by entering readable text.
- Decision Table – A decision table comprises of rules with tests matching input on one side and output on the other side.
A lot of the information provided above can be summarized in an easy to visualize mind map that I have created. The mind map shows a relationship between a number of DMN components across both decision requirement diagram, decision logic and decision services.
A Simple Use Case : Loan Straight Through Approval Decisioning
Imagine you are working at a bank in the personal lending fulfilment department. A customer wishes to make a request to determine his lending eligibility for a personal loan. Can you accept his request, determine and outcome and communicate to him the result? You have to make a business decision. What are the criteria for the correct decision and what information is your choice based on. The bank has standard rules and guidelines for handling the request, some of which are:
- Customers need to provide collateral for personal lending above a certain amount.
- The identity of the customer has to be properly verified
- Moreover, which type of document is allowed depends on the customer’s nationality and lending value
- Does the customer already have existing loans with the bank or other banks?
Decisions in DRD are represented by rectangles and input data by rounded rectangles. In the example DRD illustration shown below “Determine Lending Approval” is the top-level decision. “Determine Lending Eligibility” and “Determine Lending Limit” are sub decisions, the outcome of which is considered by top-level decision. They are also sub decisions because the questions they pose must be answered before the main question, “Determine Lending Approval”, is answered. The arrows depict a flow of the decisions into the top-level decision. There can also be more than one top-level decision. Third element types, called knowledge sources help us depict dependencies on policies or regulatory requirements. In this case, the “Determine Lending Limit” sub decision depends on “APRA #571.1 Revisions to Large Exposures”, a particular retail banking regulation by a financial regulatory authority. DMN diagrams provide a high-level overview of how a decision depends on other decisions, policies or regulation and input data.
As stated before a DMN diagram does not depict the decision logic of a particular decision. Decision logic specifies the details of one decision, so that it can be easily and unambiguously understood by a human. In the rest of this blog post, I will provide detailed steps through which the above decision model can be translated into a decision logic executable as a DMN decision model in Oracle PCS and subsequently exposed as a decision service to be consumed by a business process.
DMN as a first class Citizen in Oracle Process Cloud Service
If your PCS instance has been updated to 17.1.3, you can enable DMN design and runtime by navigating to Administration > UI Customization > and check Enable DMN in Composer.
Decision Model in DMN
Once the DMN editor is available in composer, you should be able to create a new Decision Model in any available project space in PCS. The decision model that I created and which will be covered here is called Lending Approval. A decision model in DMN can have more than one decisions that are based on boxed expressions with each decision taking in an input type and resulting in its own output. A decision model can also be service enabled by defining a decision service and associating one or more decisions to it. The interface of the decision service is determined by the input association and output is determined by the outputs associated with the decisions. The following illustration provides an anatomy of a DMN decision model in Oracle PCS.
Decision Tables in DMN
Let’s assume that the retail lending application use case being discussed has an overarching process model (will discuss this shortly) that allows lending approvals without any manual approvals for certain scenarios. In order to determine this, a decision model has to evaluate lending eligibility as well as calculate an approximate lending limit that can be approved for the applicant. An applicant’s personal lending request is deemed eligible if:
- It it below a threshold determined by the financial institution’s risk taking appetite for approving lending without any securities (in our example, let us assume it is 5G)
- For any lending request that is above this threshold, the applicant must have:
- A valid nationality
- A valid identification document which is verified
Finally, the decision logic behind these checks should ensure that all the above conditions are met for the lending request to be deemed eligible. If at least one condition is not met, then the lending request is denied. Once an eligibility has been determined, the decision function then also needs to calculate the maximum lending limit based on the credit information provided by the applicant.
There are a few ways in which the decision logic for the above scenario can be implemented, the most common being using a decision table. A decision table can have one or more rules where each rule contains input and output entries. The input entries are the condition and the output entries the conclusion of the rule. If each input entry (condition) is satisfied then the rule is satisfied and the decision result contains the output entries (conclusion) of this rule. A decision table also has a hit policy that specifies what the results of the evaluation of a decision table consist of. Each row in the decision table represents a rule where as the columns represent conditions. Conditions are based on input elements or expressions/functions and can be restricted to data types, list of values or ranges. A detailed visual of a decision table in DMN along with its key components is shown below with some explanatory text. If you carefully read the table it does the following:
- Sets the lending eligibility as true if the sum of current and any existing lending (denoted as aggregated sought exposure) is less than 5k.
- For any lending above the 5k threshold, the applicant needs to be Australian, have a valid identification status (Valid) and identification document (Passport, Election Card or National Identity Card) to be eligible.
When a decision is created in a decision model, it requires an input and output definition. For our example, I created a complex LendingRequest element with a few simple elements which would be used in the decision table. You can also use an existing business object for an input variable.
Creating Bucketsets in a Decision in DMN
Input expressions defined in the decision table can be bucketed as list of values or a value range to restrict the condition evaluation to a value within the bucket. This is very useful in long decision tables as it restricts users from entering invalid values that would otherwise result in an exception.
Decision Table Hit Policy
Decision tables in DMN has another very interesting feature called hit policy. A hit policy specifies how many rules of a decision table can be satisfied and which of the satisfied rules are included in the decision table result. The hit policies supported in Oracle PCS are Unique, Any and First and Collect which are described in more details in the table below.
|Hit Policy||Description||Usage Scenarios|
|Unique (Single)||Only one rule is allowed to fire for any one combination of inputs. In this context, all inputs are assumed to be independently from each other, i.e. that any combination is actually possible.||Immigration rules to determine if a person should be allowed a visa or be declined.|
|Any (Single)||Multiple rules cover the same combination of input values. However, this overlap is only allowed if the overlapping rules have the same output.||A diagnosis of a medical condition might need an Any policy if various ranges of similar diagnostic test identify the same condition.|
|First (Single)||Rules might overlap. But only one rule fires: The First hit policy simply assumes an ordering of the rules – they are evaluated from top to bottom. As soon as one rule fires, the output of that rule is used as result of the decision. Once one rule hits, no other rule is checked.||A hotel booking reservation where the first match room is allocated based on a customer’s preference.|
|Collect (Multiple)||Multiple rules can fire without an explicit order. Multi hit tables either return a set or aggregate the final results of the decisions. DMN’s default is provide the set of output values as result. Multi-rule table can apply aggregation functions such as min, max, avg to derive a single value from a set of output values||Create a score card to assign points to an inspected based on multiple checks and with points off for various defects.|
If you now look at the DetermineLendingEligibility decision table again, you would notice that the first cell of the table is denoted with a capital F. This is setting the hit policy of the table to First which means the decision table will stop evaluation as soon as the first condition is true.
Combining Multiple Decisions in a DMN Decision Model
A single decision model can have one to many decision services and likewise one to many decisions. Decisions can be associated with decision services which provides a service interface to invoke a decision logic construct. As originally explained in our use case, we also wanted to calculate the automatically derived lending limit from a business rule. Whilst determining such a limit in real world would be based on very complex rules, a simplified version is shown below. The lending limit is based on the difference between the total valuation of a customer’s security against a sum of his/her outstanding loans. The result of the expression can also be evaluated against a number range to determine the decision output as shown in the decision table below. Note that [ denote that the number in the range is inclusive while ( denotes it is exclusive.
Testing a DMN Decision Service
The DMN composer in PCS has very strict design time validations for decision tables and models. Once the rule components are validated, they can be deployed as a standalone application in the same way as a PCS application. Once a DMN application is deployed, it will provide a rest endpoint to post a request and get a response. Here is a sample JSON request to the Rest endpoint and I use in Postman to invoke the service. The output is an decision interpretation object returning the result of each executed decision table in the decision service.
Using the New Decision Activity in a Process Model
The final piece to the puzzle is to use a DMN decision component in the process model. Needless to say there is a new Decision Activity available in the System palette in PCS composer to associate a decision service to the activity. The data association wizard in PCS can then be used to pass and retrieve information from a decision function. The following process model shows how the decision model discussed in this example can be used in an overarching process for straight through approval of customer retail lending. The result from the decision function are used to determine the process flow:
- If the lending limit is less than 5000 and the eligibility criteria are met, the lending is automatically approved without any manual intervention.
- If the lending limit is greater than 5000 and the eligibility criteria are met, the lending request is sent to a Credit Approver to view and either approve or reject the request.
- If the lending eligibility criteria are not met, the lending is rejected and the process terminates.
Application Links and Testing the Overall Solution
The PCS process and DMN business rule application discussed in this blog can be downloaded from here. When these applications are deployed to the runtime, they can be tested from end to end. The Manage Lending Submission process model has an event start (initiate lending submission) node which means that the process can be invoked as a SOAP endpoint. The section below provides a few test scenarios and how process map behaves based on the output determined by the DMN decision model.
Scenario 1 – Straight Through Approval – Sub 5k Loan
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:man="http://xmlns.oracle.com/bpmn/bpmnCloudProcess/MLS/ManageLendingSubmission" xmlns:len="http://xmlns.oracle.com/bpm/bpmobject/MLS/LendingRequestMetadata"> <soapenv:Header/> <soapenv:Body> <man:initiateLendingSubmission> <len:LendingRequestMetadata> <len:customerName>Arun Pareek</len:customerName> <len:lendingNumber>123123213</len:lendingNumber> <len:nationality>Australian</len:nationality> <len:securityInOrderVal>3000</len:securityInOrderVal> <len:aggregatedSoughtExposure>4900</len:aggregatedSoughtExposure> <len:identificationStatus>Valid</len:identificationStatus> <len:identityDocumentType>Passport</len:identityDocumentType> <len:approver>BBCManager</len:approver> <len:lendingEligibility>false</len:lendingEligibility> <len:lendingLimit>0</len:lendingLimit> <len:customerEmail>firstname.lastname@example.org</len:customerEmail> </len:LendingRequestMetadata> </man:initiateLendingSubmission> </soapenv:Body> </soapenv:Envelope>
Scenario 2 – Lending Requires Manual Approval – Loan > 5k with Valid Nationality, Identification Status/Document
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:man="http://xmlns.oracle.com/bpmn/bpmnCloudProcess/MLS/ManageLendingSubmission" xmlns:len="http://xmlns.oracle.com/bpm/bpmobject/MLS/LendingRequestMetadata"> <soapenv:Header/> <soapenv:Body> <man:initiateLendingSubmission> <len:LendingRequestMetadata> <len:customerName>Arun Pareek</len:customerName> <len:lendingNumber>123123213</len:lendingNumber> <len:nationality>Other</len:nationality> <len:securityInOrderVal>10000</len:securityInOrderVal> <len:aggregatedSoughtExposure>13000</len:aggregatedSoughtExposure> <len:identificationStatus>Valid</len:identificationStatus> <len:identityDocumentType>Passport</len:identityDocumentType> <len:approver>BBCManager</len:approver> <len:lendingEligibility>false</len:lendingEligibility> <len:lendingLimit>0</len:lendingLimit> <len:customerEmail>email@example.com</len:customerEmail> </len:LendingRequestMetadata> </man:initiateLendingSubmission> </soapenv:Body> </soapenv:Envelope>
Scenario 2 – Lending Rejected – Invalid Identification Status
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:man="http://xmlns.oracle.com/bpmn/bpmnCloudProcess/MLS/ManageLendingSubmission" xmlns:len="http://xmlns.oracle.com/bpm/bpmobject/MLS/LendingRequestMetadata"> <soapenv:Header/> <soapenv:Body> <man:initiateLendingSubmission> <len:LendingRequestMetadata> <len:customerName>Arun Pareek</len:customerName> <len:lendingNumber>123123213</len:lendingNumber> <len:nationality>Other</len:nationality> <len:securityInOrderVal>15000</len:securityInOrderVal> <len:aggregatedSoughtExposure>12000</len:aggregatedSoughtExposure> <len:identificationStatus>Invalid</len:identificationStatus> <len:identityDocumentType>Passport</len:identityDocumentType> <len:approver>BBCManager</len:approver> <len:lendingEligibility>false</len:lendingEligibility> <len:lendingLimit>0</len:lendingLimit> <len:customerEmail>firstname.lastname@example.org</len:customerEmail> </len:LendingRequestMetadata> </man:initiateLendingSubmission> </soapenv:Body> </soapenv:Envelope>
Summary and Closing Thoughts
The Decision Model and Notation not only adds clarity to business logic, it sharpens and simplifies business processes. A process model should represent the procedural flow of tasks. A decision model should represent the declarative conditions leading to the conclusions of business decisions. In the past, due to lack of alternatives, this was mixed up in process modeling notations leading to complex and convoluted process models and eventually maintenance headache. Decision models are relatively new to most organizations and the support for the DMN standard has just released in Process Cloud Service. This blog post should hopefully provide you with the necessary knowledge, tool and best practices for implementing decision models in business process and stay ahead of times. to start No one reading this column should feel behind the times. DMN and BPMN are very powerful together and using them wisely together could provide organizations with many advantages such as:
- Maintain all operational and analytical business logic (of business rules) together in one place (rather than scatter it across wrong places)
- Reduce process models to simplest form so that they do no consume the length of board room walls
- Increases speed to value and agility of the solution as decision models can be updated agnostic of the process models and vice versa.
- Provides reuse of business decisions across multiple processes
- Allow creation of customized views of the same decision logic whereby a process model calls a different view of a decision model as appropriate
- Deploy advanced and sophisticated technology in an optimum manner:
- Give more control to business people to govern and change the logic behind business decisions.