What is a Decision Engine?
A decision engine (software) is a platform that executes decision logic in a runtime production environment. They evolved from rules engines which execute business rules for a particular process. In addition to business rules, decision engines enable organizations to execute various representations of explicit and AI-driven decision logic necessary to automate complex risk and operational decisions.
Decision engines, aka decision management platforms, decision management systems, decision management suites, digital decisioning platforms, or AI decisioning platforms are designed primarily for business analysts and non-technical domain experts. Decision engines augment, streamline, and replace much of an organization’s IT involvement in decision automation so that the business side has more autonomy and control. Therefore, decision engines often include a host of decision management tools that make it easier for these users to author, test, deploy, and monitor decision logic.
Organizations that benefit most from decision engines are those that would like to automate repetitive, cumbersome manual decisions or those that would like greater quality, flexibility, and transparency in their already automated decisions. Insurance underwriting is a good example.
Whether you decide to build or buy a decision engine, there are many factors to consider. In this post, I will focus on the more technical aspects of decision engines, specifically performance.
The Million-Dollar Question
In conversations with IT and Enterprise Architects, performance comes up frequently. The main concern can be summed up with this question: how does your decision engine handle high-throughput, low-response, high-concurrency scenarios? Or to put it more plainly, how does your decision engine support scaling?
My response, and what you should when evaluation decision engine performance is as follows:
- Different invocation modalities
- Various decision logic representations that can be combined
- Dedicated execution engines
- Flexible deployment
A modern decision engine like our SMARTS™ Data-Powered Decision Manager should be able to support more than hundreds of millions of interactive, batch, and simulation invocations per day. Note that these invocations may involve champion-challenger (or A/B) testing optimization, shadow execution of alternatives, canary deployment of new versions, etc.
- Interactive invocations occur where the caller sends data or documents to be decided on and waits for the decision results. These invocations typically happen when decisions need to be made in real-time (or as the data comes in) such as decisioning on an online loan application.
- Batch invocations occur where the caller streams large data or sets of documents through the decision engine to get the results. These invocations typically happen when decisions do not need to be made in real-time such as calculating last month’s commissions for all the agents.
- Simulation invocations occur where the caller streams large data and sets of documents through the decision to get both the decision results and decision analytics computations made on them. These invocations typically happen when users are running tests and experiments such as what-if scenarios, decision versions performance comparison, etc.
Decision Logic Representations
A modern decision engine should support various decision logic representations that users can easily combine and implement. For example, SMARTS™ supports the following decision logic representations:
- OMG DMN Decision Requirement Diagrams
- Decision Flows
- Decision Tables
- Decision Trees
- Decision Graphs
- Syntax Rules
- Sequential Rules
- Rete Inference Rules
- Point-and-Click Rules
- Scorecard Models
- Lookup Models
- Machine Learning Models (including but not restricted to Rule Set Models, Tree Model, Forest Models, XGBoost, and Neural Networks)
Supporting various representations allow users to select the most optimal representation for implementing, reviewing, and optimizing the decision.
A modern decision engine should provide dedicated execution engines to optimize performance for each decision logic representation and ultimately your overall decision. For example, SMARTS™ provides the following execution engines to ensure high performance:
- A compiled sequential rules engine
- A compiled Rete-NT inference rules engine
- A fully-indexed lookup model engine
- A decision flow engine
- A scorecard model engine
- 17+ predictive model engines
Without dedicated execution engines, your decisions will execute slowly in production.
A modern decision engine or platform should provide flexible deployment by enabling you to build decision services for microservices and other service approaches. For example, SMARTS™ can be delivered in either repository-based or decision-based containers. In addition to basic decision service execution, SMARTS™ provides the following support:
- Secure service invocations (typically JSON over HTTPS)
- Horizontal and Vertical Scalability
- High Availability
- No-Downtime Hot Swap for Decision Logic with Full Traceability
- Ready-to-Execute Decision Logic
A modern decision platform should also include the ability to address more data intensive scenarios. Examples include very large batch processes or integration with data processing pipelines that are not compatible with a services approach. SMARTS™ supports deploying rules not only as services but also as Java or .Net components. You can integrate these components into your application through direct APIs with no networking involved.
A decision engine that supports various invocations and decision logic representations as well as provides dedicated execution engines and flexible deployment options will ensure that your organization will be able to not only scale but also adapt quickly to market changes.
Learn more about Sparkling Logic’s SMARTS™ Data-Powered Decision Manager.