Blog
Cause-Effect Graphing: Notation, Process, and Examples

Abhilash
Published on

Table of contents
Lorem ipsum
Lorem ipsum
Lorem ipsum
Lorem ipsum
Lorem ipsum
Cause-effect graphing is a black-box test design technique for working out test cases when several conditions combine to decide what a system does. That covers a lot of enterprise software, from permission systems and eligibility checks to pricing rules.
In this guide, we’ll cover the notation, the constraints, the step-by-step process, two full worked examples, how it compares with other black-box techniques, common mistakes, and how to use it on AI-written business logic.
What is Cause-Effect Graphing?
Cause-effect graphing turns a written specification into a diagram that shows how input conditions (causes) lead to outputs (effects). You then turn that diagram into a decision table, and each column of the table becomes a test case.
It has three parts:
Part | What It Is |
|---|---|
Causes | The input conditions the system reacts to. Each one is either true or false |
Effects | The outputs or responses the system produces. Each one is also true or false |
The graph | A diagram linking causes to effects using logic (identity, NOT, AND, OR), plus constraints that rule out impossible combinations |
The result is a set of tests that covers every distinct outcome in the rules, without testing every possible combination of inputs. That’s what makes it worth learning.
Cause-effect graphing sits alongside equivalence partitioning, boundary value analysis and decision table testing. Its specific job is handling cases where several inputs combine in non-obvious ways. If one input maps to one output, simpler techniques work fine. When the outcome depends on how several conditions interact, cause-effect graphing is the right tool.
Why Cause-Effect Graphing Still Matters
The technique dates back to the early 1970s, so it’s fair to ask why it still matters. The answer is the kind of problem it solves, which is everywhere in modern software.
Enterprise applications are full of rules:
A permission system decides what someone can see based on their role, subscription and account status
An eligibility engine decides whether someone qualifies based on age, income, where they live and their history
A pricing engine decides what a customer pays based on volume, contract terms, region and current promotions
Each one is a set of conditions that combine to produce an outcome, which is exactly what cause-effect graphing is built for.
The other black-box techniques don’t cover this. Equivalence partitioning tells you which values to pick for one input. Boundary value analysis tells you where the risky edges are.
Neither tells you how several inputs work together to decide an outcome. That’s the gap cause-effect graphing fills.
Cause-Effect Graphing Notation
The notation is small, so you can learn it in an afternoon, though using it well takes practice. There are four functions that link causes to effects, and five constraints that limit which combinations are allowed.
The Four Functions
Function | What It Means | When to Use It |
|---|---|---|
Identity | The effect is true when the cause is true | One condition directly triggers one outcome |
NOT | The effect is true when the cause is false | An outcome happens because something is missing |
OR | The effect is true when at least one cause is true | Any one of several conditions is enough |
AND | The effect is true only when all causes are true | Every condition has to be met |
These four are enough to express any logical rule. For example, take the rule “accept the claim when the policy is active and either the documents are complete or a waiver is on file”. It breaks down into an OR inside an AND:
The OR joins the documents and waiver conditions, so either one is enough. The AND then combines that result with the policy condition, so the policy also has to be active. Drawn like this, you can see straight away that the claim can’t be accepted on an inactive policy, whatever paperwork is attached.
The Five Constraints
Constraints stop the graph producing tests for situations that can’t happen in real life. Skipping them is the most common mistake people make with this technique. Without them, you end up with tests for impossible cases, which waste time and fail for no real reason.
Constraint | Symbol | What It Means | Example |
|---|---|---|---|
Exclusive | E | Both can’t be true at once, but both can be false | A payment is by card or bank transfer, never both |
Inclusive | I | At least one must be true | The user must pick at least one delivery option |
One and only one | O | Exactly one must be true | A required single-choice field |
Requires | R | If the first is true, the second must be too | Express shipping needs a delivery address |
Mask | M | If one effect is true, another is forced to be false. This one links effects, not causes | A rejection stops any “processing” message appearing |
Getting the constraints right is what separates real use of the technique from textbook use. If you draw the functions but skip the constraints, your decision table fills up with columns for situations your system will never see.
How to Do Cause-Effect Graphing, Step by Step
Step | What to Do | What to Watch Out For |
|---|---|---|
1. Break up the specification | Split it into smaller pieces, like separate features or rule sets, and graph each one separately | Keep each graph to roughly 15 causes or fewer, and don’t split a single rule across two graphs |
2. List the causes and effects | Pull out every input condition and every outcome. Each must be something that’s either true or false | Watch for sentences that hide two or three conditions in one |
3. Draw the graph | Put causes on the left, effects on the right, connect them with the logic functions and add constraints | Use the drawing to spot gaps, like combinations the spec never mentions |
4. Turn it into a decision table | Each column is a unique combination of causes that gives a distinct set of effects | The table is what you actually test from |
5. Write the test cases | Turn each column into a test with inputs, expected results, test data and preconditions | Link each test back to the requirement it checks |
Step 2 is where precision matters most. A line like “the user submits a claim with valid documentation” actually contains three causes: the user submits a claim, documents are attached, and the documents are valid.
If you treat that as one cause, you lose the whole point, because you can’t see how those conditions interact. Get into the habit of reading every sentence and asking whether it’s hiding more than one condition.
Why You Need Both the Graph and the Decision Table
If the decision table is what you test from, why draw the graph at all? Because drawing it catches three kinds of mistakes that writing the table directly usually misses:
Missing causes: specs often imply a condition without saying it. Drawing the graph makes you list every condition that affects an outcome.
Missing effects: specs usually describe the normal cases and skip the exceptions. In a graph, an outcome with no path to it, or a combination with no outcome, stands out straight away.
Missing constraints: specs rarely say which combinations are impossible. Drawing the graph makes you think about every combination.
The graph is where you do the thinking. The table is what you hand over. You can skip the graph, but you lose the checking it gives you.
Worked Example 1: Insurance Claim Submission
Most cause-effect graphing examples use light switches or vending machines. They show the mechanics, but not how it works on real business rules. Here’s a more realistic one.
An insurance marketplace lets brokers submit claims through a portal. The rules say:
If the policy was active on the loss date, the claim is within coverage limits and the required documents are attached, the claim goes to an underwriter for review.
If the policy wasn’t active on the loss date, the claim is rejected for a policy issue.
If the claim is outside the coverage limits, it’s rejected for a coverage issue.
If the required documents aren’t attached, the claim goes back to the broker for more information.
Causes:
ID | Cause |
|---|---|
C1 | The broker submits a claim |
C2 | The policy was active on the loss date |
C3 | The claim is within coverage limits |
C4 | The required documents are attached |
Effects:
ID | Effect |
|---|---|
E1 | Claim sent for underwriter review |
E2 | Claim rejected, policy issue |
E3 | Claim rejected, coverage issue |
E4 | Claim returned for more information |
Logic:

In the graph above, C1 acts as the gate everything depends on, and the three rejection paths look almost the same, each just adding one more NOT. That’s much harder to see in the written rules.
The Decision Table
A dash (–) means that cause doesn’t change the outcome, because an earlier cause has already decided it.
Test 1 | Test 2 | Test 3 | Test 4 | |
|---|---|---|---|---|
C1: Claim submitted | True | True | True | True |
C2: Policy active | True | False | True | True |
C3: Within limits | True | – | False | True |
C4: Documents attached | True | – | – | False |
E1: Underwriter review | ✔ | |||
E2: Rejected, policy | ✔ | |||
E3: Rejected, coverage | ✔ | |||
E4: Returned for info | ✔ |
That’s four test cases. In Test 2, once the policy isn’t active, it doesn’t matter whether the claim is within limits or has documents. It gets rejected for the policy issue either way, so you don’t need to try every combination.
Without the technique, four true-or-false causes give you 16 possible combinations (2 × 2 × 2 × 2). The logic collapses those 16 into four tests, one for each distinct outcome.
Adding more tests wouldn’t find anything new, because every other combination ends up in one of these four outcomes. With eight or ten causes, the saving is much bigger, often turning hundreds of combinations into a handful of tests.
Each of those four tests is really a journey. The broker submits through the portal, the claim is checked against the policy, and the outcome lands in the underwriter queue or back with the broker. Virtuoso QA’s end-to-end testing follows that whole path in one test, from the portal to the final claim status.
Worked Example 2: Access Control with an Admin Override
Here’s a second example, using the kind of permission rule AI coding assistants often get subtly wrong.
A document system has these rules:
An admin can always view a record, even if it’s locked.
Anyone else can view a record only if they own it, their account is active and the record isn’t locked.
Otherwise, access is denied and the attempt is logged.
Causes:
ID | Cause |
|---|---|
C1 | User is an admin |
C2 | User owns the record |
C3 | User’s account is active |
C4 | Record is locked |
Effects:
ID | Effect |
|---|---|
E1 | Record shown |
E2 | Access denied and logged |
Logic:
✏️ Plain text
Decision table
Test 1 | Test 2 | Test 3 | Test 4 | Test 5 | |
|---|---|---|---|---|---|
C1: Admin | True | False | False | False | False |
C2: Owner | – | True | False | True | True |
C3: Account active | – | True | – | False | True |
C4: Record locked | True | False | – | – | True |
E1: Record shown | ✔ | ✔ | |||
E2: Denied and logged | ✔ | ✔ | ✔ |
Test 1 checks the override. An admin should see a locked record. Test 5 is the one that usually catches bugs: an active owner trying to open a locked record should be denied.
A common AI-written mistake is to check the lock only for non-owners, which lets Test 5 through. Another is to apply the lock to admins as well, which breaks Test 1.
How Many Test Cases Does Cause-Effect Graphing Produce?
With n true-or-false causes, there are 2ⁿ possible combinations. That grows fast:
Number of Causes | Possible Combinations |
|---|---|
4 | 16 |
10 | 1,024 |
20 | 1,048,576 |
Testing all of them isn’t realistic, and picking some at random doesn’t follow any logic. Cause-effect graphing cuts the number down in two ways:
Combinations with the same outcome are grouped: Once one combination has been tested for an outcome, others that give the same outcome add nothing.
Impossible combinations are removed: The constraints rule out whole groups that can’t happen.
You’re left with one test for each distinct outcome. That’s the smallest set that still checks every rule, and it’s why the technique catches bugs where conditions interact, which random or one-input-at-a-time testing misses.
When to Use Cause-Effect Graphing
Use It When | Use Something Else When |
|---|---|
Several conditions combine to give different outcomes, like eligibility, pricing, permissions or compliance rules | One input leads to one output. Use equivalence partitioning and boundary value analysis |
Conditions are clearly true or false | Inputs are continuous ranges. Use techniques that handle ranges directly |
Outcomes are a small set of distinct results | Outputs are continuous numbers, like a calculated price |
There are roughly 15 to 20 causes or fewer | There are many more. Break the spec up, or use pairwise testing |
The logic is rule-based (“if these, then that”) | The logic is a calculation. Use white-box techniques |
Order doesn’t matter | Order matters and the system moves between states. Use state transition testing |
Picking the right technique for the problem matters. If you use cause-effect graphing for everything, you’ll overcomplicate simple problems and struggle with ones it was never designed for.
How It Compares with Other Black-Box Techniques
Cause-effect graphing works alongside the other techniques rather than replacing them.
Technique | What It Decides | How It Works with Cause-Effect Graphing |
|---|---|---|
Equivalence partitioning | Which groups of values exist for one input | Picks the real values that make a cause true or false, like what counts as “policy active” |
Boundary value analysis | The risky values at the edges of a range | Tests the exact point where a cause flips, like the coverage limit |
Decision table testing | Which combination of conditions leads to which outcome | It’s the table cause-effect graphing produces. The two are steps in the same method |
How the system behaves across states and events | Covers order-dependent behaviour that cause-effect graphing doesn’t model |
On a rules-heavy feature, a good tester uses all of them. Equivalence partitioning and boundary value analysis pick the values, cause-effect graphing works out how the conditions combine, and the decision table records the result.
Common Cause-Effect Graphing Mistakes
Mistake | What Goes Wrong |
|---|---|
1. Skipping the constraints | You get tests for impossible situations, which waste time and fail for no real reason |
2. Combining several conditions into one cause | “Submits a valid claim with documents” is three causes. Treating it as one hides the interactions you’re trying to test |
3. Letting the graph get too big | A graph with 30 causes is unworkable. Break it into smaller graphs instead |
4. Skipping the graph | It’s quicker, but you lose the checking that finds missing causes, effects and constraints |
5. Not linking tests to requirements | When the spec changes, you don’t know which tests are affected |
6. Using it on the wrong kind of problem | Continuous values, calculations and step-by-step workflows are better handled by other techniques |
Using Cause-Effect Graphing on AI-Written Code
AI coding assistants now write a lot of eligibility rules, permission checks, workflow gates and pricing logic before anyone reviews it. The code often looks right but misses how conditions interact, and the problem only shows up in production.
Cause-effect graphing helps in two ways:
It finds missing logic: Listing every cause, effect and combination shows the gaps unit tests often miss, like the locked-record case in the access control example.
It finds extra logic: AI sometimes adds conditions or special cases nobody asked for. Comparing the graph with the original spec shows where the code has drifted.
So the technique becomes a review tool as well as a test design tool. Graph the rule from the spec, then check the AI-written code against it before writing your tests.
If AI is writing more of your business rules, it makes sense to use it in your testing too. Virtuoso QA’s AI-powered test automation helps you build and maintain tests for that logic, with your team approving every change.
How Virtuoso QA Helps After the Graph
Cause-effect graphing does the thinking. Virtuoso QA takes the decision table and keeps those rules tested as your application changes.
Readable tests from each column: Each decision table column becomes a plain English test, like “submit a claim on an inactive policy and check it’s rejected for a policy issue”, so analysts and reviewers can see exactly which rule it checks.
Rules drafted from your spec: Touchstone reads your requirements and policy documents and drafts requirements and tests, each citing the clause it came from. Your team still decides which cases matter and approves each one before it’s built.
Links back to the rule: Each test stays linked to the requirement it checks, so when a rule changes you can see which tests need updating.
Tests that keep running: When a screen changes, Virtuoso QA suggests fixes for your team to approve, so rule tests don’t break every release. They can run across 2,000+ browser and OS combinations.
Clear failure details: When a rule test fails, you get the failing step, screenshots and logs, which makes it quicker to tell whether the rule broke or something else went wrong.
To see how AI drafts tests from your requirements while your team approves each one, take a look at Virtuoso QA’s agentic test generation.
Business rules change all the time, with new limits, new roles and new exceptions. To keep every decision table column checked on each release, take a look at Virtuoso QA’s regression testing.
Frequently Asked Questions
What are the Notations Used in Cause-Effect Graphing?
What is the Difference Between Cause-Effect Graphing and Decision-Table Testing?
When Should Cause-Effect Graphing Be Used?
What is a Cause in Cause-Effect Graphing?
What is an Effect in Cause-Effect Graphing?
How Does AI-Assisted Coding Affect Cause-Effect Graphing?
Written by

Abhilash
Industry Analyst, Test Automation
Abhilash tracks how AI is reshaping software testing, from pairwise coverage to regulatory accountability, and writes research-led pieces that cut through vendor noise with numbers.










