From model to execution: a formal foundation for managing materials and tools in executable BPMN

Using technology of the Internet of Things (IoT) in combination with Business Process Management (BPM) represents a paradigm shift in how organizations orchestrate cyber-physical operations (Schönig et al., 2020; Dumas et al., 2018). While IoT enables different entities to form complex systems, BPM provides the foundation for discovering, implementing, executing, monitoring, and evolving collaborative business processes within and across organizations. However, as BPM extends into cyber-physical environments across manufacturing, construction, and logistics domains, organizations face a fundamental challenge in managing operational resources (Janiesch et al., 2020; Goel and Lin, 2022). Traditional BPM focuses on modeling and optimizing IT-supported processes; however, it often overlooks the crucial “how” of manual work: the physical tools and materials involved. For instance, in construction, while digital systems handle ordering and invoicing, the actual work of a craftsperson and their use of physical tools are largely digitally unsupported by Business Process Management Systems (BPMS) (Vasilecas et al., 2014; Ouyang et al., 2010). This creates a critical gap, particularly in organizations where manual labor is central to their operations. Addressing this gap is a key challenge for Business Process Technology (BPT), as effective digital transformation requires technologies that can seamlessly integrate and support both digital and physical aspects of work.

Despite the recognized potential for IoT-enhanced business processes, current BPM standards, including BPMN 2.0, primarily focus on active resources and control flows. The absence of native constructs for passive resource allocation, availability checking, and release mechanisms (cf. Albach et al., 2000) prevents organizations from achieving the operational transparency that cyber-physical integration promises. This limitation manifests as the digital-physical divide (Poss and Schönig, 2025): a disconnect between digital process models and the complex reality of managing physical resources. Solving this requires a theoretical shift in BPM: moving beyond active resources to formally conceptualize the lifecycles of passive resources (consumable materials and reusable tools) within standard process orchestration. This is visible in manufacturing and craft business environments, where the gap between digital design and physical manufacturing operations significantly affects operational efficiency. This leads to the following research question: How can IoT-enhanced BPM systems effectively model, execute, and monitor the distinct lifecycles of passive resources within integrated cyber-physical business processes?

To address this challenge, we present the Passive Resource-integrated Modeling Extension (PRiME). Unlike previous conceptual proposals, this work provides a fully executable artifact grounded in a robust theoretical foundation. Our specific contributions are threefold.

1. Theoretical Advancement via Formal Ontology: We advance the theoretical discourse on the operational perspective of BPM by formally conceptualizing physical assets as first-class citizens. By deriving a strict distinction between consumable materials (repetitive factors) and reusable tools (potential factors) rooted in production theory (cf. Allen and Alting, 1994), we provide a theoretical foundation for bridging the digital-physical divide, validated against the BPMN 2.0 metamodel (OMG, 2011).

2. Executable BPMN Extension: We translate this theoretical foundation into a standard-compliant extension that introduces ResourceRequirement and ResourceInventory elements, enabling process engines to natively execute availability checks.

3. Dual Validation and Artifacts: We validate the framework through two distinct applications: (i) a real-world, IoT-integrated runtime demonstration for shortage detection, and (ii) a standalone, reproducible design-time visualization for material flow analysis.

This research extends our earlier work in Poss and Schönig (2026). The core framework is enhanced in several key ways:

1. Extended Methodology: We introduce a formal equivalence check that compares domain concepts against existing BPMN elements to motivate the ontology.

2. Structured Literature Review: The related work section has been expanded into a PRISMA-based systematic review to better position the contribution.

3. Improved Evaluation and Discussion: Next to evaluating scalability and processing times for different scenarios with the prototypical implementation, we explicitly analyze the economic impact and incorporate sustainability indicators (ESG), and discuss the framework's alignment with the UN SDGs (United Nations, 2015) (specifically 4, 8, 9, and 12).

The paper is structured as follows: After a short presentation of our chosen research approach in Section 2, we introduce the required background on BPM, its perspectives, the de facto modeling standard Business Process Model and Notation (BPMN), and its extension mechanism, as well as the IoT in Section 3. Following this introduction, an overview of related work is presented in Section 4. This is followed by the conceptualization and development of our BPMN extension for passive resources (Section 5), which is subsequently demonstrated and evaluated using a real-world process from an ongoing research project (Section 6). After a short discussion of the results in Section 7, including an analysis of the framework's potential economic impact and its alignment with ESG criteria and SDGs (United Nations, 2015), the paper concludes with a conclusion and future work in Section 8.

This research employs the Design Science Research Methodology (DSRM) (Johannesson and Perjons, 2021; Peffers et al., 2007) to develop and evaluate the BPMN extension artifact addressing the digital-physical divide of BPM and including passive resources in BPMN. The DSRM framework structures our approach into five core phases: problem identification, solution design, development, demonstration, and evaluation. As illustrated in Figure 1, the development of PRiME integrates the BPMN extension methodologies of Braun and Esswein (2014a) and Stroppi et al. (2011) into this broader DSRM lifecycle. Specifically, we prepend a formal domain analysis and ontology development to this process. This allows us to conduct an equivalence check, i.e. comparing domain concepts against existing BPMN elements (Braun and Esswein, 2014a), before executing the standard technical extension steps outlined by Stroppi et al. (2011). To ensure methodological rigor, Table 1 details the specific validation methods and evaluation metrics used in each phase.

This section outlines the foundational concepts of the operational perspective in BPM, the extension mechanisms of BPMN 2.0, and the role of the IoT in bridging the digital-physical divide.

While Business Process Management (BPM) traditionally focuses on the control flow and organizational aspects of work, the operational perspective represents a critical but underexplored dimension. Poss and Schönig (2025) formally define this perspective as “supporting and providing all resources needed to execute a task”. While earlier definitions focused strictly on the what and the who, this operational perspective explicitly addresses the how of manual work by modeling the physical tools and materials required (Curtis et al., 1992).

To model the specific requirements for tools and materials, Business Process Model and Notation (BPMN) has emerged as the de facto standard. BPMN 2.0 supports domain-specific adaptation through a formal extension mechanism (OMG, 2011). This mechanism facilitates extension by addition, in which new XML attributes and elements are appended to existing standard elements. This strategy contrasts with extension by specialization (common in UML), allowing the core metamodel to remain unaltered (Stroppi et al., 2011). Consequently, process models utilizing PRiME remain interoperable; standard-compliant tools can still open and execute the core logic, simply ignoring the extended attributes they do not recognize (Braun and Esswein, 2014b).

The Internet of Things (IoT) provides the technological infrastructure needed to implement these extensions. By integrating network-connected sensors and actuators, IoT enables continuous monitoring of physical assets and transmits data to the process engine in real time (Janiesch et al., 2020; Schönig et al., 2020). This capability is essential for bridging the digital-physical divide (Poss and Schönig, 2025), enabling the process management system to dynamically validate the availability of physical resources before authorizing task execution.

We approached identifying and evaluating existing research on extending BPMN for passive resources by following the PRISMA guidelines (Page et al., 2021) shown in Figure 2. Based on the three thematic pillars (1) BPMN model enhancement, (2) passive resources/inventory in process contexts, and (3) operational/production/execution dynamics in BPM, we developed the following search strings: (“business process” OR “BPM” OR “Workflow”) combined with each of the following (Operation* OR production* OR execution*), (material OR “passive resource” OR inventory) and (“operational equipment” OR “bill of tools” OR “bill of material”) and used them with IEEE Xplore, ScienceDirect, AIS eLibrary, EBSCO, and ACM Digital Library.

In total, the initial search yielded 1 769 records across all sources. Of these, 690 were retrieved from IEEE Xplore, 364 from ScienceDirect, 199 from the ACM Digital Library, 12 from AIS eLibrary, and 476 from EBSCO. An additional 28 records were identified through backward and forward citation searches. After removing 91 duplicate records, a dataset of 1 678 unique entries was screened. During the screening phase, titles and abstracts were reviewed against predefined inclusion criteria, including a clear focus on BPMN extensions and resource modeling. This led to the selection of 178 studies for full-text review. Of these, two articles could not be accessed, leaving 176 for detailed analysis. In the final stage, 158 studies were excluded for reasons including a lack of connection to BPMN, a focus on general optimization without notation extensions, or the absence of passive resource modeling.

In total, 18 studies met all inclusion criteria and were included in our systematic literature review. These works form the foundation for our analysis of existing approaches and are summarized in the concept matrix (Webster and Watson, 2002) in Table 2 that details the goals, approaches, outcomes, and drawbacks of each publication. To provide a comprehensive overview, we organize these approaches into four conceptual categories based on their primary contribution to resource modeling.

1. Graphical: Introducing new visual elements, icons, or shapes to BPMN.

2. Conceptual: Proposing theoretical frameworks, metamodels, or taxonomies for resource interactions.

3. Architectural: Extending system architectures at the BPMS level (e.g. adding resource managers or databases).

4. Executable: Providing actual runtime executability that goes beyond visual or theoretical support.

Several studies propose enhancing BPMN with new visual elements to make the passive resource requirements explicit. For example, Zor et al. (2010) adapt standard BPMN for manufacturing by mapping Value Stream Mapping (VSM) concepts to existing constructs, later formalizing these ideas into dedicated graphical elements like Material Gateways (Zor et al., 2011). Similarly, Braun and Esswein (2014a) introduce new graphical elements for “Material” and “Auxiliary” items to model consumables and support materials in engineering processes. Taking a different approach, Goel (2022) propose new activity types (“Request”, “Release”, and “Resource”) to manage the resource lifecycle directly within the process model. While these graphical extensions improve model clarity, a common drawback is their limited generalizability and lack of executable semantics without further architectural support.

The most common category of contribution involves conceptual extensions, primarily through enhancements to the metamodel. Jung (2007) laid early groundwork by defining a metamodel for resource states, roles, and structures, providing a foundation for other works. Building on this, Braun et al. (2015) offer an extensive framework for healthcare, extending the BPMN metamodel to classify resources (active vs. passive) and define resource bundles. Other approaches focus on simulation, such as Bocciarelli et al. (2016), who extend the metamodel to detail resource properties like availability and non-functional characteristics using text annotations. Ouyang et al. (2010) use Object Role Modeling (ORM) to create a data model for defining complex resource constraints. A key limitation of these purely conceptual works is that they often lack machine-readability and the executable logic required for real-time process execution, focusing instead on analysis and simulation.

To bridge the gap between modeling and execution, some researchers propose architectural extensions to BPMS's. Ihde et al. (2019) exemplify this with a Resource-Aware BPMS featuring a “Resource Manager” component for dynamic resource allocation and optimization. This pattern of a central manager is also seen in Liu et al. (2011), who developed a service-oriented “Resource Manager” to handle allocation patterns and rules. These approaches are powerful because they are often executable. For instance, Goel and Lin (2022) present a framework for executable resource lifecycle management, and Vasilecas et al. (2014) use a script-based method to query a resource database for dynamic simulation. However, a common challenge with architectural extensions, as seen in Ihde et al. (2019) and Liu et al. (2011), is the lack of intuitive visual modeling, which makes it difficult for process designers to discern resource dependencies directly within the BPMN diagram.

In summary, this evaluation highlights the importance of integrating passive resources into process models. While many approaches conceptually integrate material-related aspects into BPMN, most focus on simulation or domain-specific modeling. Executable solutions exist, but often compromise visual clarity at the modeling level. This reveals a significant gap between comprehensive conceptual modeling and actionable, visually integrated execution support, which our work aims to address.

This section outlines the design and development of the PRiME framework, based on the methodologies outlined in our research approach. The process is structured into two main phases. First, we establish the conceptual foundation for the extension. This involves a domain analysis, the creation of a formal ontology, an equivalence check against the BPMN standard, and the derivation of explicit design objectives. Second, we translate these concepts into a formal, standard-compliant BPMN extension, including the creation of a Conceptual Domain Model (CDME) and a corresponding graphical notation.

To extend BPMN to include materials and tools as passive resources, following the combined approach of Stroppi et al. (2011) and Braun and Esswein (2014a), we need to analyze the domain of each component. This phase formalizes the core concepts, relationships, and material transformation activities within a process, establishing the foundation for a comprehensive resource ontology. The classification of materials and tools is rooted in Gutenberg's production factor model (cf. Albach et al., 2000), which distinguishes between Elementary Factors directly involved in production and Dispositive Factors related to managerial and organizational coordination. Elementary Factors further subdivide into Repetitive Factors (consumed during production, e.g. raw materials, auxiliary materials, operating materials) and Potential Factors (used repeatedly without consumption, e.g. machinery, tools) ^[1]. To address the limitations of the classical model, which homogenizes materials across repetitive factors, a more granular classification is introduced that differentiates materials based on their process integration, transformation stages, and usage characteristics. This includes raw materials, intermediate products, end products, consumables, and standardized components. Similarly, material operating resources (tools) classified as potential factors are detailed by their characteristics and uses. These include tool parts with specific quantitative and qualitative parameters that define the instance of the object.

To formalize these concepts, we developed a material and tool ontology (Figure 3) that extends the prior work of Poss and Schönig (2025). This ontology defines core classes (e.g. tools, raw materials), taxonomic hierarchies, and object relationships. Furthermore, it introduces specific datatype properties to capture quantitative and qualitative attributes, such as weight, dimensions, and battery levels. Based on this extended ontology, we can now examine the properties of each resource and compare them with those defined in the BPMN standard. This is the Equivalence Check, which precedes the domain modeling step to ensure a good fit and to motivate the specific process elements required (cf. Braun and Esswein, 2014a). The equivalence check is detailed in Table 3. It is organized into three sections: (1) passive resources in general; (2) specific material handling concepts, such as flow, storage, and transformation; and (3) other domain concepts, including resource location and the active resource (human or machine) executing the task. The equivalence check reveals current limitations of BPMN in representing passive resource requirements, inventory handling, and flows. To address this, explicit extensions are introduced: ResourceObject for classifying materials and tools, ResourceInventory for tracking availability, and MaterialFlow to distinguish between physical and informational flows.

This analysis of existing approaches and the following modeling of the requirements and the domain of passive resources itself, followed by a comparison to already existing elements and possibilities in the BPMN standard, leads to establishing the following design objectives for PRiME.

1. DO1 – Explicit modeling of passive resources: Introduce structured annotation mechanisms within BPMN to define material requirements (e.g. quantity, unit, type) at the task level. This enables clear differentiation between active and passive resources, establishing a foundation for runtime material management.

2. DO2 – Representation of resource availability, dependencies, and material flows: Enable the modeling of material inputs and outputs for process tasks, along with mechanisms to track material availability and resolve dependencies. This includes detecting material shortages, triggering exception handling, and dynamically updating inventory to ensure process execution aligns with material constraints.

3. DO3 – Conformance with BPMN Standards and Modeling Tools: Maintain strict compliance with the BPMN 2.0 standard by using its provided extension mechanisms (e.g. extending existing TextAnnotation or DataObjectReference) to embed resource metadata.

4. DO4 – Executability in a Real-Time Runtime Environment: Ensure the extended BPMN model is executable within a real-time process management system. This involves providing the required logic for material availability checks, inventory deductions, and visualization updates as a prototypical implementation.

The goal is to develop the PRiME framework, which models passive resources, i.e. consumable materials and reusable tools. Following the methodology (Stroppi et al. (2011), as shown in Figure 1), we achieve this by developing the corresponding BPMN elements based on the identified requirements. This requires formally defining domain-specific concepts and their relationships within a Conceptual Domain Model (CDME) before transforming them into a compliant BPMN+X model, which extends the BPMN metamodel. This model is then transformed into a standard XML document.

The Conceptual Domain Model of the Extension (CDME) ( Appendix, Figure A1) introduces a dual-structure approach to integrate resource management without breaking BPMN semantics.

1. Design-Time Specifications (Annotations): We introduce the ResourceRequirementAnnotation as an extension of the standard TextAnnotation. This allows modelers to attach static, structured requirements (e.g. “Requires: Circular Saw”) to tasks. We distinguish between MaterialRequirement (fungible) and ToolRequirement, which can further specify a generic ToolType or a specific ToolObject (e.g. for calibrated equipment).

2. Runtime Management (Data Objects): To enable execution, these requirements are instantiated into ResourceObjects managed within a ResourceInventory collection. This distinction ensures that the process definition remains clean (annotations), while the process instance carries the necessary state data (inventory objects).

3. Physical Flow (Associations): We extend the standard DataAssociation to create a MaterialFlow. Unlike data associations, which model information read/write access, this explicitly represents the physical transport of a quantity from a source (Inventory) to a target (Task), carrying a structured payload (Material ID, Quantity).

The transformation to the BPMN + X model ( Appendix, Figure A2) follows standard extension rules (Stroppi et al., 2011): new data structures are defined as << ExtensionElement>>, while their integration points (e.g. attaching requirements to tasks) are formalized via << ExtensionDefinition>>.

Finally, as a last step, we introduce additional icons, following the rules provided in OMG (2011), to visually distinguish the newly introduced elements shown in Figure 4. Again, distinguishing between tangible, real-world objects and resources, and the list of requirements and the corresponding annotations for tools and material requirements.

To demonstrate and evaluate the new elements, we present two distinct examples based on real-world requirements identified in collaboration with actors from the craft business sector. Before detailing the use cases, Table 4 provides a clear mapping from the core PRiME constructs, as defined in our conceptual model (Section 5.2), to their concrete implementation artifacts within our prototype. This table bridges the conceptual framework and its practical realization.

One example is similar to the approach in Poss and Schönig (2025), in which additional information about requirements is directly attached to tasks within the process model. This example focuses on runtime support, enabling the automatic provision of information on required and potentially missing tools and materials during process execution (Section 6.1). The second example (Section 6.2) takes a further step by introducing a novel method for statically parsing and presenting relevant information on resource requirements as a Sankey diagram (Riehmann et al., 2005). This serves as an overlay on the process model, displaying the flow of materials through each step for design-time optimization. To ensure the technical reproducibility of these results, the complete evaluation setup is available at https://github.com/LeoPoss/PRiME_MaterialFlow/tree/processRequirements. The repository contains.

1. Executable Artifacts: The BPMN 2.0 XML models for all evaluated scenarios.

2. Backend Services: The Java/Spring Boot source code for the prototype, including mock IoT REST APIs to simulate physical sensor events.

3. Evaluation Suite: An automated JUnit test suite that programmatically validates the quantitative performance and latency metrics presented in Section 6.3.

To demonstrate the practical utility of our approach, we apply the concept from Poss and Schönig (2025) to provide runtime support for monitoring the tools and materials required for manual tasks. Figure 5 displays an excerpt of a real-world process model from an ongoing research project, adapted for publication purposes, where the functionality is integrated into the workflow management system and an external application within the research project. For this publication, we present a simplified version that displays formatted requirements within a basic Camunda form ^[2]. The model comprises a set of tasks, with their resource requirements specified via JSON-based annotations. The process depicts a carpenter's role in building a wooden roof truss. It involves two distinct tasks: Prefabricate Beams and Joints and Assemble and Erect Truss (highlighted in red). These tasks are separated by a waiting period for transportation. Crucially, each task requires a different set of materials and tools. For better understanding, we explicitly model service tasks to indicate whether the correct resources are carried. Then, we verify the requirements and explicitly address material shortages highlighted in yellow, as well as requirements specified through the extended elements and those annotated to each task.

The technical implementation follows the process flow, beginning with the Create Resource List service task. This task executes a Java delegate that parses all ResourceRequirementAnnotations from the process model's XML definition. It aggregates these individual requirements into a single ResourceRequirementCollection object, which is then stored as a process variable. This variable serves as a comprehensive “Bill of Resources” for the entire process instance. Next, in the Collect Resources user task, the actor is presented with a list of required items for the current phase, as illustrated in Figure 6a. For the prefabrication phase, tools include a Circular Saw (Bosch), and materials include Pine Beam and Rafters. In our project, IoT sensors automatically track the collected items, populating the ResourceInventory process variable with a digital manifest of the resources the actor is actually carrying. In the physical deployment, IoT sensors (e.g. RFID, Bluetooth Low Energy (BLE), and smart shelves) automatically track collected items. However, to ensure the artifact's technical reproducibility without requiring specific hardware, we developed a standalone version of the prototype. In this reproducible implementation, the physical hardware layer is mocked via two REST endpoints (/api/resources/inventory and /api/resources/inventory/update). The Create Resource List task initializes the process with mock inventory data and simulates sensor events via direct API calls. This abstraction enables the core logic of the PRiME extension (inventory tracking, shortage detection, and variable aggregation) to be validated in a standard software environment without requiring physical dependencies.

The following Check Resource Availability service task then performs a critical validation by comparing the required items in the ResourceRequirementCollection against the actual items in the ResourceInventory. If this check detects a mismatch, an exclusive gateway directs the process flow to the Handle Resource Shortage user task. Here, the actor is shown a list of the specific missing items (Figure 6b), allowing them to correct the error. Once the user confirms the issue is resolved, an execution listener updates the ResourceInventory, and the process returns to the verification step to ensure the inventory is correct before proceeding with the main workflow. Internally, this mechanism relies on the native process (instance) variables of the Camunda engine. As illustrated in Figure 7, the execution listener attached to the availability check calculates the difference between the required and available resources. It then serializes this delta into specific process variables, such as materialAvailable (Boolean) to drive the exclusive gateway, and formattedMissingMaterials (String/JSON) to store the specific list of shortages. These variables are directly bound to the input fields of the Handle Resource Shortage Camunda Form. Consequently, the user interface is dynamically populated with the live data, presenting the worker with a precise, human-readable checklist of the missing items required to proceed (Figure 6b).

Upon successful completion of the Prefabricate Beams and Joints task, the framework manages the material transformation. The consumed raw materials (Pine Beams, Rafters) are decremented from the inventory, and new intermediate resources (Prefabricated Truss Components) are added. After the transport phase, a second resource check is performed before the final Assemble and Erect Truss task. This check validates the on-site availability of various resources and consumables. This two-phase validation demonstrates how the system can manage resource logistics across different locations and stages of a complex project. Finally, the system distinguishes between resource types: consumables, such as screws, are decremented from inventory upon use, whereas tools, such as the crane, are simply marked as available again, ready for use in other processes.

Finally, the utility extends beyond real-time operational support to post-process analytics. The granular data captured during execution, including resource usage times (derived by correlating inventory updates with task start/end timestamps) and material consumption quantities per task, is persisted in Camunda's history database. By analyzing historical data, process owners can calculate a project's true resource cost, identify recurring patterns of tool shortages or material waste, and optimize inventory planning for future projects.

Beyond execution support, the extracted material requirements can be used to visualize the material flow directly on the process model at design time. The frontend visualization is realized as a client-side plugin for the Camunda Cockpit. This architectural approach enables the direct integration of a material flow overlay into the standard process monitoring interface without altering the core Camunda application. The plugin registers itself using the cockpit.processDefinition.diagram.plugin extension point, allowing it to programmatically interact with and augment the rendered BPMN diagram.

The plugin's operation follows a two-stage pipeline. First, upon loading the diagram, it initiates an asynchronous fetch request to a dedicated API endpoint to retrieve the material flow data for the current process definition. This data is pre-processed by the backend into a graph structure, consisting of nodes (representing tasks and materials) and links (representing the directed flow of materials). The second stage is the rendering process, which leverages the d3.js library ^[3]. The core functionality of this stage involves geometrically aligning the Sankey diagram with the BPMN model. A standard Sankey layout would arrange nodes algorithmically, breaking the correspondence with the user-created BPMN layout. To solve this, our plugin first leverages Camunda's frontend API to query the elementRegistry service, extracting the coordinates and dimensions of each task shape in the underlying diagram. After the d3-sankey library ^[4] computes the initial flow geometry, the plugin manually overrides the positions of the task nodes, ensuring they align with their corresponding graphical elements in the process model. Finally, the plugin renders the visual components.

1. Links: Each material flow is drawn as an SVG <path> element. A custom path generator creates smooth curves between source and target nodes. The stroke-width of each path is calculated to be proportional to the value of the link (i.e. the material quantity).

2. Labels: To provide context, an SVG <textPath> element is appended to each link's path. This element renders the material name and quantity along the curve of the flow.

The resulting visualization, shown in Figure 8, illustrates the material flow involved in assembling a wooden table. The process model comprises three key tasks: Mount Wooden Slats to Tabletop, Inserting Corner Connectors, and Attaching Table Legs. Each task is annotated with its specific material requirements using RequirementAnnotations. The nodes on the left-hand side list all required raw materials for a single process instance. Flow lines represent the movement of materials from the initial supply to the tasks where they are consumed. For instance, Screw M10, Screw M8, Table Leg, and Side Rail are consumed at various stages, with intermediate products such as the Partially Assembled Table and Table Frame being produced and subsequently utilized in downstream tasks. The final task, Attaching Table Legs, results in the Finished Good, which represents the fully assembled table. While the current implementation primarily supports linear process flows, this foundational approach demonstrates the potential to communicate complex material dependencies transparently within a process model.

It is important to note that PRiME relies on standard BPMS capabilities; specifically, the parsing of XML extension elements and the comparison of JSON or YAML-based data sets. Consequently, the extension does not introduce computationally intensive algorithms; the complexity is effectively linear O(n) relative to the number of resource items. To evaluate the practical efficiency and scalability of our approach, we established an automated testing suite to measure the execution time of the design-time material-flow visualization pipeline. To ensure statistical robustness and reflect true runtime performance, the testing suite utilizes a JVM warm-up phase to resolve initial class-loading overhead, followed by 10 independent measured executions for each scenario. The results in Table 5 report the mean and standard deviation for each operation. In addition to the real-world “Table Assembly” and “Truss Prefabrication” processes, we introduced a “Synthetic Scaling” scenario to address broader, enterprise-level testing requirements. We manually significantly increased the structural complexity of the process model, which comprises 115 process tasks, 24 of which are annotated with 120 resource requirements. As shown in Table 5, the framework efficiently processes high-density models. The total pipeline latency for the synthetic stress test averaged just 21.13 ± 2.10 ms, demonstrating that the system completes its parsing and transformation virtually instantaneously with highly stable variance. These results conclusively confirm that PRiME imposes negligible computational overhead and scales predictably without bottle-necking the process engine, even when managing extensive resource dependencies.

To empirically validate our claim of linear complexity, we additionally generated a series of process models programmatically, with 10–500 tasks, each containing up to 300 concurrent resource requirements ^[5]. As before, we utilized a JVM warm-up phase followed by 10 measured iterations for each scale point to capture true runtime variance. As illustrated in Figure 9, the total pipeline latency exhibits a strict linear correlation to the model size. Scaling the process complexity by a factor of 50 (from 10 to 500 tasks) increases the total execution time by less than 15 ms (from 7.77 ms to 22.26 ms). Furthermore, the standard deviation remains exceptionally tight across all scales (SD < 3 ms). This explicitly confirms that the underlying parsing and transformation algorithms process massive, enterprise-scale models with near-constant time overhead, ensuring the BPMS remains highly responsive regardless of model density.

In contrast to other BPM paradigms for passive resource handling, which focus primarily on high-level conceptual frameworks (e.g. Jung, 2007), or process simulation (e.g. Bocciarelli et al., 2022; Vasilecas et al., 2014), PRiME provides a concrete, executable implementation. Because these related works target different research objectives, such as abstract resource-allocation logic rather than the formal, standard-compliant execution of resource lifecycles, their use cases and technical artifacts are not directly comparable to a runtime benchmark. To confirm the practical efficiency of our approach, we measured the execution time of the design-time material-flow visualization. Measurements were taken for the “Table Assembly” and “Truss Prefabrication” processes. As shown in Table 5, the total pipeline latency averages far below half a second.

These results confirm that the extension imposes no significant overhead. The visualization is rendered in real time during modeling, and the runtime logic (restricted to simple variable comparisons) executes virtually instantaneously within the service tasks. Notably, the observed variance in material annotation parsing times is primarily driven by the underlying serialization libraries rather than the extension's architectural logic. The JSON-based scenarios use kotlinx.serialization ^[6], while the YAML-based scenarios rely on the Jackson ^[7] library. Consequently, optimizing raw parsing speed remains an external dependency, independent of the PRiME framework.

This work aimed to address the digital-physical divide in cyber-physical systems by developing and demonstrating PRiME, a framework for integrating passive resources into executable BPMN models. The research systematically achieved the four design objectives established at the outset. First, the explicit modeling of passive resources (DO1) was realized through a dual-artifact approach: the ResourceRequirementAnnotation provides a structured, human- and machine-readable format for defining needs at the task level, while the underlying ontology formally classifies resources, distinguishing between consumable materials and reusable tools. Second, the representation of resource availability and dependencies (DO2) was implemented by defining ResourceInventory as a dynamic process variable to track carried resources, and by coupling it with Java delegates that perform availability checks and handle shortage exceptions. The material flow visualization further enhances this by providing direct visual feedback on resource consumption. Third, conformance with BPMN standards (DO3) was a central design principle, ensured by the exclusive use of the official BPMN 2.0 extension mechanism. By embedding definitions within standard TextAnnotation elements, the models remain fully compliant and interchangeable with standard-compliant tools. Finally, the crucial aim of executability in a real-time environment (DO4) was validated through the Camunda-based prototype. This implementation proved the framework's practical applicability by providing runtime logic for availability checks, user notifications, and dynamic inventory updates within a live process engine. By successfully meeting these goals, PRiME provides an executable solution that overcomes the primary limitation of many conceptual or simulation-focused approaches, which often neglect direct operational applicability.

The use of DSRM, integrated with the extension development process of Stroppi et al. (2011) and Braun and Esswein (2014a), ensures the artifact is well-founded and systematically designed. The ResourceRequirementAnnotation serves a dual purpose: it provides human-readable clarity for process modelers at design time, while delivering machine-readable structured data to the process engine for runtime automation. This is demonstrated through two separate use cases: providing real-time resource checklists and shortage alerts to operational workers, and offering a design-time visualization of material flows for process analysts. Because PRiME relies on standard BPMN metamodel extensions, resource requirements can be modeled using any arbitrary format or Domain-Specific Language (DSL), provided the implementation serializes them into a machine-readable format. Future extensions could further integrate formal ontologies to enforce strict, machine-verifiable requirements (cf. Poss and Schönig, 2025).

Furthermore, PRiME aligns strongly with emerging paradigms in IoT-enabled process execution, particularly the development of the Digital Twins (Fornari et al., 2025) and the shift towards Object-Centric Process Mining (OCPM, Aalst (2023)). While current Digital Twins often struggle to synchronize with the physical reality of the shop floor, PRiME's executable tracking of passive resources provides the real-time, physical state data required to construct high-fidelity process digital twins. Additionally, the execution logs generated by PRiME that explicitly track the distinct lifecycles, locations, and interactions of multiple tools and consumables, provide a rich, multi-dimensional event log. This natively supports OCPM by allowing organizations to analyze complex, intersecting material flows and resource bottlenecks that traditional, single-case-ID process mining cannot capture.

Despite these contributions, the current work has limitations that offer clear avenues for future research. First and foremost, the framework's accuracy fundamentally depends on the quality of manual annotations and the ability to track actual resource inventory. While the system validates availability against these requirements, it cannot verify the requirements themselves, thereby introducing a risk of human error.

Beyond its technical contributions, PRiME can also be viewed from a sociotechnical perspective as a tool for cognitive augmentation in skilled craftwork. Rather than deskilling or replacing the craftsperson, the framework offloads the significant cognitive load associated with managing a complex, dynamic resource inventory. In the assembly use case, the system automates tracking of components and tools, freeing the master craftsperson to focus on high-value activities that require their tacit knowledge and experience. Furthermore, the creation of ResourceRequirementAnnotations serves as a means of knowledge formalization. It makes the task's implicit resource needs explicit, thereby creating a digital, reusable knowledge base. This formalized knowledge can serve as a scaffold for training apprentices, guiding them in establishing appropriate resources for a given task and in effectively preserving and transferring valuable craftsmanship knowledge.

The deployment of PRiME offers tangible economic benefits by systematically eliminating the “hidden factory” of non-productive time. In manual and cyber-physical operations, a significant portion of labor cost is wasted on searching for tools, waiting for materials, or halting work due to incomplete setups. By enforcing an algorithmic Availability Check before a task begins, the framework flags shortages in advance. For instance, preventing a worker from arriving at a construction site without a critical tool not only saves hours of round-trip travel time but also prevents cascading delays that idle subsequent trades. Commercially, this translates into direct efficiency gains through maximized wrench time. Furthermore, by generating precise Bills of Resources and visualizing material flows, organizations can shift toward just-in-time procurement, thereby reducing inventory holding costs, minimizing material shrinkage, and lowering the capital tied up in excess stock.

Furthermore, the framework provides the necessary data infrastructure to support Environmental, Social, and Governance (ESG) criteria, specifically aligning with the UN SDGs (United Nations, 2015).

1. SDG 4 (Quality Education): The explicit modeling of resource requirements transforms tacit craftsmanship knowledge into a digital, reusable asset (Target 4.4). By formalizing the tools and materials required for complex tasks, PRiME creates an educational scaffold that guides apprentices in proper operational setups, thereby facilitating the preservation and transfer of valuable vocational skills to the next generation.

2. SDG 8 (Decent Work and Economic Growth): By automating the cognitive load of resource management, PRiME supports Target 8.2 (technological upgrading). Crucially, it promotes decent work by augmenting rather than replacing the skilled craftsperson. It removes the non-productive frustration of searching for missing tools, allowing workers to focus on high-value, skill-based tasks.

3. SDG 9 (Industry, Innovation, and Infrastructure): By integrating IoT-based resource tracking into standard BPMN, PRiME facilitates the retrofit of legacy manual industries with smart capabilities (Target 9.4). It bridges the digital-physical divide, allowing traditional sectors to adopt resilient, cyber-physical infrastructure without replacing their core workforce.

4. SDG 12 (Responsible Consumption and Production): The explicit modeling of material flows directly supports Target 12.2 (Sustainable management of natural resources). The visualization of material consumption (Figure 8) transforms abstract inventory data into visible consumption patterns, allowing managers to identify usage hotspots. Additionally, the distinction between consumable and reusable resources supports Target 12.5 (Waste reduction). By tracking the exact lifecycle of a tool versus the consumption of a material, organizations can shift from wasteful “bulk provisioning” to precise “just-in-time” resource allocation, minimizing material waste and avoiding emissions from excess inventory production.

The operational logic of PRiME targets specific inefficiencies inherent in manual work. By enforcing a digital availability check before executing physical/manual tasks, the framework addresses the “search time” often required to locate tools and materials. In distributed environments, such as construction sites, preventing a worker from starting a task without the necessary equipment logically reduces non-productive travel time and execution delays. Additionally, the material flow visualization enables comparison of planned and actual resource consumption, providing the transparency needed to identify inventory waste. Regarding transferability, the core contribution and distinguishing between consumable and reusable passive resources are applicable beyond the craft sector. The requirement to synchronize materials (consumables) with specific equipment (reusables) is equally critical in domains such as healthcare (e.g. matching surgical instruments with medical supplies) and industrial maintenance (e.g. routing spare parts and diagnostic tools to a repair site).

Finally, the practical relevance of this artifact is grounded in its development context. The requirements were gathered directly from Small and Medium-sized Enterprises (SMEs) in the skilled crafts sector, who identified the lack of digital resource tracking as a specific barrier to process management. The prototype demonstrates that standard-compliant BPMN can address these operational needs without requiring complex, proprietary software solutions.

A key limitation identified is that our material flow visualization was demonstrated on a linear process, which may face scalability challenges in models with complex branching or loops (Dumas et al., 2018). For instance, consider a quality control loop in the table assembly process (Figure 8), where the Attaching Table Legs task might be repeated if a subsequent inspection fails. In such a scenario, the material requirements for that task would be consumed with each iteration. Our current design-time parsing mechanism aggregates all resource requirements for the entire process instance. While this approach effectively generates a total Bill of Resources, a standard Sankey diagram of aggregated data obscures iterative or conditional material flows. This can potentially misrepresent true resource consumption patterns—a known challenge in complex flow visualizations (Riehmann et al., 2005). To address this, the visualization could be adapted in two ways. First, it could aggregate flows separately for distinct execution paths (e.g. rendering rework loops with dashed lines or lower opacity). Alternatively, the static overlay could be transformed into an interactive element, allowing users to expand specific loops to analyze per-iteration consumption. An aggregated flow representing a loop can be clicked to “expand,” revealing per-iteration consumption or statistical information (e.g. expected consumption based on historical loop counts). Implementing these adaptations would transform the visualization from a static design-time overview into a more powerful analytical tool, demonstrating foresight and a deeper engagement with real-world process complexity.

A systematic reflection on the validity of our research is crucial for any Design Science artifact (Peffers et al., 2007; Johannesson and Perjons, 2021). We structure this analysis into three categories: internal, construct, and external validity.

1. Internal Validity: This concerns factors that could have influenced our results, primarily related to the specific design of our prototype. The demonstration was implemented using the Camunda process engine and a custom parsing script. The construction of an artifact, such as our prototype, is a core activity in Design Science Research (Peffers et al., 2007). While this setup successfully demonstrates the executability of PRiME, the observed performance characteristics are specific to this technical environment and may differ from those of other process engines or implementation strategies.

2. Construct Validity: This threat relates to how well our conceptual constructs, such as ResourceObject and ResourceRequirement, accurately map to the real-world concepts they represent. We systematically addressed this threat by grounding our extension's core concepts in established production theory, specifically Gutenberg's production factor model (Albach et al., 2000), to classify resources as consumable (Repetitive Factors) or reusable (Potential Factors). Furthermore, by strictly adhering to the official BPMN 2.0 extension mechanism (OMG, 2011; Stroppi et al., 2011) and following a formal development process from ontology to CDME and BPMN + X models, we ensure that our constructs are well-defined and integrated in a standard-compliant manner, accurately representing the intended domain concepts.

3. External Validity: This concerns the generalizability of our findings (Johannesson and Perjons, 2021). The requirements, process models, and evaluation scenarios for PRiME were derived primarily from collaborations with actors in the craft business sector. Consequently, the external validity of our framework is currently strongest within this domain. While the fundamental concepts of materials and tools are universal, further studies are necessary to evaluate their applicability and potential need for adaptation in other domains, such as large-scale manufacturing, healthcare, and logistics, which may present distinct resource-management complexities and constraints.

4. Conclusion Validity: This concerns the validity of direct inferences drawn from the data. A primary limitation of this study is the absence of longitudinal, empirical data quantifying the direct economic impact, such as specific cost reductions or measured efficiency gains, in a comparable live industrial deployment. Because PRiME introduces a novel, executable paradigm for passive resources, direct comparative benchmarking with equivalent frameworks is currently infeasible, as prior work largely focuses on conceptual modeling or non-executable simulations. Consequently, we cannot rely on pre–post measurements with a common instrumentation baseline; any “before” values would necessarily be based on retrospective estimates rather than systematically collected observations. As a result, while the logical derivations of saved travel time and reduced inventory costs are operationally sound and grounded in established business process analysis techniques, they must be interpreted as theoretically informed projections rather than statistically validated outcomes. Nevertheless, the successful runtime availability checks and the quantitative measurements of parsing overhead (cf. Table 5) provide robust evidence that the artifact is technically feasible and highly performant within its defined scope, thereby validating an early-stage evaluation that focuses on technical validity and utility rather than a full economic impact assessment.

This paper addresses the critical gap between digital process models and physical reality in cyber-physical systems, where standard BPMN fails to adequately represent the operational lifecycles of materials and tools. To address this, we introduce the Passive Resource-integrated Modeling Extension (PRiME), a formally defined and executable framework that bridges the digital-physical divide. The primary contributions of this work are threefold. First, we developed a formal BPMN extension grounded in a detailed ontology that distinguishes between consumable materials and reusable tools. Second, we validated the framework through two perspectives: real-time runtime support for workers (checklists and alerts) and strategic design-time analysis (Sankey flow visualization). Third, we presented a systematic design methodology that ensures the extension remains standard-compliant and robust.

The implications of this research are significant. For practitioners, PRiME enables process models to serve as more faithful and executable blueprints, thereby enhancing operational transparency. More importantly, it functions as a tool for cognitive augmentation. By offloading the mental load of resource tracking, the system enables skilled craftspeople to focus on high-value tasks that require their tacit knowledge and experience, thereby augmenting skilled manual labor rather than replacing it. For researchers, this work provides a validated foundation for orchestrating cyber-physical systems and formally integrates the operational perspective into executable BPM. Furthermore, the granular tracking enabled by PRiME provides a direct link to sustainability and circular economic initiatives. The framework's ability to precisely monitor material consumption creates opportunities for waste reduction analysis, while its underlying logic can be inverted to support product disassembly and recovery of reusable components. These positions process management not just as a tool for efficiency but also as a mechanism for promoting sustainable industrial practices.

Building upon this foundation, which serves as a first step towards a process-centric digital twin, future work will focus on three key areas. First, to address the current limitations in empirical benchmarking, we aim to conduct longitudinal case studies in active cyber-physical environments to capture direct ROI measurements and quantitatively validate the projected economic benefits. Second, to further strengthen the framework's theoretical rigor, future research will explore formalizing PRiME's resource constraints using languages such as the Object Constraint Language (OCL) or Alloy. This will enable automated formal verification and model checking, ensuring that complex resource dependencies in extended BPMN models are logically consistent and conflict-free prior to execution. Finally, we will advance from passive monitoring to active automation and dynamic resource optimization. Currently, PRiME detects shortages but relies on human intervention to resolve them. Future iterations could integrate with planning algorithms to automatically resolve contention for shared tools and trigger automated procurement workflows when consumable inventory thresholds are breached.

Integrating the operational perspective directly into executable models is a critical step toward a holistic BPM, where the orchestration of physical assets is no longer an afterthought but a first-class citizen alongside control flow, enabling the support of the execution of physical operations.