Why BPMN Interchange Is So Important

I wrote before about why I think BPMN is brilliant, and in that post I shared a little bit about the community. Recently, the main BPMN tool builders worked together to create a demo, the BPMN Interchange, that showcased the power of BPMN as an open standard. I wanted to take some time to explain why this collaboration is so important, both for the community of users and the BPMN standard itself. To do that, I’m going to discuss how and why 11 different BPMN vendors decided to get together and show off how well they all work together—and it all starts with BPMN’s open standards.

Open standards allow flexibility

When you see a BPMN model, you might not be aware that everything you see visually is also being represented by an XML metamodel. For example, behind this simple process:

…is this jumble of text:

<?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" xmlns:modeler="http://camunda.org/schema/modeler/1.0" id="Definitions_1kdt7t5" targetNamespace="http://bpmn.io/schema/bpmn" exporter="Camunda Modeler" exporterVersion="5.24.0" modeler:executionPlatform="Camunda Cloud" modeler:executionPlatformVersion="8.5.0">
  <bpmn:process id="Process_1yomcha" isExecutable="true">
 <bpmn:startEvent id="StartEvent_1">
   <bpmn:outgoing>Flow_1of45it</bpmn:outgoing>
 </bpmn:startEvent>
 <bpmn:sequenceFlow id="Flow_1of45it" sourceRef="StartEvent_1" targetRef="Activity_00i8pry" />
 <bpmn:endEvent id="Event_0kpltiu">
   <bpmn:incoming>Flow_1pmm9i9</bpmn:incoming>
 </bpmn:endEvent>
 <bpmn:sequenceFlow id="Flow_1pmm9i9" sourceRef="Activity_00i8pry" targetRef="Event_0kpltiu" />
 <bpmn:userTask id="Activity_00i8pry" name="Just a Task">
   <bpmn:incoming>Flow_1of45it</bpmn:incoming>
   <bpmn:outgoing>Flow_1pmm9i9</bpmn:outgoing>
 </bpmn:userTask>
  </bpmn:process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_1">
 <bpmndi:BPMNPlane id="BPMNPlane_1" bpmnElement="Process_1yomcha">
   <bpmndi:BPMNShape id="_BPMNShape_StartEvent_2" bpmnElement="StartEvent_1">
     <dc:Bounds x="179" y="99" width="36" height="36" />
   </bpmndi:BPMNShape>
   <bpmndi:BPMNShape id="Event_0kpltiu_di" bpmnElement="Event_0kpltiu">
     <dc:Bounds x="432" y="99" width="36" height="36" />
   </bpmndi:BPMNShape>
   <bpmndi:BPMNShape id="Activity_10ligid_di" bpmnElement="Activity_00i8pry">
     <dc:Bounds x="270" y="77" width="100" height="80" />
   </bpmndi:BPMNShape>
   <bpmndi:BPMNEdge id="Flow_1of45it_di" bpmnElement="Flow_1of45it">
     <di:waypoint x="215" y="117" />
     <di:waypoint x="270" y="117" />
   </bpmndi:BPMNEdge>
   <bpmndi:BPMNEdge id="Flow_1pmm9i9_di" bpmnElement="Flow_1pmm9i9">
     <di:waypoint x="370" y="117" />
     <di:waypoint x="432" y="117" />
   </bpmndi:BPMNEdge>
 </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</bpmn:definitions>

Reading this XML is not important for the vast majority of users, but it is important to know that the BPMN specification, in addition to describing how all of the symbols look and function, also describes how those symbols are represented in XML. As a result, any modeling tool that wants to properly implement BPMN can start by converting the XML to the visual representation (or vice versa).

The XML standard also means that all tools that properly implement the BPMN standard will be able to display a BPMN model, irrespective of where and how it was created. If you’ve built your model in Trisotech and want to continue modeling it in Camunda—no problem, just move the file from one tool to another.

Following the XML standard for BPMN means that there shouldn’t be any vendor lock-in for your BPMN tooling. If you like, you can even switch from one tool for another depending on the context in which you model. For example, back in 2013, before we had built our BPMN.io tooling, Camunda was simply a company with a BPMN engine that understood the XML and was able to execute those symbols. Our original Eclipse-based modeler was designed specifically for developers to add execution semantics. At that time, most process designers would pick a more design-focused modeler like Signavio to model their process, then transfer the file to Camunda to add the technical attributes.

These days, of course, we have modeler that can do both, but it was the openness of the BPMN standard that created the space for persona-defined tooling, and allowed for a huge variety of options for the community of users—and lots of potential for the BPMN tool makers.

The Model Interchange Working Group demo

Now that we understand how BPMN allows flexibility between different tools, we can talk about the collaboration between 11 different modeling tools. The group behind this annual demo is the Model Interchange Working Group (MIWG). This group is made of representatives from 11 BPMN vendors including our very own Camundi Maciej Barelkowski and Falko Menge. The goal of the group is to facilitate cooperation and support among BPMN vendors so that models built in any tool can be understood and properly rendered by any other. The annual demo is a way of showcasing that the group’s work is really accomplishing its goal.

This year’s demo for the BPMN Interchange is now available on YouTube and features three BPMN models being built piece-by-piece with 11 different modeling tools—live—over the course of about 30 minutes. I think it’s kind of amazing. This demo exists as a testament to how well and thoroughly these tools implement the BPMN standard, but also to showcase the strength of the community of vendors supporting BPMN.

Each year the demo is built around a specific theme—this year was subprocesses. That includes Embedded Subprocess, Call Activities, and of course Event Subprocesses. To demonstrate these symbols three interconnected models were built.

Below, you’ll see the model that the Camunda Modeler was involved in creating.

Camunda’s Web Modeler, which is built on BPMN.io, is used to build the timeout event subprocess. I was particularly happy about that because as I said during the recording, it truly is my favorite BPMN symbol. That isn’t where our involvement ends though—those open source BPMN.io libraries we started building back in 2014 are now well-established in the BPMN community and available to anyone who might be interested in using them. In this demo, three out of the 11 vendors chose BPMN.io as their preferred tool to display and edit BPMN models. Learning that was very exciting, and we hope to see more in future demos.

Conclusion

You’ll often hear the term “community” being used as a synonym for “users,” but this misrepresents how a real community dynamic can function. In the BPMN community, there are indeed users and practitioners who work with the standard and perhaps champion its usage. However, it’s important to note that this community also includes the people maintaining the standard itself and, of course, those building the tools so that the standard can be the most effective. These groups also overlap! These individuals don’t exist in isolation. They are connected by a shared, honest, and unironic love for the standard, and are working together to make it the success it is.

While BPMN is popular because it is, indeed, brilliant, the community around it is a big reason it shines the way it has. The BPMN community is brilliant in its own right—where else would you find would-be competitors working together to prove that each is as good as another because of the shared standard they implement?

Watch the demo

You can watch the BPMN Interchange demo in action on YouTube or just click Play below. The demo runs every year, and as I mentioned, we try out a different theme each year, so feel free to suggest in the comments some themes, symbols or patterns you’d be interested in seeing at the next demo. The MIWG group is also open to more vendors taking part—so if you use a modeling tool that you’d like to see as part of the group, it’s a great idea to put them forward.