The vision of this project is to deal with complex data dependencies and process flow entirely model-driven and based thereon, to enact business process models in process engines.


The screencast visualizes the modeling and execution of a data-annotated business process model following the concepts referenced below and can be downloaded here (right click and save as).


Enacting business processes in process engines requires the coverage of control flow, resource assignments, and process data. While the first two aspects are well supported in current process engines, the data perspective needs to be added and maintained manually by a process engineer; an error-prone and time-consuming task. This holds true for process orchestrations – internal processes – as well as process choreographies – interactions of different organizations to exchange information. Following the vision, we started to address issues in this regard by extending BPMN, the industry standard in business process modeling. On the one hand, we augmented BPMN with few concepts that suffice to model and enact complex data dependencies, e.g., m:n relationships, in process orchestrations. On the other hand, we provide a choreography modeling guideline with an operational semantic to handle data retrieval, data transformation, message exchange, and message correlation in process choreographies. The enactment is entirely model-driven, i.e., based on information extracted from the process model.

The current state of the project comprises version 3 of the prototype covering above contributions. The prototype V1 refers to the BPM 2013 conference paper available at Springer online describing the concepts handling complex data dependencies in process orchestrations. This prototype is an extended version of the Activiti process engine that is capable of enacting sufficiently annotated process models. With respect to the BPM 2013 Demo Sessions, we ported the project to the camunda BPM platform and extended the camunda Modeler to allow modeling of sufficiently annotated process models (prototype V2). In version 3 of the prototype, we added support for process choreographies at the modeling and enactment level. A technical report provides the respecting concepts and explanations.

Process Orchestrations

Process orchestration focus on single process models which get executed. Thereby, dependencies and relations between multiple processes are not regarded.

Prototype V1 -- BPM Conference 2013

The first prototype comprises the execution of sufficiently annotated process models where sufficiently means that primary and foreign keys and the type of access (create, read, update, delete) are specified for each data node within the process model. Additionally, a case object has to be specified for the process model. This case object drives the execution. Each data node utilized within the process model is either of the same type or refers to the case object (in)directly via foreign key relations. Thereby, we focus on, i.e. enact, complex data dependencies. Currently, the actual handling of process data like updating multiple attributes of data objects was not in the focus of this work. However, we provide an initial solution to update single data attributes. Complete process data handling is subject of future work. The conference paper describing the details is available at Springer online.

As this prototype is limited to the process engine, the process models need to be annotated manually directly within the XML representation of the process model. The second prototype solves this issues by also providing an extented modeler. Prototype V1 is based on the Activiti process engine.

Next, we describe the availability of the sources, provide a user guide to play around with this prototype, and finally, we provide five example process models that are sufficiently annotated and can be enacted with this prototype.


We deployed the extended Activiti engine in conjunction with five example processes (see below) in a virtual machine, which can be downloaded here. A readme containing the entries from our user guide is found on the virtual machine's desktop. The sudo password for user BPMNData is "BPMNData".

The GIT repository containing the complete source code is available here.

If you like to set up your own Activity instance, you may use the files provided in the GIT repository or linked here:

User Guide

  1. Open Firefox and navigate to http://localhost:8080/activiti-explorer/
  2. Log in with user 'kermit' and password 'kermit'
  3. Go to 'Processes'
  4. Select one of the processes (which are also presented below)
  5. Open a console and type 'tail /var/lib/tomcat7/logs/catalina.out' to see the console output from tomcat, it will tell at which point the process is waiting for which data (in terms of an SQL query).
  6. Open another console and enter 'mysql -u root testdb' to log into the database queried by the process.
  7. Insert rows or update the tables based on the seen SQL query to let the process advance (given below for applicable deployed processes).

Deployed Process Models as Examples

  • Blood Sample Taking Process

  • BPMN Data Automatic Test 1:n Process
    • BPMN XML file
    • SQL queries:
      • INSERT INTO `Order` (`oid`, `state`) VALUES (id, 'created'); with id equalling the process instance identifier OR
      • INSERT INTO `Order` (`oid`, `state`) VALUES (id, 'received'); with id equalling the process instance identifier
      • INSERT INTO `Receipt` (`rid`, `oid`, `state`) VALUES (id, NULL, 'approved'); with id being a unique varchar
    • Case objects
      • Process: Order
      • Subprocess: Product
      • Multi Instance Subprocess: Shipment

  • BPMN Data Automatic Test m:n Process
    • BPMN XML file
    • SQL queries:
      • INSERT INTO `BTO` (`btoid`, `state`) VALUES (id, 'started'); with id equalling the process instance identifier
      • INSERT INTO `Order` (`oid`, `btoid`, `state`) VALUES (id, NULL, 'received'); with id being a unique varchar
    • Case objects
      • Process: BTO
      • First Multi Instance Subprocess: Order
      • Second Multi Instance Subprocess: Material Order

Prototype V2 -- BPM Demos 2013

The second prototype refers to the same concepts as described in the BPM 2013 conference paper and comprised by the prototype V1. However, we ported the source code from the Activiti process engine to the camunda BPM platform. Additionally, we extended the prototype with an modeler realized within the camunda Modeler. It allows to graphically model sufficently annotated process models which then can be enacted within the camunda BPM platform. For details, please check the corresponding BPM 2013 Demo paper. Below, you find the sources of the second prototype.


You can retrieve the complete source code from our GIT repository. Alternatively, you can download Eclipse, install the modeler as plugin, and utilize this preparded Tomcat web server for process execution. Additionally, you have to set up a MySQL database with name "test" and user "testuser" having the password "test623". This information can be adapted in file "bpm-platform.xml" to be found in the configuration folder of the Tomcat. For each data object utilized in a process model, this database requires a table with the same name and a coloumn for the primary key, the state, and each corresponding foreign key as well as additional attribute. You may also download a prepared demo process.

Using the second version follows the usage of a common Camunda BPM project as described on their website. For executing a process model, set up the SQL data base tables, use the modeler to create one, create the deployment artifact, direct your browser to localhost, deploy the artifact, and start the process model.

A readme with further details is contained in the GIT repository.

Process Choreographies

Process choreographies describe the interaction between different organizations via message exchange. Thereby, each organization runs its local and private process orchestrations.

Prototype V3 -- CAiSE Conference 2014

The third prototype extends the second one by adding choreography support. This is achieved by giving the process designer the chance to specify message correlation on the model level by using correlation keys; the interpretation is done at run-time to actually correlate messages and activity instances. Furthermore, the prototype extends the camunda BPM platform with means to retrieve the data required for message creation from a database, to transform the local data objects into a message complying to a specified global data model, and to handle the mentioned correlation on instance level. The actual message passing between two organization, i.e., between the process engines of both organizations is out of scope of the prototype is assumed to be handled by standard technologies such as middleware or Web services. Details about the concepts are provided in a technical report.

Below, you find details about the sources and our implementations of the service interaction patterns which we utilize to evaluate this prototype.


We deployed two extended camunda engines in conjunction with the service interaction patterns. A zip-file containing the deployments can be downloaded here. A readme containing the user guide is included in the zip-file as well as the SQL-scripts required to set up the database to run the service interaction patterns.

The source code for the extended camunda BPM platform and extended camunda modeler are published in the respective GIT repositories in our GitHub.

Implementations of Service Interaction Patterns

The pattern implementations can be found within the examples folder in the GIT repository of our extended camunda BPM platform.


Andreas Meyer
Luise Pufahl
Dirk Fahland
Mathias Weske
Kimon Batoulis
Sebastian Kruse
Thorben Lindhauer
Thomas Stoff