Separating Business Rules From Requirements Increases Agility

mixing chips

We’ve written in the past about why it is important to gather and manage requirements. In short, you avoid some costly mistakes, and fix others before they become too expensive. We’ve also started exploring how business requirements and business rules live and play together. But why should we bother to separate business rules from requirements? One reason is to increase your company’s agility.

Benefits of Separating Business Rules

There are some significant benefits to separating business rules from requirements, and we learn many of them in our interview with James Taylor from a couple weeks ago. James’ new book, Smart (Enough) Systems, focuses on the benefits of automating decisions, but some of those benefits can be achieved to a lesser extent, just by isolating the business rules that would then ideally be automated. The main benefit that comes to mind is the increased agility of the company when it comes to changing their rules and processes. By isolating the business rules, they become easier to change and manage.

David Wright recently wrote an article at RQNG titled The Business Rules Approach. In it, he also points to the speed with which a company can change rules – not only as a benefit of managing business rules separately, but as a need to adapt and respond to today’s markets.

How Is Agility Increased?

There are two main ways in which agility is increased when separating business rules from requirements. First, the requirements management process will take less time. Second, the company can implement changes to their solution more quickly.

Less Time Managing Requirements

One best practice in writing requirements is to write concise requirements. You can’t just write the requirements with fewer words – that might lead to ambiguity. But you can dramatically simplify the writing, reviewing, and interpreting of requirements by isolating the business rules that represent decisions within a requirements document.

As an example, a process flow might include a decision – “Do we have the needed paperwork to approve the loan?” And that decision might represent a series of rules:

  • If the applicant’s credit rating is above 700, we only need a valid driver’s license and SSN.
  • If the applicant’s credit rating is between 600 and 700, we need a recent credit check, driver’s license, and SSN.
  • If the applicant’s credit rating is below 600, we need a cosigner on the loan.
  • If a co-signer is required, the co-signer’s credit rating must be above 600.
  • If the applicant’s credit rating is below 600, we must run a new credit check, and have a valid driver’s license and SSN.
  • If the co-signer’s credit rating is below 700, we must have a recent credit check for the co-signer, as well as a valid driver’s license and SSN.
  • If the co-signer’s credit rating is above 700, we only need a valid driver’s license and SSN for the co-signer.
  • If a recent (within 6 months of application date) is not available, a new one must be run.

In a process flow diagram, we could create a series of decision boxes – always requiring the applicant’s SSN and driver’s license, sometimes requiring a credit check (and some of those times requiring the credit check to be new), and sometimes requiring a co-signer. We would then have more branches for the co-signer.

This flow diagram would be pretty complicated. This can be simplified by embedding a decision tree into the requirements documents. However, you still are applying the (potentially) heavyweight requirements approval and validation process to this decision tree. You are also asking your developers to review this decision tree and determine how to implement it. A great developer will see when it makes sense to abstract these decisions from the code, and a less-great developer will embed them. In either situation, you’re asking your developer to spend time thinking about this abstraction – and thinking about how mutable the particular decisions are.

As an analyst, you are better informed about the mutability of the decisions. By documenting the decision as a single decision in the requirements document (“Do we have the needed paperwork?”) that references the enumerated business rules. It is also easier to review the rules and validate them when they are isolated. Business people who don’t have backgrounds designing software do find it easier to review these steps when presented in the context of a decision – and it is easier to grab the context of the decision from a simpler process flow diagram.

Less Effort To Change

Even if you don’t automate the decision, you still make it much easier to review changes. If the thresholds change from 700 and 600 to 650 and 550, it is trivial to update the isolated business rules. It is also an easier process to approve those changes when you are only updating and reviewing the business rules – and not a broader requirements document.

Developers abstract “magic numbers” like 700 and 600 (in this example) into variables and constants when they embed them into code. We are doing the same thing by isolating the business rules from the requirements (which then reference the rules).

What about changes that are more structural in nature? Imagine that we redefine the criteria – eliminating the 700+ rules, and changing the 600 rule to 650 – and always require a new credit check for co-signers. Then we also decide to add a new document – say proof of residence, or proof of employment. If we were managing this within our requirements document, it would take extra time to validate – and possibly re-implement the solution. With a solution like James proposes in his book, the business analyst could make the changes directly into the rules-processing engine and the software would not even need to be modified. In either case, the approval and change process is faster.

3 thoughts on “Separating Business Rules From Requirements Increases Agility

  1. You make a good point about separating business requirements from business rules. Having less effort and less time to change are great benefits of separating those two..

  2. I totally agree. The fact that breaking down tasks into smaller pieces makes the process easier, gives this idea a strong point. We don’t have to involve everything on the process if it doesn’t need it.

  3. Y’all are both right – and welcome to Tyner Blain, and thanks for reading and commenting!

    There are some interesting things to think about, especially with implicit rules. If we abstract the rules out of the requirements, then we need a way to reference those rules. But what about “implicit rules” like Roger mentions in the discussion on another article.

    For example – a rule that specifies that steps in a use case must happen in a particular order (user is authenticated prior to transaction processing). We should make sure we capture that as well – even if it only prevents a violation of the rule during a future revision of the requirements.

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.