{"version":3,"file":"LW0fAVOt9-10.Bj_o9Iq3.mjs","names":["t","i"],"sources":["https:/framerusercontent.com/modules/DUaBI8Z0zQBEAftOFMh3/35vg0nARJtm9HUP7aFaP/LW0fAVOt9-10.js"],"sourcesContent":["import{jsx as e,jsxs as n}from\"react/jsx-runtime\";import{Link as t}from\"framer\";import{motion as i}from\"framer-motion\";import*as a from\"react\";export const richText=/*#__PURE__*/n(a.Fragment,{children:[/*#__PURE__*/n(\"p\",{children:[\"The\\xa0\",/*#__PURE__*/e(t,{href:\"https://www.javelinstrategy.com/content/Javelin-2021-Identity-Fraud-Study\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[\"noreferrer\"],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{href:\"https://www.javelinstrategy.com/content/Javelin-2021-Identity-Fraud-Study\",target:\"_blank\",children:/*#__PURE__*/e(\"strong\",{children:\"total fraud losses in 2020 amounted to 56 billion USD\"})})}),\"\\xa0and\\xa0\",/*#__PURE__*/e(t,{href:\"https://businessfraudprevention.org/fraud-statistics/\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[\"noreferrer\"],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{href:\"https://businessfraudprevention.org/fraud-statistics/\",target:\"_blank\",children:/*#__PURE__*/e(\"strong\",{children:\"U.S. businesses will lose an average of 5% of gross revenue to fraud\"})})}),\", making fraud mitigation a core area of focus in businesses of all manner. At the same time, detecting fraud in real-time is a difficult proposition causing substantially high monetary losses due to late detection of fraudulent behavior. More than 50% organizations\\xa0\",/*#__PURE__*/e(t,{href:\"https://home.kpmg/xx/en/home/insights/2019/05/the-multi-faceted-threat-of-fraud-are-banks-up-to-the-challenge-fs.html\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[\"noreferrer\"],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{href:\"https://home.kpmg/xx/en/home/insights/2019/05/the-multi-faceted-threat-of-fraud-are-banks-up-to-the-challenge-fs.html\",target:\"_blank\",children:/*#__PURE__*/e(\"strong\",{children:\"said in a survey\"})})}),\"\\xa0that they recover less than only 25% of fraud losses. In addition to monetary losses, late fraud detection causes irreparable damage to brand equity and user trust alike. Users of online services are at an increased privacy risk in the form of personal data exposure, account appropriation for fraud, or monetary losses, making fraud detection crucial to the larger trust and safety goal.\"]}),/*#__PURE__*/e(\"p\",{children:\"Banks, retail, insurance companies, online community products and marketplaces alike, need tools and techniques both to detect fraud and abuse in real-time, as well as, take appropriate mitigation measures in the moment vs when it is too late. Rapidly evolving adversarial patterns make early detection of fraud particularly challenging. This is exacerbated due to a lack of tooling to detect those patterns in real-time through rules or Machine Learning (ML) models, but Oscilar can change that!\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"Instant fraud decisioning powered by a combination of Machine Learning and rules is the future of fraud mitigation.\"})}),/*#__PURE__*/e(\"h2\",{children:\"Real-time fraud detection: Rules or Machine Learning?\"}),/*#__PURE__*/e(\"p\",{children:\"Up until recently, the primary approach to fraud prevention was centered around fraud detection based on human-defined rules coupled with manual review of possibly fraudulent transactions. While human review of fraudulent transactions might lead to fewer false positives, it unfortunately leaves a window of opportunity for advanced and fast evolving adversarial techniques leading to substantial financial and reputation damage. Therefore, effective fraud mitigation requires \\xa0accurate and instant decisioning ability with low false positives. Instant fraud decisioning involves ingesting hundreds of signals, some from the incoming transaction and some from historical analytics, to decide appropriate course of action for the transaction as it is happening.\"}),/*#__PURE__*/e(\"h2\",{children:\"Why a pure rules based decisioning approach is insufficient?\"}),/*#__PURE__*/e(\"p\",{children:\"Historically, fraud mitigation primarily centered around heuristics defined using rules, which when satisfied, trigger corresponding action. In a rules-based approach, you mark a data point as anomalous if it exceeds a preset, human-defined boundary. This approach requires significant domain knowledge of the incoming data and can become less effective with changes to the underlying fraud signals.\"}),/*#__PURE__*/e(\"p\",{children:\"As new adversarial patterns emerge, decisioning must evolve instantly to address them. Rules lend themselves to changes easily, making them a good fit for mitigating new adversarial patterns. However, as adversarial patterns adapt to human-defined thresholds, the rules and corresponding thresholds must adapt quickly as well. This necessitates tuning rules based on continuous rule analytics, as well as, using Machine Learning.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"Tuning heuristic based rules might work well for addressing certain high-confidence signals, but might fall short of discerning new multi-dimensional patterns.\"})}),/*#__PURE__*/e(\"p\",{children:\"For example, the billing address used for a credit card transaction being different from the card's billing address is a high confidence signal for increased risk of the transaction. But a combination of discerning trends across various financial transaction signals based on historical patterns, namely transaction amount, past transaction trends, GPS location of the transaction, transaction time, merchant account history etc quickly limit the effectiveness of rules driven by human insights.\"}),/*#__PURE__*/e(\"h2\",{children:\"Why a pure Machine Learning approach is insufficient?\"}),/*#__PURE__*/e(\"p\",{children:\"Machine learning is effective at deriving predictions from a vast variety of historical signals, but is fundamentally not agile to respond to rapidly evolving adversarial patterns in the moment. Furthermore, a pure Machine Learning approach to fraud and abuse detection necessitates substantial expertise that might not scale well if applied everywhere. For instance, ML models might operate at high recall and relatively higher false positive rates, but can be tuned to have lower false positive rate and a lower recall.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"Finding the right operating point on the ROC curve is necessary to strike the appropriate balance between false positive rate and recall.\"})}),/*#__PURE__*/e(\"p\",{children:\"Machine Learning models are also substantially less explainable compared to rules, limiting the set of people who can effectively tune the model.\"}),/*#__PURE__*/e(\"h2\",{children:\"It's about complexity of the decision logic and rate of change\"}),/*#__PURE__*/e(\"p\",{children:\"Application code is the starting point for lightweight rules that are simple and don't change often but is also less approachable to most risk teams given the requirement to write code. As the degree of complexity and rate of change increases, application code is no longer suitable for business logic. A rules engine is a good fit for logic that changes often but is less effective at decisioning as the logic increases in complexity. Machine Learning is a better fit for synthesizing complex relationships amongst hundreds of data points into a probability score when the rate of change in fraud patterns is relatively low. As the decision complexity, as well as, the rate of change of decisions increases, a decision engine that integrates both Machine Learning and rules offers the best fit for holistic and instant decisioning.\"}),/*#__PURE__*/e(\"p\",{children:\"‍\"}),/*#__PURE__*/e(\"img\",{className:\"framer-image\",height:\"740\",src:\"https://framerusercontent.com/images/ioqwN8VfKymgFvsCW9hO68B5NPc.jpg\",srcSet:\"https://framerusercontent.com/images/ioqwN8VfKymgFvsCW9hO68B5NPc.jpg?scale-down-to=512 512w,https://framerusercontent.com/images/ioqwN8VfKymgFvsCW9hO68B5NPc.jpg?scale-down-to=1024 1024w,https://framerusercontent.com/images/ioqwN8VfKymgFvsCW9hO68B5NPc.jpg 1920w\",style:{aspectRatio:\"1920 / 1481\"},width:\"960\"}),/*#__PURE__*/e(\"p\",{children:\"Machine Learning vs Rules:\\xa0The fit\"}),/*#__PURE__*/e(\"h2\",{children:\"Machine Learning vs Rules: The Fit\"}),/*#__PURE__*/e(\"p\",{children:\"Other than the complexity and rate of change, other vectors for assessing the fit for rules vs machine learning center around explainability, precision of output, origin of logic.\"}),/*#__PURE__*/e(\"p\",{children:\"Rules vs Machine Learning:\\xa0The Fit\"}),/*#__PURE__*/e(\"h2\",{children:\"Effective fraud mitigation requires both ML and rules\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"Accurate real-time risk decisioning using an appropriate combination of Machine Learning and rules is a journey. This evolution starts by replacing a subset of existing rules with ML models, followed by backstopping ML model risk scores with rules, and finally applying several ML models—some internal and other external—in the final decision.\"})}),/*#__PURE__*/e(\"p\",{children:\"This evolution is characterized by the following 3 step journey.\"}),/*#__PURE__*/e(\"h2\",{children:\"Step 1: Replace a subset of rules with new Machine Learning models\"}),/*#__PURE__*/e(\"p\",{children:\"The first step in the application of Machine Learning to risk decisioning is to replace a subset of rules with an ML model for ease of maintenance and increase in recall.\"}),/*#__PURE__*/e(\"img\",{className:\"framer-image\",height:\"510\",src:\"https://framerusercontent.com/images/T1F3mWeutMuNQMfBM0Zb2XHmZ2Y.jpg\",srcSet:\"https://framerusercontent.com/images/T1F3mWeutMuNQMfBM0Zb2XHmZ2Y.jpg?scale-down-to=512 512w,https://framerusercontent.com/images/T1F3mWeutMuNQMfBM0Zb2XHmZ2Y.jpg?scale-down-to=1024 1024w,https://framerusercontent.com/images/T1F3mWeutMuNQMfBM0Zb2XHmZ2Y.jpg 1920w\",style:{aspectRatio:\"1920 / 1021\"},width:\"960\"}),/*#__PURE__*/n(\"p\",{children:[/*#__PURE__*/e(\"em\",{children:\"Step 1\"}),\":\\xa0\",/*#__PURE__*/e(\"em\",{children:\"Replace a subset of well-tuned rules using Machine Learning\"})]}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"br\",{className:\"trailing-break\"})}),/*#__PURE__*/e(\"p\",{children:\"Over time, risk organizations accumulate a large number of rules with manually-tuned thresholds. Not only is this less maintainable but also cumbersome for the tuning process to keep up with the evolution of fraud patterns. To do this, features used in rules serve as training data for the Machine Learning model. For instance, a rule might deny a user request if the user fails to login thrice in the last 30 minutes and the account age is less than 2 days. Another rule might step-up authentication if the user's transaction zip code does not match one in their customer profile. The features used in these rules— namely transaction amount and number of failed login attempts—serve as training data for the Machine Learning model to provide a probability of risk for the particular user transaction. A human typically defines the decision and recommended action based on the threshold of the probability score.\"}),/*#__PURE__*/e(\"h2\",{children:\"Step 2: Backstop new Machine Learning models using well-tuned rules\"}),/*#__PURE__*/e(\"p\",{children:\"The next step in this evolution is to backstop these newly created ML models using well-tuned rules.\"}),/*#__PURE__*/e(\"img\",{className:\"framer-image\",height:\"756\",src:\"https://framerusercontent.com/images/5BAR8RpoVxB7gHWPBrjSleuE7mE.jpg\",srcSet:\"https://framerusercontent.com/images/5BAR8RpoVxB7gHWPBrjSleuE7mE.jpg?scale-down-to=512 512w,https://framerusercontent.com/images/5BAR8RpoVxB7gHWPBrjSleuE7mE.jpg?scale-down-to=1024 1024w,https://framerusercontent.com/images/5BAR8RpoVxB7gHWPBrjSleuE7mE.jpg 1920w\",style:{aspectRatio:\"1920 / 1512\"},width:\"960\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"Step 2: Backstop new ML models with well-tuned rules\"})}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"br\",{className:\"trailing-break\"})}),/*#__PURE__*/e(\"p\",{children:\"Backstopping ML models with rules is especially effective while launching a new Machine Learning model or when the signal that is being used in the rules is not available during model training. Offsetting the relatively less tuned ML model's accuracy with some well-tuned heuristics-based rules serves as a reasonable starting point. ML models trained on other relevant fraud also help protect the rollout of a new one. For instance, if account fraud ML model output > 0.65 and the IP reputation ML model < 0.76 and the number of user requests in the last 30 minutes > 3, then block the transaction.\"}),/*#__PURE__*/e(\"p\",{children:\"Machine Learning works well when the probability score of a well-tuned model is sufficiently high. However, a probability score in the gray area can lead to a high false positive rate that is hard to explain or reason about. This is also where backstopping the ML model score using well-defined rules effectively aid in increasing the overall accuracy of the decision. For example, let's say that your fraud detection ML model has a risk score of 0.75 for user account fraud. At the same time, if the payment transaction amount is unusually higher than the previous transactions by the same user, then you can increase the risk score.\"}),/*#__PURE__*/e(\"p\",{children:\"Another reason to apply this pattern is when the effectiveness of the ML model might be deteriorating due to shift in data or user behavioral patterns. Similarly, the model might be trained on labels that are different from but correlated to the label being predicted. When this happens, adding well-tuned heuristics based rules can increase the overall accuracy of the decision. For instance, block the transaction if the credit card transaction ML model score > 0.81 and user account's age > 10 days, or the credit card transaction ML model score is between 0.55 and 0.81 and user account's age ≤ 10 days. In this case, the ML model might already be trained with user account's age but the behavior of the fraud patterns influenced by the user account's age might change in a way that the model is unaware of. You subsequently train a new ML model incorporating account fraud, new behavior of user account's age, along with other features, and replace this rule eventually.\"}),/*#__PURE__*/e(\"h2\",{children:\"Step 3: Integrate multiple ML models into a more advanced ML model\"}),/*#__PURE__*/e(\"p\",{children:\"The final step in the evolution swings the pendulum from rules to the Machine Learning side. This step integrates probability scores from several well-tuned ML models—some internal and some third-party—into rules and other ML models.\"}),/*#__PURE__*/e(\"p\",{children:\"Over time, as the organization's ML prowess increases, several risk scores coming from specialized third-party tools and internal ML models alike, need to be integrated for a holistic fraud decisioning ability. For instance, you might have a third-party tool offering a risk score on account fraud, and an internal ML model that offers a risk score on transaction fraud. Both risk scores must be integrated in assessing the overall risk score for the transaction. Such an integration starts with writing rules that effectively combine various risk scores and corresponding thresholds to then recommend the appropriate course of action. And evolves into training new ML models using outputs of existing well-tuned ML models.\"}),/*#__PURE__*/e(\"img\",{className:\"framer-image\",height:\"635\",src:\"https://framerusercontent.com/images/TUIndiZS8ZXIftB1TjpFD5kh1w.jpg\",srcSet:\"https://framerusercontent.com/images/TUIndiZS8ZXIftB1TjpFD5kh1w.jpg?scale-down-to=512 512w,https://framerusercontent.com/images/TUIndiZS8ZXIftB1TjpFD5kh1w.jpg?scale-down-to=1024 1024w,https://framerusercontent.com/images/TUIndiZS8ZXIftB1TjpFD5kh1w.jpg 1920w\",style:{aspectRatio:\"1920 / 1270\"},width:\"960\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"Step 3: Integrate several ML model risk scores into rules at first, followed by a more advanced ML model\"})}),/*#__PURE__*/e(\"h2\",{children:\"Oscilar for real-time fraud prevention, powered by ML\"}),/*#__PURE__*/e(\"p\",{children:\"Real-time fraud prevention is an increasingly complex data processing problem involving multi-faceted data integration capability to backstop machine learning risk scores with rules when required, and have online training capability to continuously learn new and evolving adversarial patterns to protect the business and the user. Oscilar solves for real-time fraud detection using a no-code decision engine that integrates machine learning and rules to enable real-time and accurate fraud prevention.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"br\",{className:\"trailing-break\"})})]});export const richText1=/*#__PURE__*/n(a.Fragment,{children:[/*#__PURE__*/n(\"p\",{children:[\"This blog post is the second part of a series of blog posts on business rules engines. \",/*#__PURE__*/e(t,{href:{pathVariables:{jrNYIlVGO:\"business-rules-engine-101\"},unresolvedPathSlugs:{jrNYIlVGO:{collectionId:\"BUgVwc8Nv\",collectionItemId:\"LyOg8ZATO\"}},webPageId:\"g44hmdrGQ\"},motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"Part 1\"})}),\" covered business rules engines in detail; what they are, how they work, and why you might need one. This blog post provides a high-level overview of a specific rule engine called Drools and how to build a a modern business rules management system using Drools:\"]}),/*#__PURE__*/n(\"ul\",{children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Drools basic glossary\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Challenges with Drools\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Weak support for frequently changing rules and related data\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Redundancy and inefficient management of rules\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Limited expressiveness and steep learning curve\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Building a modern Drools based business rules management system\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Conclusion\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"See Oscilar in action, schedule a demo\"})})]}),/*#__PURE__*/e(\"h2\",{children:\"What is Drools?\"}),/*#__PURE__*/n(\"p\",{children:[/*#__PURE__*/e(t,{href:\"https://docs.jboss.org/drools/release/7.15.0.Final/drools-docs/html_single/\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"Drools\"})}),\" is a rules library with a forward and backward chaining-based rules engine. It uses an enhanced implementation of the \",/*#__PURE__*/e(t,{href:\"https://en.wikipedia.org/wiki/Rete_algorithm\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"Rete algorithm\"})}),\" and supports the Java Rules Engine API standard for its rules engine.\"]}),/*#__PURE__*/e(\"h3\",{children:\"A short history\"}),/*#__PURE__*/e(\"p\",{children:\"The Drools Project was started by Bob McWhirter in 2001 as a SourceForge project. In 2005, Drools was federated into JBoss as part of their JEMS offering and rebranded JBoss Rules. In 2006, JBoss itself was acquired by Red Hat and got renamed back to Drools in 2007.\"}),/*#__PURE__*/e(\"h3\",{children:\"Drools basic glossary\"}),/*#__PURE__*/e(\"p\",{children:\"Here are some of the basic concepts in Drools:\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Drools Rule Language\"})}),/*#__PURE__*/e(\"p\",{children:\"The Drools Rule Language or DRL rules are business rules defined in .drl text files. A DRL file can have one or more rules that define the rule conditions and actions in a when-then form.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Rule\"})}),/*#__PURE__*/n(\"p\",{children:[\"A Rule consists of a condition that fires the rule (when) and a consequence that performs actions (then) when it fires. It associates facts with matching actions. As we mentioned in the \",/*#__PURE__*/e(t,{href:\"https://oscilar.com/blog/business-rules-engine-101\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"previous blog\"})}),\", business rules can only be true or false.\"]}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Facts\"})}),/*#__PURE__*/e(\"p\",{children:\"Business rules are composed of facts and facts represent data that serves as information for rules.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Working Memory\"})}),/*#__PURE__*/e(\"p\",{children:\"Working memory is storage containing facts. The working memory enables a business engine to use facts for pattern matching. Facts can also be modified, inserted in, and removed from the working memory.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Knowledge Base\"})}),/*#__PURE__*/e(\"p\",{children:\"Knowledge base is an interface that manages a collection of rules, internal types and processes and it represents the knowledge of the Drools ecosystem. Knowledge sessions are created using the knowledge base.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Knowledge Session\"})}),/*#__PURE__*/e(\"p\",{children:\"The knowledge session holds all the resources that are required for firing rules. Facts are inserted into a session, and then matching rules are fired.\"}),/*#__PURE__*/n(\"p\",{children:[\"There can be stateless knowledge sessions and stateful knowledge sessions\",/*#__PURE__*/e(\"strong\",{children:\".\"})]}),/*#__PURE__*/e(\"p\",{children:\"Stateless knowledge sessions have facts or a working memory inserted into them, and it means a new session is created for each request, while stateful knowledge sessions maintain the old sessions, continuing where the previous one left off.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Module\"})}),/*#__PURE__*/e(\"p\",{children:\"A module contains multiple knowledge bases, which help create knowledge sessions.\"}),/*#__PURE__*/e(\"h2\",{children:\"Challenges with Drools\"}),/*#__PURE__*/e(\"p\",{children:\"While Drools enables you to define and manage the business rules outside of your code, it presents some challenges as well.\"}),/*#__PURE__*/e(\"h3\",{children:\"Weak support for frequently changing rules and related data\"}),/*#__PURE__*/e(\"p\",{children:\"The primary challenge with Drools is the lack of support for frequently changing rules. Generally, a Drools-based Java application requires all the rules artifacts such as DRLs, decision table excel files to be part of the application binary itself. That means, artifacts have to either be present in the source code repository or be pulled from it during the application build process. This becomes cumbersome with frequently changed rules; every rule change necessitate adding or modifying the rules artifacts, building the application code, and deploying to production servers.\"}),/*#__PURE__*/e(\"p\",{children:\"DRL rule uses Java data objects to retrieve facts or a set of results. Like DRL rules, creating and using new data objects also necessitates code modification and deployment. As a result, Drools usually works well with a static dataset rather than a dynamic dataset. However, most real-world use cases require dynamic datasets for accurate decisioning. For instance, most account takeover decisions require multi-dimensional data about the user's activity history and recent actions, that are themselves changing rapidly under the covers.\"}),/*#__PURE__*/e(\"p\",{children:\"This reliance on code—and the resulting build and deployment—both for rules and the related data, significantly slows down the speed of iteration of decisioning.\"}),/*#__PURE__*/e(\"p\",{children:\"Besides limiting its effectiveness for solving real-world problems, this also slows down response time for business decisioning.\"}),/*#__PURE__*/e(\"h3\",{children:\"Redundancy and inefficient management of rules\"}),/*#__PURE__*/e(\"p\",{children:\"The same business rules may apply across different applications and services, leading to redundancy and governance challenges. Drools imposes the burden on the user of keeping the rules and DRL files in sync. This necessitates building tooling to manage rules in a source code repository along with a rule service that manages updates and serves rules, which requires ownership and maintenance of a centralized rules service. Furthermore, the rules service must test and assess possible side effects of every rule change, which itself imposes a significant burden on the user of Drools.\"}),/*#__PURE__*/e(\"h3\",{children:\"Limited expressiveness and steep learning curve\"}),/*#__PURE__*/n(\"p\",{children:[\"Drools has its own Java-based\\xa0\",/*#__PURE__*/e(t,{href:\"https://en.wikipedia.org/wiki/Domain-specific_language\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"DSL\"})}),\"\\xa0with a non-trivial learning curve whereas majority of the data science community has a Python background. The Drools DSL is also limited in its \",/*#__PURE__*/e(t,{href:\"https://en.wikipedia.org/wiki/Expressive_power_(computer_science\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"expressive power\"})}),'. For instance, Drools has limited support for some common math functions such as factorials, greatest common divisor that are useful in practice. To address this challenge, Drools allows the development of \"',/*#__PURE__*/e(t,{href:\"https://docs.jboss.org/drools/release/7.59.0.Final/drools-docs/html_single/#_domain_specific_languages\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"custom DSLs\"})}),'\", but again, they are limited by the underlying rule support.']}),/*#__PURE__*/e(\"h2\",{children:\"Building a modern Drools based business rules management system\"}),/*#__PURE__*/e(\"p\",{children:\"Given the understanding of the challenges imposed by Drools, let's look at what's missing in Drools to make pragmatic application of Drools easier:\"}),/*#__PURE__*/n(\"ul\",{style:{\"--framer-line-height\":\"1.5em\",\"--framer-text-color\":\"rgb(55, 53, 47)\"},children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/n(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Rules Database\"}),\": A way to store all the rules outside the application binary in an external system such as a database.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/n(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Rules Service\"}),\": A rules service with a REST API that programmatically rebuilds Drools objects based on changes in rules, thereby eliminating the need to modify code. Such a rules service must also enable rolling out new changes to rules quickly without deploying or restarting applications. Thereby, it must build source code management of rules coupled with a CI/CD pipeline to push changes to the central rules database.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/n(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Knowledge or Feature Database\"}),\": A way to integrate feature data across third-party tools, databases, data lakes and other applications into a central feature database, eliminating the need to store all the facts that rules use in memory and powering the ability to backtest new rule changes.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/n(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Feature Service\"}),\": A central knowledge base or feature service with a REST API that accepts features or facts in a common format and responds with any data required by the rules.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/n(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Rule Analytics\"}),\": Central management and monitoring of rules to assess their performance over time to know when to evolve them.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/n(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Canary rollout\"}),\": Any pragmatic use of a rules engine for production requires careful rollout of new rules. This process starts with backtesting rules on past data, followed by deployment of the rule in shadow mode, followed by a gradual canary rollout of the rule before it processes 100% of the available data.\"]})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/n(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"No-code automation\"}),\": A UI that allows business analysts and any non-developers to easily evolve rules based on new signals and use cases, without writing any code.\"]})})]}),/*#__PURE__*/e(\"p\",{children:\"As might be clear from the description above, building a modern business rules management system—or decision engine—is a substantial proposition requiring deep expertise.\"}),/*#__PURE__*/e(\"h2\",{children:\"Conclusion\"}),/*#__PURE__*/e(\"p\",{children:\"Drools is a good but low-level abstraction for a rules engine and not a modern business rules management system. As such, it necessitates building numerous capabilities in order to turn it into a comprehensive decisioning solution.\"}),/*#__PURE__*/n(\"p\",{children:[/*#__PURE__*/e(t,{href:\"https://www.oscilar.com/\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"Oscilar\"})}),\" is a no-code real-time modern decision engine. It automates custom fact or feature creation, enrichment and analytics, combined with a rules engine that runs rules synchronously or asynchronously, and offers an easy-to-use UI to go from new feature to new rule in minutes.\"]})]});export const richText2=/*#__PURE__*/n(a.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"This blog post is the first part of a series of blog posts on business rules engines. In this blog post, we will cover the following:\"}),/*#__PURE__*/e(\"p\",{children:\"History of business rules engines: Rule Based Systems\"}),/*#__PURE__*/n(\"ul\",{children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"What are business rules?\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Business rules engines\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Business rules management systems\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"When and why do you need a business rules engine?\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"High-level architecture of a conventional business rules engine\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"The 3 phases of inference in rules engines\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"    Step 1: The Match Phase\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"    Step 2: The Select Phase\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"    Step 3: The Execute Phase\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"    Conclusion\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"See Oscilar in action, schedule a demo\"})})]}),/*#__PURE__*/e(\"p\",{children:\"This is the first part of our blog series on modern business rule engines. Read this blog series to learn the basics and the ins and outs of how it all works, whether you need it, and why.\"}),/*#__PURE__*/e(\"h2\",{children:\"History of business rules engines: Rule Based Systems\"}),/*#__PURE__*/e(\"p\",{children:\"A rule-based system (RBS) is a model of computation that has been widely used in the field of Artificial Intelligence (AI) for modeling human reasoning and problem-solving processes in specific task areas. Rule-based systems use if-then, or condition-action rules, as their basic unit of computation and employ declarative programming. The sequence of operations is not pre-specified in a RBS. Instead, the control flow depends on the frequent evaluation of the current system state, represented by a set of facts. The computation proceeds by applying the rules in a sequence determined by these facts and concludes with the final recommended action.\"}),/*#__PURE__*/e(\"p\",{children:\"This blog post outlines a rule-based system called business rules engine, when and why you need one, and their high-level architecture.\"}),/*#__PURE__*/e(\"h2\",{children:\"What are business rules?\"}),/*#__PURE__*/e(\"p\",{children:\"Business rules resolve to either true or false and take the form of conditions and corresponding actions. They are based on policies, regulations, contracts, and best practices and describe operations and constraints that apply to the business. Their main goal is to assert business policies that helps control the business's behavior and outcomes.\"}),/*#__PURE__*/e(\"p\",{children:\"Business rules are used to solve a variety of problems ranging from fraud and risk decisioning to IT policies and marketing segmentation.\"}),/*#__PURE__*/e(\"p\",{children:\"Using if-then rules is a natural approach to model human decision-making and problem-solving abilities, as well as, to represent knowledge. Nowadays, business rules have become ubiquitous with a broad range of applications in various domains, namely:\"}),/*#__PURE__*/n(\"ul\",{style:{\"--framer-font-size\":\"16px\",\"--framer-line-height\":\"1.5em\",\"--framer-text-alignment\":\"start\",\"--framer-text-color\":\"rgb(55, 53, 47)\",\"--framer-text-transform\":\"none\"},children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Risk-based pricing and other pricing strategies\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Loan origination, propensity to pay, recovery\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Segmentation strategies\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Insurance claim approval and related fraud\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Loan amount, credit limits and more\"})})]}),/*#__PURE__*/e(\"h2\",{children:\"Business rules engines\"}),/*#__PURE__*/e(\"p\",{children:\"A business rules engine (BRE) is a software component in a larger business rules management (BRMS) system that allows non-programmers to add, edit or change business logic, operational decisions, or company policies. These are defined, tested, executed, and maintained separately from the application code.\"}),/*#__PURE__*/e(\"h2\",{children:\"Business rules management systems\"}),/*#__PURE__*/e(\"p\",{children:\"A Business rule management system (BRMS) is built around a business rules engine and automates decision-making across an organization's business processes. BRMS act as a central warehouse for rules and offer collaboration and analytics capabilities. A BRMS is used to define, redistribute, execute, monitor, and manage business rules and decision logic.\"}),/*#__PURE__*/e(\"p\",{children:\"Modern business rules management systems are accessible to IT admins and business users alike, with features like no-code rules development and automated data engineering.\"}),/*#__PURE__*/e(\"h2\",{children:\"When and why do you need a business rules engine?\"}),/*#__PURE__*/e(\"p\",{children:\"Best use of business rules engines are when they are applied to problems with no obvious algorithmic solution.\"}),/*#__PURE__*/e(\"p\",{children:\"Here are some reasons for modeling problems as rules:\"}),/*#__PURE__*/n(\"ul\",{style:{\"--framer-font-size\":\"16px\",\"--framer-line-height\":\"1.5em\",\"--framer-text-alignment\":\"start\",\"--framer-text-color\":\"rgb(55, 53, 47)\",\"--framer-text-transform\":\"none\"},children:[/*#__PURE__*/n(\"li\",{\"data-preset-tag\":\"p\",children:[/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"The problem is not well understood upfront\"})}),/*#__PURE__*/e(\"p\",{children:\"Rules are a good fit for complex problems where there are no obvious algorithmic solutions, or when the problem isn't fully understood.\"})]}),/*#__PURE__*/n(\"li\",{\"data-preset-tag\":\"p\",children:[/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"The logic changes often\"})}),/*#__PURE__*/e(\"p\",{children:\"The logic itself may be simple but it changes often. In many organizations, software releases are few and far between and rules can help provide agility in a reasonably safe way.\"})]}),/*#__PURE__*/n(\"li\",{\"data-preset-tag\":\"p\",children:[/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Data integration is necessary for the logic\"})}),/*#__PURE__*/e(\"p\",{children:\"Business rules often require operating on data or facts that are frequently fragmented across several internal and external data sources. Tight coupling of logic and related data reduces efficiency and causes duplication as the data needs to be integrated several times wherever the logic is applied.\"})]}),/*#__PURE__*/n(\"li\",{\"data-preset-tag\":\"p\",children:[/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Speed and scalability\"})}),/*#__PURE__*/e(\"p\",{children:\"Rules engines employ various well-tested and widely deployed pattern matching algorithms. They provide very efficient ways of matching rule patterns to your data, thereby increasing the speed and scalability of decisioning.\"})]}),/*#__PURE__*/n(\"li\",{\"data-preset-tag\":\"p\",children:[/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Centralization of knowledge\"})}),/*#__PURE__*/e(\"p\",{children:\"The use of rules creates a central repository of knowledge, or a knowledge base, which is well understood and explainable. It serves as a single point of truth for business policies and related decisioning. Ideally rules are readable enough to serve as documentation.\"})]}),/*#__PURE__*/n(\"li\",{\"data-preset-tag\":\"p\",children:[/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Domain experts or business analysts are readily available\"})}),/*#__PURE__*/e(\"p\",{children:\"Domain experts often possess a wealth of knowledge about business rules and processes. Rules allow them to express decisioning logic without requiring to write application code.\"})]})]}),/*#__PURE__*/e(\"h2\",{children:\"High-level architecture of a conventional business rules engine\"}),/*#__PURE__*/n(\"ol\",{style:{\"--framer-font-size\":\"16px\",\"--framer-line-height\":\"1.5em\",\"--framer-text-alignment\":\"start\",\"--framer-text-color\":\"rgb(55, 53, 47)\",\"--framer-text-transform\":\"none\"},children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Production memory stores the list of rules.\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Working memory stores the list of facts required by the rules.\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Inference engine performs pattern patching to execute the selected rule.\"})})]}),/*#__PURE__*/e(\"img\",{alt:\"\",className:\"framer-image\",height:\"602\",src:\"https://framerusercontent.com/images/45QpWfPkuqiNbvA4rB66AxniGc.jpg\",srcSet:\"https://framerusercontent.com/images/45QpWfPkuqiNbvA4rB66AxniGc.jpg?scale-down-to=512 512w,https://framerusercontent.com/images/45QpWfPkuqiNbvA4rB66AxniGc.jpg?scale-down-to=1024 1024w,https://framerusercontent.com/images/45QpWfPkuqiNbvA4rB66AxniGc.jpg 1920w\",style:{aspectRatio:\"1920 / 1204\"},width:\"960\"}),/*#__PURE__*/e(\"h2\",{children:\"The 3 phases of inference in rules engines\"}),/*#__PURE__*/e(\"p\",{children:\"At a high level, the inference engine in business rules engines iteratively performs the following operations:\"}),/*#__PURE__*/e(\"img\",{alt:\"\",className:\"framer-image\",height:\"507\",src:\"https://framerusercontent.com/images/VWiTWZtmHxASRUyHsmHYopeqMM.jpg\",srcSet:\"https://framerusercontent.com/images/VWiTWZtmHxASRUyHsmHYopeqMM.jpg?scale-down-to=512 512w,https://framerusercontent.com/images/VWiTWZtmHxASRUyHsmHYopeqMM.jpg?scale-down-to=1024 1024w,https://framerusercontent.com/images/VWiTWZtmHxASRUyHsmHYopeqMM.jpg 1920w\",style:{aspectRatio:\"1920 / 1014\"},width:\"960\"}),/*#__PURE__*/e(\"h3\",{children:\"Step 1: The Match Phase\"}),/*#__PURE__*/e(\"p\",{children:\"All rules are compared to the current facts in the working memory. This process is called rule pattern matching. Each ordered pair of a rule and the subset of facts satisfying the conditions is an instantiation—also called activation—of the rule. All rule activations are enumerated to form the conflict set.\"}),/*#__PURE__*/e(\"p\",{children:\"The process of comparing rules to the current facts in the working memory is called rule pattern matching. In contrast to pattern recognition—recognizing patterns and similarities in data—pattern matching means that the match usually has to result in a boolean match/not match value.\"}),/*#__PURE__*/e(\"p\",{children:\"Rules engines employ several types of pattern matching algorithms, such as Rete, Linear, Treat, Leaps. The Rete algorithm is a popular pattern matching algorithm and has become the basis for some of the most popular rule engines, including Drools. Efficiency was a central focus in developing the Rete algorithm and it is designed to sacrifice memory for increased speed. In theory, Rete performance is independent of the number of rules in the system, thus being many times faster compared to naive implementations.\"}),/*#__PURE__*/e(\"h3\",{children:\"Step 2: The Select Phase\"}),/*#__PURE__*/e(\"p\",{children:\"In the Select phase, a single rule activation of the conflict set is chosen for execution. This phase is also called conflict resolution and the predefined criterion for selecting the rule to be executed is called conflict resolution strategy. This phase outputs the resulting selected rule.\"}),/*#__PURE__*/e(\"h3\",{children:\"Step 3: The Execute Phase\"}),/*#__PURE__*/e(\"p\",{children:\"The actions specified in the selected rule are executed. They may change the contents of the working memory. At the end of this phase, the match phase is executed again.\"}),/*#__PURE__*/e(\"p\",{children:\"There are two methods of execution for a rules engine: Forward Chaining and Backward Chaining; systems that implement both are called Hybrid Chaining Systems. The way rules are scheduled for execution is a key characteristic that differentiates the various types of rule engines.\"}),/*#__PURE__*/n(\"ol\",{style:{\"--framer-font-size\":\"16px\",\"--framer-line-height\":\"1.5em\",\"--framer-text-alignment\":\"start\",\"--framer-text-color\":\"rgb(55, 53, 47)\",\"--framer-text-transform\":\"none\"},children:[/*#__PURE__*/n(\"li\",{\"data-preset-tag\":\"p\",children:[/*#__PURE__*/n(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Forward Chaining\"}),\": Forward chaining is the predominant type of rules engine. In short, this type of rules engine starts with the data and reasons its way to the answer. They start with the available data or facts and uses inference rules—a function that takes premises, analyzes their syntax, and returns a conclusion(s)—to extract more facts until a goal is reached.\",/*#__PURE__*/e(\"br\",{}),/*#__PURE__*/e(\"br\",{}),\"There are two types of forward chaining rule engines:\"]}),/*#__PURE__*/n(\"ol\",{style:{\"--framer-line-height\":\"1.5em\"},children:[/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/e(\"p\",{children:\"Production/inference: that take the form of if-then logic\"})}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/n(\"p\",{children:[\"Reactive: that take the form of event → condition → action or 'when-then' logic\",/*#__PURE__*/e(\"br\",{}),/*#__PURE__*/e(\"br\",{className:\"trailing-break\"})]})})]})]}),/*#__PURE__*/e(\"li\",{\"data-preset-tag\":\"p\",children:/*#__PURE__*/n(\"p\",{children:[/*#__PURE__*/e(\"strong\",{children:\"Backward Chaining\"}),\": Backward chaining, as the name suggests, is the opposite of forward chaining. While forward chaining starts with data and works its way from there, backward chaining starts with a list of goals (or a hypothesis) and works backward to see if any facts support the goals or a hypothesis.\"]})})]}),/*#__PURE__*/e(\"h2\",{children:\"Conclusion\"}),/*#__PURE__*/e(\"p\",{children:\"While business rules engines have become ubiquitous with a broad range of applications in various domains, they may be an overkill for certain use cases. They are a powerful abstraction when applied correctly and enable a broader user base—that do not write code—to solve key business problems ranging from IT policies, risk management to regulatory policies and marketing segmentation.\"}),/*#__PURE__*/n(\"p\",{children:[\"In this blog post, we went through what conventional business rules engines are all about. \",/*#__PURE__*/e(t,{href:\"https://oscilar.com/blog/drools-business-rules-engine\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"Part 2\"})}),\" of the blog post series will go through a popular business rules engine called Drools. The final blog of this series will go through modern decision engines and what's missing in conventional business rules engines.\"]})]});export const richText3=/*#__PURE__*/n(a.Fragment,{children:[/*#__PURE__*/n(\"p\",{children:[\"This is the final part of our blog post series on business rules engines. \",/*#__PURE__*/e(t,{href:{pathVariables:{jrNYIlVGO:\"business-rules-engine-101\"},unresolvedPathSlugs:{jrNYIlVGO:{collectionId:\"BUgVwc8Nv\",collectionItemId:\"LyOg8ZATO\"}},webPageId:\"g44hmdrGQ\"},motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!1,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"Part 1\"})}),\" covered conventional business rules engines in detail; what they are, how they work, and why you might need one. In \",/*#__PURE__*/e(t,{href:{pathVariables:{jrNYIlVGO:\"drools-business-rules-engine\"},unresolvedPathSlugs:{jrNYIlVGO:{collectionId:\"BUgVwc8Nv\",collectionItemId:\"jh7N8gAFl\"}},webPageId:\"g44hmdrGQ\"},motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!1,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"Part 2\"})}),\" we covered one specific rule engine called Drools and what's missing in Drools. This blog post will go through modern no-code decision engines in relation and its application to one of the most prolific use cases: fraud and risk decisioning.\"]}),/*#__PURE__*/e(\"h2\",{children:\"The rise of modern risk decisioning\"}),/*#__PURE__*/n(\"p\",{children:[\"With every company becoming a software company, more end user transactions are moving online, thereby increasing the surface area for fraud and corresponding business risks. The \",/*#__PURE__*/e(t,{href:\"https://www.javelinstrategy.com/content/Javelin-2021-Identity-Fraud-Study\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"total fraud losses in 2020 amounted to 56 billion USD\"})}),\" and \",/*#__PURE__*/e(t,{href:\"https://businessfraudprevention.org/fraud-statistics/\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"U.S. businesses will lose an average of 5% of gross revenue to fraud\"})}),\", making fraud mitigation a core area of focus in businesses of all manner.\"]}),/*#__PURE__*/e(\"p\",{children:\"Transportation services require that customer's location get tracked while on a ride, SaaS tools ask that companies store their sensitive data in the cloud, financial services want their users to send money to each other using their mobile phones, Online marketplaces want their customers to send money to someone they have never met. And e-commerce providers want customers to share and save personal information, including credit card numbers, to enable faster and more personalized purchasing experiences. Digitization is bringing new and transformative user experiences online but at the cost of increased fraud and associated risk.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"The cornerstone of modern risk decisioning is detection of fraud and abuse in real-time using automated feature engineering, a decision engine powered by Machine Learning, coupled with no-code automation.\"})}),/*#__PURE__*/e(\"h3\",{children:\"Risk management is about making accurate decisions in the moment\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"Risk management entails a balancing act between enabling a seamless online user experience and introducing friction in the user experience to stop bad actors.\"})}),/*#__PURE__*/e(\"p\",{children:\"This isn't a one time static decision. User behaviors change, as do business appetite for fraud losses and risk. Therefore, risk management is about continuously and dynamically altering the user experience to reduce false positives and slow down or stop adversarial patterns.\"}),/*#__PURE__*/e(\"p\",{children:\"This capability of dynamic decisioning necessitates speeding up fraud and risk operations in a way that enables organizations to go from discovering new fraud signals to deploying accurate decisions to counter those adversarial patterns in a few minutes vs months.\"}),/*#__PURE__*/e(\"h2\",{children:\"Why a conventional rules engine approach is not the answer?\"}),/*#__PURE__*/e(\"p\",{children:\"Traditionally, risk management was centered around rules engines. Typically, these took the form of a business rules engine that manages a set of policies, expressed as rules, separately from application code. Business rule engines are typically part of a business rule management system that enable registering, defining rules and the relationship between various rules.\"}),/*#__PURE__*/e(\"p\",{children:\"Fundamentally, rule engines are a much lower level of abstraction requiring analysts and data scientists to write code in order to design new decisions to manage risk. Thereby, conventional rule engines necessitate a dependence on engineering due to a lack of no-code automation amongst other reasons.\"}),/*#__PURE__*/e(\"p\",{children:\"Furthermore, conventional business rules engines are centered around the processing logic alone, leaving the data plumbing required by the rules to the risk teams to figure out. This results in the application bearing the burden of integrating all the data required by the rules before invoking the rule engine, thereby impacting the performance of decisioning.\"}),/*#__PURE__*/e(\"h2\",{children:\"The result is a decision gap\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"Drawbacks of conventional decisioning result in a series of unideal tradeoffs involving performance, engineering overhead and iteration speed of fraud and risk operations.\"})}),/*#__PURE__*/e(\"img\",{alt:\"\",className:\"framer-image\",height:\"681\",src:\"https://framerusercontent.com/images/kCOOKsG0Q2WDBpGi1T4Blw0gqU.jpg\",srcSet:\"https://framerusercontent.com/images/kCOOKsG0Q2WDBpGi1T4Blw0gqU.jpg?scale-down-to=512 512w,https://framerusercontent.com/images/kCOOKsG0Q2WDBpGi1T4Blw0gqU.jpg?scale-down-to=1024 1024w,https://framerusercontent.com/images/kCOOKsG0Q2WDBpGi1T4Blw0gqU.jpg 1920w\",style:{aspectRatio:\"1920 / 1363\"},width:\"960\"}),/*#__PURE__*/e(\"h3\",{children:\"High engineering overhead\"}),/*#__PURE__*/e(\"p\",{children:\"Building a lower level abstraction such as a rules engine often means their end users—analysts and data scientists—get blocked on expensive engineering resources to do end-to-end risk management—from integrating appropriate data sources and writing new rules, to pushing them live and monitoring their performance. This reliance on engineering is not ideal for risk teams and an expensive proposition for the company.\"}),/*#__PURE__*/e(\"h3\",{children:\"Slow response time to new adversarial patterns\"}),/*#__PURE__*/e(\"p\",{children:\"Absence of automated out-of-the-box integrations with the right data sources often means significant time spent on data plumbing to discover new fraud and risk signals. Coupled with the lack of no-code automation, this means a delay of weeks to months to respond to rapidly evolving adversarial patterns. This slow response time results in millions of dollars in fraud losses and damage to invaluable brand equity.\"}),/*#__PURE__*/e(\"h3\",{children:\"Poor performance\"}),/*#__PURE__*/e(\"p\",{children:\"Accumulating all the data required by the rules engine as part of one large object passed into the rules often means that applications make several synchronous API calls, some to 3rd party tools and some to internal services, to execute a set of relevant rules. Not only does this increase the latency of rule execution, but it also does not scale and leads to incomplete decisioning due to the skipped rules that are too slow to execute.\"}),/*#__PURE__*/e(\"h2\",{children:\"What does modern risk decisioning entail?\"}),/*#__PURE__*/e(\"p\",{children:\"To answer this question, we must reason about decisions from first principles. A decision is a set of conditions that must be satisfied to trigger the appropriate set of actions to execute the business decision.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Decisions = Conditions + Actions\"})}),/*#__PURE__*/e(\"p\",{children:\"And conditions require features or signals of interest and often context that might lie in a 3rd party tool or a relational database or a data lake.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"strong\",{children:\"Conditions = Features + Context\"})}),/*#__PURE__*/e(\"p\",{children:\"While the raw features can be assembled, albeit at the cost of performance, the core overhead is the data plumbing that needs to be done in real-time to assemble the context required to enrich the raw features.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"A decision engine is a system that takes in features, enriches it with related context, to feed relevant rules and ML models and execute the configured actions.\"})}),/*#__PURE__*/e(\"p\",{children:\"More importantly, it is a system that enables a complete feedback loop, thereby measuring the performance of rules and ML models along with the actual decisions made. The final decision might be made by a manual reviewer or by the business logic of the application. These decisions are then fed into Machine Learning models that are trained to recognize complex adversarial patterns effectively.\"}),/*#__PURE__*/e(\"img\",{alt:\"\",className:\"framer-image\",height:\"718\",src:\"https://framerusercontent.com/images/Oj2kg3SKU9rFGzuKxpn9taZfY.jpg\",srcSet:\"https://framerusercontent.com/images/Oj2kg3SKU9rFGzuKxpn9taZfY.jpg?scale-down-to=512 512w,https://framerusercontent.com/images/Oj2kg3SKU9rFGzuKxpn9taZfY.jpg?scale-down-to=1024 1024w,https://framerusercontent.com/images/Oj2kg3SKU9rFGzuKxpn9taZfY.jpg 1920w\",style:{aspectRatio:\"1920 / 1436\"},width:\"960\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"Image 2: Architecture of a no-code decision engine\"})}),/*#__PURE__*/e(\"h3\",{children:\"Accurate risk decisioning is a real-time data integration problem\"}),/*#__PURE__*/e(\"p\",{children:\"Raw features are rarely sufficient for good decision making; they almost always require enrichment with context that is itself fragmented across 3rd party tools, databases, internal services, and data lakes. As such, modern risk decisioning is really a real-time data integration problem.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"The core need of modern risk decisioning is a platform that integrates context coming from a variety of sources, offers an easy way to enrich features with that context, and do that continuously as new features and signals are generated.\"})}),/*#__PURE__*/e(\"h3\",{children:\"Not just rules, or Machine Learning, but both\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"The journey of fraud prevention and risk management often starts with rules centered around heuristics and advances to extensive application of Machine Learning.\"})}),/*#__PURE__*/e(\"p\",{children:\"The first step of this journey starts with high-confidence rules using heuristics. For instance, if the customer has failed to login more than 3 times in the last 10 minutes, then block the account. Tuning rules might work well for incorporating certain high-confidence signals, but might fall short of discerning new multi-dimensional patterns. For example, the billing address used for a credit card transaction different from the card's billing address is a high confidence signal for increased risk of the transaction. So is the location of the user's transaction different from the user's billing address. Those signals coupled with an unsually high transaction amount might signal a high-risk or fraudulent transaction.\"}),/*#__PURE__*/e(\"p\",{children:\"As adversarial patterns adapt to human specified thresholds, the rules and corresponding thresholds must adapt quickly as well. Furthermore, a combination of discerning trends across various financial transaction signals such as transaction amount, past transaction trends, GPS location of the transaction, transaction time, merchant name etc quickly limit the effectiveness of human insights driven heuristics.\"}),/*#__PURE__*/e(\"p\",{children:\"This is where Machine Learning (ML) for real-time fraud detection comes in. Supervised ML models that get trained on the heuristics used in high-confidence rules and the corresponding decisions—either taken by a human as part of a manual review or by an application—are effective at discerning fraud patterns using a large number of complex and related signals. And unsupervised Machine Learning is more effective at anomaly detection that facilitates discovery of new fraud signals and hence, new and more effective rules or Machine Learning models.\"}),/*#__PURE__*/e(\"p\",{children:\"While Machine Learning is good at detecting patterns from the past, rules help stop actively evolving adversarial patterns in the moment. Therefore, the next step in the evolution of modern risk decisioning is about back stopping new ML model risk scores with short-term rules for a holistic and real-time risk decisioning ability.\"}),/*#__PURE__*/e(\"p\",{children:\"Finally, the journey of modern fraud and risk decisioning evolves into advanced Machine Learning that trains new ML models on the output of these short-term rules, as well as, other features from other well-tuned ML models.\"}),/*#__PURE__*/e(\"h3\",{children:\"No-code automation for fraud and risk decisioning\"}),/*#__PURE__*/e(\"p\",{children:\"A core gap in rules engines is the inability of performing end-to-end decisioning without reliance on engineering. Increasing the iteration speed of fraud and risk operations necessitates closing this critical gap and bringing down the mean time to recovery.\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"No-code automation sits at the heart of modern fraud and risk decisioning freeing non-developers like analysts and data scientists from writing code and relying on engineering for core day-to-day decisioning.\"})}),/*#__PURE__*/e(\"h3\",{children:\"Integrated case management with decisioning\"}),/*#__PURE__*/e(\"p\",{children:\"Albeit the high degree of automation that Machine Learning lends to risk decisioning, it does not fully remove the role of humans in managing high risk transactions. Streamlining case management by fully integrating it with the decision engine is a necessary capability of modern risk management. Doing that effectively entails assembling all the related data and associated history of user's actions for the reviewer to enable them to take the right action. Equally important is completing the feedback loop and feeding the final decision as labels for training supervised ML models, thereby improving the ability to further reduce the burden on manual decision making.\"}),/*#__PURE__*/e(\"img\",{alt:\"\",className:\"framer-image\",height:\"482\",src:\"https://framerusercontent.com/images/Dby5fIKHJUYYp55Cs1XlMxOajg.jpg\",srcSet:\"https://framerusercontent.com/images/Dby5fIKHJUYYp55Cs1XlMxOajg.jpg?scale-down-to=512 512w,https://framerusercontent.com/images/Dby5fIKHJUYYp55Cs1XlMxOajg.jpg?scale-down-to=1024 1024w,https://framerusercontent.com/images/Dby5fIKHJUYYp55Cs1XlMxOajg.jpg 1920w\",style:{aspectRatio:\"1920 / 965\"},width:\"960\"}),/*#__PURE__*/e(\"p\",{children:/*#__PURE__*/e(\"em\",{children:\"Image 3: Oscilar, a no-code decision engine for fraud and risk\"})}),/*#__PURE__*/e(\"h2\",{children:\"Oscilar as a modern no-code fraud and risk decisioning solution\"}),/*#__PURE__*/e(\"p\",{children:\"Oscilar is the only no-code real-time decision engine that automates custom feature enrichment using out of the box integrations with a variety of 3rd party tools and data systems, and has an in-built no-code decision engine powered by Machine Learning to offer real-time risk decisioning ability. Oscilar also offers integrated case management to complete the decisioning feedback loop and enable risk teams to speed up fraud and risk operations.\"}),/*#__PURE__*/n(\"p\",{children:[/*#__PURE__*/e(t,{href:\"https://www.oscilar.com/\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"Schedule a demo\"})}),\" or \",/*#__PURE__*/e(t,{href:\"mailto:hi@oscilar.com\",motionChild:!0,nodeId:\"LW0fAVOt9\",openInNewTab:!0,relValues:[],scopeId:\"contentManagement\",smoothScroll:!1,children:/*#__PURE__*/e(i.a,{children:\"drop us a note\"})}),\".\"]})]});\nexport const __FramerMetadata__ = {\"exports\":{\"richText1\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText2\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText3\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}"],"mappings":"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"}