BPMN Fundamentals: Business Process Model and Notation

Business Process Model and Notation (BPMN) is the international standard for graphically representing business processes. BPMN 2.0 provides standardized notation for modeling, analyzing, and optimizing business workflows.

What is BPMN?

BPMN is a graphical notation language for describing business processes. It was developed by the Object Management Group (OMG) and has been standardized as ISO 19510 since 2011.

Key Features of BPMN

Standardized Notation: Unified symbols and rules
Graphical Representation: Visual process modeling
Technology-Agnostic: Cross-platform application
Executable Processes: Direct implementation in workflow engines

Core BPMN Elements

1. Flow Objects

Events

Events represent triggers or outcomes within a process:

<!-- Start Event -->
<bpmn:startEvent id="startEvent" name="Start Process"/>

<!-- End Event -->
<bpmn:endEvent id="endEvent" name="End Process"/>

<!-- Intermediate Event -->
<bpmn:intermediateCatchEvent id="timerEvent" name="Wait Time">
  <bpmn:timerEventDefinition/>
</bpmn:intermediateCatchEvent>

Event Types:

Start Event: Process initiation
End Event: Process completion
Intermediate Event: Intermediate occurrences

Activities

Activities represent work steps within the process:

<!-- Task -->
<bpmn:task id="task1" name="Enter Data"/>

<!-- User Task -->
<bpmn:userTask id="userTask1" name="Approval Required"/>

<!-- Service Task -->
<bpmn:serviceTask id="serviceTask1" name="Automated Check"/>

<!-- Sub-Process -->
<bpmn:subProcess id="subProcess1" name="Detailed Process">
  <bpmn:startEvent id="subStart"/>
  <bpmn:task id="subTask1"/>
  <bpmn:endEvent id="subEnd"/>
</bpmn:subProcess>

Gateways

Gateways control process flow:

<!-- Exclusive Gateway (XOR) -->
<bpmn:exclusiveGateway id="gateway1" name="Decision"/>

<!-- Parallel Gateway (AND) -->
<bpmn:parallelGateway id="gateway2" name="Parallelization"/>

<!-- Inclusive Gateway (OR) -->
<bpmn:inclusiveGateway id="gateway3" name="Multiple Choice"/>

2. Connecting Objects

Sequence Flows

Connect activities and gateways:

<bpmn:sequenceFlow id="flow1" sourceRef="startEvent" targetRef="task1"/>
<bpmn:sequenceFlow id="flow2" sourceRef="task1" targetRef="gateway1"/>

Message Flows

Enable communication between separate processes:

<bpmn:messageFlow id="msgFlow1" sourceRef="pool1" targetRef="pool2"/>

Associations

Link artifacts to flow objects:

<bpmn:association id="assoc1" sourceRef="dataObject1" targetRef="task1"/>

3. Pools and Lanes

Pools

Represent participants in the process:

<bpmn:pool id="pool1" name="Department A">
  <bpmn:laneSet>
    <bpmn:lane id="lane1" name="Staff"/>
    <bpmn:lane id="lane2" name="Management"/>
  </bpmn:laneSet>
</bpmn:pool>

Lanes

Organize activities within pools:

<bpmn:lane id="lane1" name="Sales">
  <bpmn:flowNodeRef>task1</bpmn:flowNodeRef>
  <bpmn:flowNodeRef>gateway1</bpmn:flowNodeRef>
</bpmn:lane>

4. Data Objects

Data Objects

Represent information within the process:

<bpmn:dataObject id="data1" name="Customer Data"/>
<bpmn:dataStoreReference id="store1" name="Database"/>

Practical BPMN Example

Modeling an Order Process

<?xml version="1.0" encoding="UTF-8"?>
<bpmn:definitions xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL"
                  xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"
                  xmlns:dc="http://www.omg.org/spec/DD/20100524/DC"
                  xmlns:di="http://www.omg.org/spec/DD/20100524/DI"
                  id="Definitions_1" targetNamespace="http://bpmn.io/schema/bpmn">
  
  <bpmn:process id="OrderProcess" isExecutable="false">
    
    <!-- Start Event -->
    <bpmn:startEvent id="StartEvent_1" name="Order Received">
      <bpmn:outgoing>Flow_1</bpmn:outgoing>
    </bpmn:startEvent>
    
    <!-- Task: Review Order -->
    <bpmn:userTask id="Task_1" name="Review Order">
      <bpmn:incoming>Flow_1</bpmn:incoming>
      <bpmn:outgoing>Flow_2</bpmn:outgoing>
    </bpmn:userTask>
    
    <!-- Gateway: Decision -->
    <bpmn:exclusiveGateway id="Gateway_1" name="Order Valid?">
      <bpmn:incoming>Flow_2</bpmn:incoming>
      <bpmn:outgoing>Flow_3</bpmn:outgoing>
      <bpmn:outgoing>Flow_4</bpmn:outgoing>
    </bpmn:exclusiveGateway>
    
    <!-- Task: Check Inventory -->
    <bpmn:serviceTask id="Task_2" name="Check Inventory">
      <bpmn:incoming>Flow_3</bpmn:incoming>
      <bpmn:outgoing>Flow_5</bpmn:outgoing>
    </bpmn:serviceTask>
    
    <!-- Task: Reject Order -->
    <bpmn:userTask id="Task_3" name="Reject Order">
      <bpmn:incoming>Flow_4</bpmn:incoming>
      <bpmn:outgoing>Flow_6</bpmn:outgoing>
    </bpmn:userTask>
    
    <!-- End Events -->
    <bpmn:endEvent id="EndEvent_1" name="Order Confirmed">
      <bpmn:incoming>Flow_5</bpmn:incoming>
    </bpmn:endEvent>
    
    <bpmn:endEvent id="EndEvent_2" name="Order Rejected">
      <bpmn:incoming>Flow_6</bpmn:incoming>
    </bpmn:endEvent>
    
    <!-- Sequence Flows -->
    <bpmn:sequenceFlow id="Flow_1" sourceRef="StartEvent_1" targetRef="Task_1"/>
    <bpmn:sequenceFlow id="Flow_2" sourceRef="Task_1" targetRef="Gateway_1"/>
    <bpmn:sequenceFlow id="Flow_3" name="Yes" sourceRef="Gateway_1" targetRef="Task_2"/>
    <bpmn:sequenceFlow id="Flow_4" name="No" sourceRef="Gateway_1" targetRef="Task_3"/>
    <bpmn:sequenceFlow id="Flow_5" sourceRef="Task_2" targetRef="EndEvent_1"/>
    <bpmn:sequenceFlow id="Flow_6" sourceRef="Task_3" targetRef="EndEvent_2"/>
    
  </bpmn:process>
  
</bpmn:definitions>

BPMN Gateway Types in Detail

Exclusive Gateway (XOR)

Only one outgoing path can be taken:

// Java implementation of an Exclusive Gateway
public class ExclusiveGateway {
    private Map<String, String> conditions;
    
    public String evaluateCondition(Map<String, Object> context) {
        for (Map.Entry<String, String> condition : conditions.entrySet()) {
            if (evaluateExpression(condition.getKey(), context)) {
                return condition.getValue();
            }
        }
        return null; // Default Path
    }
    
    private boolean evaluateExpression(String expression, Map<String, Object> context) {
        // Condition evaluation implementation
        return context.containsKey(expression) && (Boolean) context.get(expression);
    }
}

Parallel Gateway (AND)

All outgoing paths are activated simultaneously:

// Java implementation of a Parallel Gateway
public class ParallelGateway {
    private List<String> outgoingFlows;
    private List<String> incomingFlows;
    
    public List<String> execute() {
        if (allIncomingFlowsCompleted()) {
            return new ArrayList<>(outgoingFlows);
        }
        return Collections.emptyList();
    }
    
    private boolean allIncomingFlowsCompleted() {
        // Check whether all incoming flows have completed
        return true; // Simplified implementation
    }
}

Inclusive Gateway (OR)

Multiple outgoing paths can be activated:

// Java implementation of an Inclusive Gateway
public class InclusiveGateway {
    private List<ConditionFlow> conditionFlows;
    
    public List<String> evaluateConditions(Map<String, Object> context) {
        List<String> activeFlows = new ArrayList<>();
        
        for (ConditionFlow conditionFlow : conditionFlows) {
            if (conditionFlow.evaluate(context)) {
                activeFlows.add(conditionFlow.getTargetId());
            }
        }
        
        return activeFlows;
    }
}

BPMN Events and Event Types

Timer Events

Time-triggered processes:

<bpmn:intermediateCatchEvent id="timerEvent" name="Wait period">
  <bpmn:timerEventDefinition>
    <bpmn:timeDuration>P2DT3H4M</bpmn:timeDuration> <!-- 2 days, 3 hours, 4 minutes -->
  </bpmn:timerEventDefinition>
</bpmn:intermediateCatchEvent>

Message Events

Message-driven communication:

<bpmn:intermediateCatchEvent id="messageEvent" name="Receive message">
  <bpmn:messageEventDefinition messageRef="message1"/>
</bpmn:intermediateCatchEvent>

Error Events

Error handling in processes:

<bpmn:boundaryEvent id="errorBoundary" attachedToRef="task1">
  <bpmn:errorEventDefinition errorRef="error1"/>
</bpmn:boundaryEvent>

Implementing BPMN with Camunda

Process Deployment

// Camunda BPMN process deployment
@Service
public class ProcessDeploymentService {
    
    @Autowired
    private RepositoryService repositoryService;
    
    public void deployProcess(String processName, String bpmnFile) {
        try (InputStream inputStream = getClass().getResourceAsStream(bpmnFile)) {
            Deployment deployment = repositoryService.createDeployment()
                .addClassnameResource(processName + ".class")
                .addInputStream(processName + ".bpmn", inputStream)
                .deploy();
                
            System.out.println("Process deployed: " + deployment.getId());
        } catch (IOException e) {
            throw new RuntimeException("Deployment failed", e);
        }
    }
}

Starting a Process Instance

// Camunda process instance startup
@Service
public class ProcessInstanceService {
    
    @Autowired
    private RuntimeService runtimeService;
    
    public String startProcess(String processKey, Map<String, Object> variables) {
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(
            processKey, 
            variables
        );
        
        return processInstance.getId();
    }
    
    public List<Task> getUserTasks(String processInstanceId) {
        return taskService.createTaskQuery()
            .processInstanceId(processInstanceId)
            .list();
    }
}

Task Handler

// Camunda task handler
@Component
public class OrderTaskHandler {
    
    @EventListener
    public void handleTaskCreated(TaskCreatedEvent event) {
        String taskId = event.getTaskId();
        String taskName = event.getTaskName();
        
        if ("Check order".equals(taskName)) {
            processOrderTask(taskId);
        }
    }
    
    private void processOrderTask(String taskId) {
        // Business logic for order validation
        Map<String, Object> variables = new HashMap<>();
        variables.put("orderValid", true);
        variables.put("orderAmount", 1000.0);
        
        taskService.complete(taskId, variables);
    }
}

BPMN Best Practices

1. Process Modeling Guidelines

// BPMN validation rules
public class BPMNValidator {
    
    public ValidationResult validateProcess(Process process) {
        ValidationResult result = new ValidationResult();
        
        // Every process must have a start event
        if (!hasStartEvent(process)) {
            result.addError("Process requires at least one start event");
        }
        
        // Every process must have an end event
        if (!hasEndEvent(process)) {
            result.addError("Process requires at least one end event");
        }
        
        // All tasks must be connected
        if (hasDisconnectedTasks(process)) {
            result.addError("Disconnected tasks detected");
        }
        
        return result;
    }
    
    private boolean hasStartEvent(Process process) {
        return process.getFlowElements().stream()
            .anyMatch(element -> element instanceof StartEvent);
    }
    
    private boolean hasEndEvent(Process process) {
        return process.getFlowElements().stream()
            .anyMatch(element -> element instanceof EndEvent);
    }
}

2. Naming Conventions

<!-- Good naming conventions -->
<bpmn:userTask id="checkOrderTask" name="Check order"/>
<bpmn:exclusiveGateway id="isValidGateway" name="Order valid?"/>
<bpmn:serviceTask id="sendEmailTask" name="Send confirmation"/>

<!-- Poor naming conventions -->
<bpmn:userTask id="task1" name="Task 1"/>
<bpmn:exclusiveGateway id="gw1" name="Gateway"/>

3. Process Optimization

// Process performance analysis
@Service
public class ProcessAnalyticsService {
    
    @Autowired
    private HistoryService historyService;
    
    public ProcessMetrics analyzeProcess(String processDefinitionKey) {
        List<HistoricProcessInstance> instances = historyService
            .createHistoricProcessInstanceQuery()
            .processDefinitionKey(processDefinitionKey)
            .finished()
            .list();
        
        ProcessMetrics metrics = new ProcessMetrics();
        metrics.setTotalInstances(instances.size());
        metrics.setAverageDuration(calculateAverageDuration(instances));
        metrics.setSuccessRate(calculateSuccessRate(instances));
        
        return metrics;
    }
    
    private Duration calculateAverageDuration(List<HistoricProcessInstance> instances) {
        return instances.stream()
            .map(instance -> Duration.between(
                instance.getStartTime(), 
                instance.getEndTime()
            ))
            .reduce(Duration.ZERO, Duration::plus)
            .dividedBy(instances.size());
    }
}

BPMN Tools and Frameworks

1. Camunda Modeler

// Camunda Modeler plugin example
const customPlugin = {
  id: 'custom-validation-plugin',
  init: function(modeler) {
    
    // Custom validation rule
    modeler.get('validationRules').add('task-name-required', function(element) {
      if (element.type === 'bpmn:Task' && !element.name) {
        return 'Task must have a name';
      }
    });
    
    // Custom property panel
    modeler.get('propertiesPanel').registerProvider({
      getTabs: function(element) {
        if (element.type === 'bpmn:UserTask') {
          return {
            'custom-task-tab': {
              label: 'Custom Task Properties',
              entries: [
                {
                  id: 'task-priority',
                  label: 'Priority',
                  component: 'textfield',
                  bindTo: 'customPriority'
                }
              ]
            }
          };
        }
      }
    });
  }
};

2. BPMN.js Integration

// BPMN.js Viewer Integration
import BpmnViewer from 'bpmn-js/lib/Viewer';

class BPMNViewer {
  constructor(container) {
    this.viewer = new BpmnViewer({
      container: container,
      width: '100%',
      height: '500px'
    });
  }
  
  async loadDiagram(xml) {
    try {
      await this.viewer.importXML(xml);
      
      // Zoom to fit
      const canvas = this.viewer.get('canvas');
      canvas.zoom('fit-viewport');
      
    } catch (err) {
      console.error('Error loading BPMN diagram:', err);
    }
  }
  
  addClickListener(callback) {
    this.viewer.on('element.click', function(event) {
      const element = event.element;
      callback(element);
    });
  }
}

// Usage
const viewer = new BPMNViewer('#bpmn-container');
viewer.loadDiagram(bpmnXml);
viewer.addClickListener((element) => {
  console.log('Clicked element:', element.id, element.name);
});

BPMN in Practice

E-Commerce Order Process

<!-- Complex order process with multiple participants -->
<bpmn:definitions>
  
  <!-- Pool: Customer -->
  <bpmn:pool id="customerPool" name="Customer">
    <bpmn:lane id="customerLane" name="Customer">
      <bpmn:userTask id="placeOrder" name="Place Order"/>
      <bpmn:userTask id="makePayment" name="Make Payment"/>
    </bpmn:lane>
  </bpmn:pool>
  
  <!-- Pool: Shop System -->
  <bpmn:pool id="shopPool" name="Shop System">
    <bpmn:lane id="orderLane" name="Order Processing">
      <bpmn:serviceTask id="validateOrder" name="Validate Order"/>
      <bpmn:serviceTask id="checkInventory" name="Check Inventory"/>
      <bpmn:userTask id="processPayment" name="Process Payment"/>
    </bpmn:lane>
    <bpmn:lane id="warehouseLane" name="Warehouse">
      <bpmn:userTask id="pickItems" name="Pick Items"/>
      <bpmn:userTask id="packageItems" name="Package Items"/>
    </bpmn:lane>
  </bpmn:pool>
  
  <!-- Pool: Delivery Service -->
  <bpmn:pool id="deliveryPool" name="Delivery Service">
    <bpmn:lane id="deliveryLane" name="Shipping">
      <bpmn:serviceTask id="scheduleDelivery" name="Schedule Delivery"/>
      <bpmn:userTask id="deliverPackage" name="Deliver Package"/>
    </bpmn:lane>
  </bpmn:pool>
  
  <!-- Message Flows between Pools -->
  <bpmn:messageFlow id="orderMessage" sourceRef="placeOrder" targetRef="validateOrder"/>
  <bpmn:messageFlow id="paymentMessage" sourceRef="makePayment" targetRef="processPayment"/>
  <bpmn:messageFlow id="deliveryMessage" sourceRef="packageItems" targetRef="scheduleDelivery"/>
  
</bpmn:definitions>

Approval Process

// Approval process with escalation
@Service
public class ApprovalProcessService {
    
    public String startApprovalProcess(ApprovalRequest request) {
        Map<String, Object> variables = new HashMap<>();
        variables.put("requestId", request.getId());
        variables.put("amount", request.getAmount());
        variables.put("requester", request.getRequester());
        variables.put("approvalLevel", determineApprovalLevel(request.getAmount()));
        
        return runtimeService.startProcessInstanceByKey(
            "approval-process",
            variables
        ).getId();
    }
    
    private String determineApprovalLevel(Double amount) {
        if (amount < 1000) return "manager";
        if (amount < 10000) return "director";
        return "executive";
    }
    
    @EventListener
    public void handleEscalation(TaskEscalationEvent event) {
        String taskId = event.getTaskId();
        String escalationLevel = event.getEscalationLevel();
        
        // Route escalation to the next level
        Map<String, Object> escalationVariables = new HashMap<>();
        escalationVariables.put("escalatedFrom", taskId);
        escalationVariables.put("escalationReason", event.getReason());
        
        taskService.delegateTask(taskId, escalateLevel + "_approval");
    }
}

BPMN Exam Preparation

Key Exam Topics

BPMN Core Elements: Events, Activities, Gateways
Flow Objects: Different types and their applications
Connecting Objects: Sequence Flows, Message Flows, Associations
Pools and Lanes: Process organization and responsibilities
Gateway Types: Exclusive, Parallel, Inclusive, Complex
Event Types: Start, End, Intermediate Events
Sub-Processes: Embedded and Call Activities
Data Objects: Information representation

Typical Exam Tasks

Process Analysis: Interpret given BPMN diagrams
Process Modeling: Represent business processes in BPMN
Gateway Application: Select the correct gateway types
Event Handling: Model event-driven processes
Process Optimization: Identify inefficiencies in BPMN processes

Exam-Relevant Concepts

// Exam-relevant BPMN concepts
public class BPMNExamConcepts {
    
    // 1. Process paths and gateway logic
    public void demonstrateGatewayLogic() {
        // Exclusive Gateway: Only one path
        // Parallel Gateway: All paths simultaneously
        // Inclusive Gateway: Multiple paths possible
    }
    
    // 2. Event-based process control
    public void demonstrateEventHandling() {
        // Start Events initiate processes
        // Intermediate Events control process flow
        // End Events terminate processes
    }
    
    // 3. Data flow in BPMN
    public void demonstrateDataFlow() {
        // Data Objects represent information
        // Data Stores for persistent data
        // Associations connect data with Activities
    }
}

Summary

BPMN is a powerful standard tool for process modeling that:

Standardizes consistent process representation across organizations
Visualizes complex business processes in an understandable way
Automates direct implementation into workflow systems
Enables collaboration in shared process development
Facilitates optimization through systematic process improvement

Mastering BPMN is essential for IT professionals and business analysts to effectively model, analyze, and automate modern business processes.

Further Resources:

Täglicher Artikel