Leading companies are tackling the complexity of their application and IT environments with service-oriented architecture (SOA), which facilitates the development of enterprise applications as modular business services that can be easily integrated and reused, thereby creating a truly flexible, adaptable IT infrastructure. Business process management (BPM) solutions such as those based on Business Process Execution Language (BPEL) enable services to be orchestrated into business processes. Processes built using a BPM solution can be reused, changed easily in response to business requirements, and enable real-time process visibility.

The promise of SOA is simplified integration, increased reuse, greater agility, and reduced risk. SOA and BPM deliver increased agility through three key enablers:

1.  Reducing the time that it takes to automate business processes by reducing the gap between model and implementation, and enabling easier reuse of existing assets that can be exposed as services and then reused

2.  Enabling business processes already implemented as orchestration of services to be changed rapidly

3.  Freeing up funds for projects that enhance business agility by giving IT the ability to reduce spending on maintenance - after all, a capability that is implemented once, as a service, provides a single point of change and is easier to maintain when compared to the scenario in which it's embedded multiple times in different applications.

Agility is one of the biggest promises of BPM: the ability to make rapid changes to processes in step with the changes that occur inside of your business. Such changes are not always changes to the process. Often they are changes to the rules that drive the process. A typical business process often includes a number of decision points. These decision points generally have an effect on the process flow; for example, someone's credit rating may determine whether he or she is approved for a low-cost loan. These decisions are evaluated based on certain conditions and facts, which may be internal or external to the business process, and predefined company policies or rules. Business rules engines (BREs) allow architects to easily define, manage, and update the decision logic that directs enterprise applications from a single location without needing to write code or change the business processes calling them. BREs have been used extensively in enterprises; e.g., to implement yield management in the travel industry (what price to sell a ticket?), credit risk assessment in the loan industry (what is the interest rate for my car loan?), operations scheduling in manufacturing (what should we build today to maximize throughput and keep customers happy?), and the list goes on.

BREs are naturally of interest to enterprise architects building out SOAs, since they contribute to agility by enabling reduced time to automate, easier change, and easier maintenance for business policies and rules. BPM technology and BREs naturally fit together: BPM enables automated and flexible business processes; BREs enable automated and flexible business policies.

We'll outline three different approaches that you can take to incorporate rules into your process logic: code-based, model-driven, and service-oriented. We consider two classes of BPM systems: monolithic BPM suites - those that embed capabilities including a BRE into a suite, and open-standards BPM solutions, which are based on the BPEL standard and enable you to use your choice of rules engine or an embedded one. We show how each of two solution classes supports code-based, model-driven and service-oriented automation of business rules. A case study of a loan application processing will be outlined to show how business processes and rules exist together, and how the rules engine enables changes in business policies to be made easily by business analysts, without breaking the business process logic. We will then focus on how practitioners can go about building out their SOA using BPEL and their choice of rules engine, as well as how to integrate these capabilities (from an architectural perspective). We will also provide best practices on when to embed decisions in the process logic and when it's best to abstract and capture decisions/policies using a rules engine.

Context
Let's provide some background about the various concepts in a rules engine. Some common terms are:

• Facts - Application or business objects that are used to make decisions. A fact definition can be created using the tools provided by the rules engine or directly imported from Java objects or XML document definitions. For example, a customer object, loan application object, and credit history are all facts that can be used to define credit risk rules.
• Rules - Sets of expressions that are evaluated as soon as facts are created or updated into the rules engine. The expressions can be simple if/then expressions, or decision tables, or complex functions. Rules also have actions associated with them - these actions fire if the condition evaluates to true. The actions may in turn create new facts or call other functions.
• Constraints - Used to define portions of the rules that are customizable by the business analysts after the rules have been deployed. For example, in a rule like "if loan amount < 100,000 AND credit rating > '700', then Auto_Approve," both the action and the number "700" could be modifiable after deployment, but the expression itself may not be changed.
• Rules dictionary/vocabulary - A collection of metadata files that includes the fact and rule definitions. This generally forms the deployment unit for all rules used by a specific application.

A typical rules engine has the following components:

• Rules editor - A tool used by business analysts and developers to define facts, author rules, and deploy rule sets.
• Rules repository - The persistence layer that stores and manages the rule sets and definitions. Most rules products support both file and DB-based repositories.
• Rules engine - Processing engine that evaluates and fires the rules based on facts that are created or updated in its working memory. Facts are generally loaded into the engine using application-programming interfaces (APIs) or batch loaders. Many rules engines on the market are based on the industry standard RETE algorithm for processing rules.
• Rules engine interfaces - Most rules engines support APIs to import facts definitions, define rules, assert/retract facts, execute rule sets, and retrieve results.

These components are common to both the monolithic BPM suites and the open-standards BPM solutions built on BPEL.

Approaches to Rules Enabling Business Processes
We consider three basic approaches to using rules in business processes, which are shown in Table 1. Regardless of the approach taken, some requirements include: tools for business analysts to define rules in an English-like language and tools for process owners to incorporate rules as part of the process flow; capabilities to modify rules after process deployment in response to changing company policies without the need to change the process definitions; mechanisms to load facts into the rules engine from business processes as well as other applications; and the ability to reuse rules across processes and applications. We can evaluate each of three approaches with respect to common criteria regarding ease of development, reuse, and flexibility. Table 2 summarizes the merits of each approach.

Monolithic BPM suites support both the code-based and the model-driven approaches and work best when rules are used in the context of business process only and when rules do not require additional context (for example, real-time metrics from a Business Activity Monitoring [BAM] solution). They do not generally make it possible for you to leverage existing rules (metadata) that may reside in an existing rules engine, which means you have to build your rules base from scratch or implement logic to import the rules. Furthermore, there are usually no out-of-the-box mechanisms for synchronizing rules between the embedded rules engine in the BPM system and external rules engines and repositories.