Skip to content

Systems and records

Business process branch labeling: conditions, choices and outcomes

By SourceX Editorial · Updated

9 sections

Short answer

To label decision branches in a business workflow, classify each split first, then record for every case the condition that decided it, the inputs known at that moment, the path taken, the paths available but not taken, who or what decided, and the outcome that followed. Tie each value to evidence, mark the rest unknown, and reconcile branch counts to source system totals before using the labels.

Evaluation split

Business process branch

This page covers business process branch labeling: conditions, choices and outcomes.Illustrative

Key takeaways

  • Classify each split before labeling it: exclusive, inclusive, parallel, event race, loop or implicit skip each need a different label.
  • A branch label needs the untaken alternatives and the downstream outcome, or it records a route rather than a decision.
  • Separate configured rules, written policy and human judgment, and never label a default path as else.
  • Inputs count only if they were set before the decision; clock drift and identifier mismatches can flip a label.
  • Reconcile arrivals and branch counts to trusted totals and publish a second-reviewer agreement check with the labels.

How do you label decision branches in a business workflow?

Label a branch at every point where cases that arrived the same way leave by different paths. For each case at that point, record the kind of split, the condition that decided it, the inputs that were known at decision time, the path taken, the paths that were available but not taken, who or what decided, and the outcome that followed. A branch label without the untaken alternatives and the outcome is only a route; with them it becomes a decision a model can learn from.

This matters because most operational event data is stored as a flat sequence of activities per case. Process mining tools can reconstruct a map from that sequence, but the map shows that cases split, not why. Business process branch labeling adds the why, case by case, and ties it back to evidence in the source systems.

The protocol on this page is written for data and process teams preparing workflow histories for analysis, automation design or licensing. It assumes you can already extract cases with an identifier, an activity name and a timestamp.

Which kind of split are you looking at?

Not every fork in a process map is a decision, so classify the split before labeling it. BPMN, the common notation for business processes, distinguishes gateway types, and Camunda's documentation describes how each behaves when it runs. An exclusive gateway picks exactly one outgoing path based on data. An inclusive gateway takes every path whose condition is true. A parallel gateway takes all paths, so nothing was chosen. An event-based gateway waits and follows whichever event arrives first.

Each type needs a different label. An exclusive split gets one chosen branch and the conditions of the rejected ones. An inclusive split gets the set of branches taken. A parallel split gets no decision label at all, only a check that every branch ran. An event-based split gets the event that won the race and the ones that did not happen in time.

Which kind of split are you looking at?
Split typeHow it behavesWhat to labelCommon trap
Exclusive (XOR)Exactly one outgoing path, chosen on data; a default path catches cases where no condition holdsBranch taken, condition met, conditions of untaken branchesTreating the default path as a reason when it only means nothing else matched
Inclusive (OR)Every path whose condition holds is taken; default only if none holdSet of branches taken and the condition for eachLabeling only the first branch observed
Parallel (AND)All paths taken; work runs concurrently and joins laterNo decision; check that every branch completed before the joinReading the order of concurrent work as a choice
Event-based raceWaits for the first of several events, such as a reply or a timeoutWinning event and how long the case waitedIgnoring the timeout path because it has no user action
Loop or reworkCase returns to an earlier stepReason for the return and iteration countCounting the second pass as a new case
Implicit skipA step is simply absent for some casesWhether the skip was allowed, waived or missedAssuming absence means not applicable

Finding the branch points in raw event data

Start from a clean event log. The XES standard for event logs, published by IEEE as Std 1849-2016, names the core attributes most tools expect: the activity name of each event, its timestamp and its lifecycle transition, such as start or complete. If your extract lacks a case identifier, an activity and a timestamp on every row, fix that before looking for branches.

Then let the data show where cases diverge. The open source library pm4py includes a decision mining module that treats any place in a discovered Petri net with two or more outgoing arcs as a decision point, and for each one records the attributes that preceded the choice of a particular path. That is a good candidate list. It is not the answer, because a discovered model can invent splits from noise and miss splits that live in a different system.

Workflows that span several records, such as an order, its shipments and its invoices, are better handled as object-centric logs. The OCEL 2.0 specification lets one event relate to several objects and supports qualified object-to-object relations, so a branch on a shipment can be tied back to the order whose terms decided it.

  • Count arrivals at each candidate point and the cases leaving on each path; a real decision point has stable paths, while noise produces many rare ones.
  • Confirm each candidate with the process owner, who can say whether the split is a rule, a judgment or an artifact of data entry.
  • Look for splits the log cannot see, such as approvals made in email or chat, and add them as manual decision points with their own evidence.

The branch condition and outcome annotation protocol

The protocol attaches one annotation row to each case at each confirmed decision point. The fields below are the minimum; teams with richer sources add fields, but they should not drop any of these. Every value must point to evidence, and values that cannot be evidenced are marked unknown with the reason rather than filled with a guess.

At a glance

The branch condition and outcome annotation protocol

The branch condition and outcome annotation protocol
FieldWhat it capturesAllowed values or formatEvidence required
decision_point_idThe confirmed split, stable across casesIdentifier plus split type from the classification tableProcess owner sign-off on the point
case_and_objectsThe case and any related objects at the splitCase ID plus object IDs with their typesJoin keys present in the source records
inputs_at_decisionAttribute values known when the choice was madeName, value and the timestamp each value was last setValues timestamped before the decision event
condition_sourceWhere the deciding condition came fromconfigured_rule, written_policy, human_judgment, external_event, unknownRule configuration, policy text, note or message
condition_textThe condition that held for the path takenPlain-language statement, quoted where possibleThe same source as condition_source
branches_availablePaths the case could have takenList of path names from the decision pointProcess model or policy listing the options
branch_takenThe path or set of paths actually followedOne path, or a set for inclusive splitsFirst event on each taken path
decided_bySystem rule or the role that chosesystem or a role code, never a personal nameUser or service account on the decision event
outcomeWhat happened downstream within a set windowOutcome code, window length and whether the case reopenedClosing, reversal or follow-up events
label_confidenceHow the label was establishedobserved, inferred, unknownInferred labels name the rule used to infer them

Is the condition a rule, a judgment or a default?

The condition_source field matters more than any other, because rules, judgments and defaults teach different lessons. A configured rule can be read straight from the workflow engine. In Camunda, for example, an exclusive gateway evaluates its conditions in the order they appear in the process definition and takes the first one that holds, and if none holds it takes the default flow, which carries no condition of its own. Order matters: two overlapping conditions resolve to whichever comes first.

That default flow is the most common labeling mistake. Cases routed by default did not meet a condition called else; they failed every other condition. Label them with the conditions they failed, or the annotation hides the actual decision. Camunda also notes that when no condition holds and no default exists, the engine raises an incident, which is itself a branch outcome worth recording.

Human judgment gets a different treatment. Record the inputs the person had, the option they chose and any note they left, and mark the condition as human_judgment. Do not write a rule into condition_text that the person never applied. If a team later learns the rule from the labeled cases, that is a finding; writing it in advance would bias the data.

Could clock drift, mismatched identifiers or a missing transition change the branch you labeled?

Yes, each one can flip a label, so test for them before trusting the annotations. Clock drift between systems can place an input after the decision it supposedly drove, which turns a valid rule into an apparent judgment. Identifier mismatches can attach a case to the wrong order. A missing lifecycle event can make a parallel split look like a choice, because one branch appears never to start.

  • Map every source clock to one time zone and record the offset; recheck any input stamped within a few minutes of its decision.
  • Reject an input value whose timestamp is later than the decision event, unless the source proves it was known earlier.
  • Test joins in both directions: every case at a decision point should resolve to exactly one record in each source system.
  • Check that every branch of a parallel split has a start and complete event before the join; a missing one is a gap, not a choice.
  • For event-based races, confirm the timer duration in the configuration, because a timeout path depends on it.
  • Record retries and concurrent work separately, so a retried step is not counted as a second decision.

Worked example (illustrative): a return request that splits four ways

This example is invented for illustration and every count in it is illustrative. An online retailer's returns desk handles requests in a help desk tool and settles them in its order system. The decision point is the resolution step, with four paths: full refund, store credit, replacement, or denial. Replacement and refund can both happen when part of an order is replaced and the rest refunded, so the split is inclusive, not exclusive.

Over one quarter, 1,200 requests reach the point. The workflow rule sends requests inside the return window with an unopened item straight to full refund; that path is a configured rule. Damaged-on-arrival requests are routed to an agent who chooses refund, replacement or both after viewing photos; those are judgments. Requests outside the window fall through to a default that offers store credit, so they are labeled with the condition they failed, outside_return_window, not with else.

  • The exception: 25 denied cases reopened after the customer disputed the decision and later received refunds. Those cases loop back to the decision point. Annotate both passes, keep the first label, and set the first pass's outcome to reversed, because the reversal is the most useful signal in the set.
  • Reconciliation check: the table counts each case once, so its rows sum to the 1,200 arrivals. Within the agent-choice row, 38 cases took both refund and replacement; a per-path count would therefore exceed 1,200, which is why the counting rule is stated beside every inclusive split.
Worked example (illustrative): a return request that splits four ways
Path (illustrative)CasesCondition sourceLabel note
Full refund, automatic610configured_ruleInside window and unopened, read from the rule configuration
Refund or replacement, agent choice340human_judgmentInputs: photos, order value band, customer history; branch set recorded
Store credit by default180configured_ruleLabeled with the failed condition, not as else
Denied70written_policyPolicy clause cited in the agent's closing note

Checking labeled branches against the source system totals

Before anyone uses the annotations, reconcile them to totals the business already trusts. Arrivals at each decision point should match the count of cases that reached that step in the source system for the same period. Branch counts for an exclusive split should sum to arrivals; for an inclusive split, the counting rule must be stated. Outcome counts should match independent reports, such as refunds issued in the finance system.

Measure agreement on the judgment labels as well. Have a second reviewer annotate a random subset of cases at each decision point without seeing the first labels, then compare. Where they disagree, refine the field definitions rather than overruling one reviewer. Publish the reconciliation results and the agreement check with the dataset, so a user can see what was tested and what was not.

What branch labels add when workflow histories are licensed

Teams building agents for operations work want to know not only what happened but which choices were available and why one was taken, so labeled branches and their outcomes are often the most valuable layer of a workflow dataset. They also make privacy review easier, because the protocol records roles and conditions rather than names.

For companies weighing whether to license such histories, SourceX runs the work from qualification and rights review through contracting, preparation, delivery and payment. Its first step, a brief look at the company, asks for no event logs. Records move only after the company signs off on the scope and terms and executes the agreement.

Frequently asked questions

What should the branch condition and outcome annotation protocol include?

At minimum: a stable decision point identifier and split type, the case and related objects, the inputs known at decision time, where the condition came from, the condition itself, the available and taken branches, who decided, the downstream outcome and a confidence flag. Every value points to evidence or is marked unknown.

Is a gateway in a process model the same as a decision?

Not always. Exclusive, inclusive and event-based gateways involve a choice or a race, but a parallel gateway sends work down every path, so nothing is decided there. Classify the split first, then label only the ones that involve a choice.

Can process mining find all the branch points for us?

It finds good candidates. Decision mining in tools such as pm4py looks for places with two or more outgoing paths and the attributes that preceded each choice, but discovered models can include noise and miss decisions made outside the logged systems. Confirm each point with the process owner.

How should default or else paths be labeled?

With the conditions the case failed, not with the word else. A default path means no other condition held, so the useful label lists what was not true, such as outside the return window. That keeps the decision visible to anyone using the data.

How many cases need a second reviewer?

Enough at each decision point to see whether the definitions are applied consistently, chosen at random rather than by convenience. The exact number depends on how many paths and judgment calls the point has; state the sample and the agreement result alongside the dataset.

Sources

  • Camunda's exclusive gateway evaluates conditions in definition order, takes the first that holds, falls back to a default flow, and raises an incident when no condition holds and no default exists. Source
  • Camunda's inclusive gateway takes every outgoing path whose condition is fulfilled, and the default only when none is. Source
  • Camunda's event-based gateway waits for the first of its events and follows that event's path. Source
  • Camunda's parallel gateway takes all outgoing paths, which run concurrently and are joined later. Source
  • pm4py's decision mining module treats places with two or more outgoing arcs as decision points and records the attributes that preceded each choice. Source
  • XES, published as IEEE Std 1849-2016, defines the activity name, timestamp and lifecycle transition attributes of events. Source
  • The OCEL 2.0 specification relates events to several objects and supports qualified object-to-object relations. Source

See if your company qualifies

A short company assessment. No data uploads are needed.

See if your company qualifies