Native-Language Rules Engine for User-Configurable Decisions
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing rules engines require hardcoded business rules, making it cumbersome and time-consuming to modify or create new rules, necessitating involvement of software development and testing teams, which limits user independence in rule creation and automation.
Innovation Solution
A rules engine framework that allows users to create rules as expressions in a native language with logical operators, enabling users to modify rules without changing the underlying codebase, and uses an API to extract data for automated decision-making.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If business rules are hardcoded in the codebase, then the system maintains stability and reliability, but modifying or creating new rules requires software development and testing cycles
Solution Approach 1:
The patent segments the rule system from the core codebase by introducing a separate rule engine component. Rules are stored externally in a data store as configurable expressions rather than being hardcoded in the application code. This segmentation allows rules to be modified independently without changing the underlying codebase, eliminating the need for software development and testing cycles when updating business rules.
Solution Approach 2:
The patent introduces an intermediary rule engine that acts as a mediator between the data source and the decision-making process. This rule engine retrieves rules from an external data store, evaluates them against input data, and returns decisions. The intermediary layer decouples the business rules from the core system logic, enabling flexible rule modification without affecting system stability.
2Productivity
If users can independently create and modify rules, then software development cycles are reduced, but the system requires a flexible rule evaluation mechanism
Solution Approach 1:
The patent enables parameter changes by allowing rules to be defined as configurable expressions with variables and logical operators. Users can modify rule parameters such as conditions, operators, and thresholds without changing the codebase. The rule engine evaluates these parameterized expressions dynamically, enabling users to independently create and modify rules with high productivity.
Solution Approach 2:
The patent replaces the mechanical system of hardcoded rules with a computational rule engine that automatically evaluates expressions. Instead of manually modifying code to change rules, users work with declarative expressions that are automatically parsed and executed by the engine. This substitution eliminates manual development cycles and enables users to independently create and modify rules efficiently.
3Loss of time
If rules are stored externally rather than hardcoded, then rule modification time is reduced, but data extraction and rule evaluation infrastructure is required
Solution Approach 1:
The patent implements preliminary action by pre-storing rules in an external data store in a structured format before they are needed for evaluation. The rule engine can retrieve these pre-configured rules immediately when processing data, eliminating the time required for rule modification and deployment. This preliminary preparation enables rapid rule changes without requiring infrastructure for real-time rule compilation or deployment.
Data Source
AI summary
A method, computer program product, and computer system for configuring, by a computing device, a plurality of rules for use by a rules engine, wherein the plurality of rules may be written in a native language as expressions. Data may be extracted from a source. At least a portion of the data may be input into a plurality of input fields based upon, at least in part, the data extracted from the source. The plurality of rules may be run on at least the portion of the data populated into the plurality of input fields. A decision may be returned based upon, at least in part, running the plurality of rules on at least the portion of the data populated into the plurality of input fields.