Hi,
I recently faced a scenario where three companies interact in a process, and I wanted to model each company as its own BPMN pool. Focusing on one of those companies, the departments are modeled as lanes. One particular role in the company is responsible for orchestrating tasks across the different lanes. At one point in the process, this orchestrator must wait for three messages from other lanes before emitting a message itself. The sequence in which the incomming messages arrive is not known in advance. This is where the challenge began.
Approach A: Parallel Gateway with Message Catch Event
My first idea was to use three Message Catch Events combined with an AND-Split and AND-Join within the orchestrator lane. The problem: at the split, each output got a token, and each Message Catch Event received also a token from the sending lanes (connected via sequence flows). The result was six tokens arriving at the Join Gateway-twice as many as intended.
Approach B: Encapsulating Parallel Gateway in a Subprocess
I then tried putting the parallel gateway structure inside a subprocess. This should solve the token issue, but I ran into a different problem: I couldn’t connect flows from message throwing tasks in other lanes to the message catch events inside the subprocess.
I am aware that BPMN does not allow sending messages within a pool. However, in the real-world scenario I want to model, there are essentially internal messages exchanged within the company.
What could be an approach to such a case?
Thank you very much for any hint.
Hi and welcome to the forums!
In the BPMN language, messages cannot be thrown and received within a single process.
So, you can model the three “silos” within Org 1 as independent processes, or you can simply allow the work to flow from lane to lane.
If a flow goes from Lane 1 to Lane 2, that flow can imply that there is a message going from the worker completing the work in Lane 1 to the worker in Lane 2, but the role of the Orchestrator (eg. Camunda or “Orchestrator Lane”) is to present (and coordinate) the work between groups.
If this were an automated process, the worker (script) completing the task in Lane 1 would send a “I’ve completed the work” message back to the Orchestrator (Camunda), and then the Orchestrator arranges what has to happen next.
If (and this is a big if) the parts of the process that run in lanes actually belong to the same process, you can consider using Condition Event instead of Message Event to do the trick of handling Internal communications.
Something like this would be what I would do…
Thanks for your replies. The approach of using sequence flows that flow from one lane to the next, split and joined by a parallel gateway, while omitting any message throw tasks and catch events, made me think about the problem in a different way and might be a solution. The only downside, not having fully adapted my model so far, is that the difference in visualization between what is esentially just a message flow (e.g., “Task executed” reported from lane A to lane B), and procedural flows (e.g., an arbitrary task A is followed by an arbitrary task B) is not as clear as when using distinct symbols for messages. One idea and question which came to my mind is wether it might also be an approach (and maybe something used in everyday practice) to model each lane/role as its own pool and process, and then group all pools belonging to one company afterwards?
Moving tasks to their own process just to enable messages is a bit of an overkill and, in the worst case scenario, could be a misrepresentation of your business process.
Semantically speaking, a sequence connecting tasks A and B conveys exactly the idea that after, and only after, Task A terminates, Task B will start.
As @claudio_rio noted, that could be misleading.
However, depending on how silo’ed your organization is, it might be a valid setup.
In a company I worked with a few years ago, Team A tracked all their service requests in one system, while Team B tracked all their service requests in a different system (all within the same company!). In that world, modeling Team A and Team B as distinct pools makes sense.
Realistically, all sequence flows are (at some level of comprehension) a form of message passing between one participant and another (a scripted worker is still participating) - and that message says “I have completed ‘Task XYZ’ please start working on your next task”
1 Like
Found some insights from Bruce Silver exactly about this:
1 Like
Thanks a lot for your support and your helpful explanations. Then I will stick with using a sequence flow to represent communication between different lanes.
