Evolving your Business Processes through Time Aware modelling
Earlier this week I was spending a little time flitting around the various LinkedIn groups that I frequent. In one of the BPMN groups, the group admin had set a fun little challenge as follows:
Create a BPMN model for this leave application process:
- Employee applies for annual leave
- Employee must submit the request to their Manager if the leave is < = 5 days
- Employee must submit the leave to their CEO if the leave is < 5 days
- The Manager or CEO approve/reject the leave
- The Manager or CEO inform Employee that their leave application is approved / rejected
I had some time to spare & thought I would quickly whip up a process model to represent this in its most simple form. This was the result:
As you can see, this is probably as simple as this scenario could possibly be made. But, what if I want to evolve this model, how can I show the evolution of this process?
Time Aware BPMN modelling
You may or may not be aware of the ability to create time aware models within Sparx Systems Enterprise Architect, and this functionality allows us to take our as-is process (the simple process), clone it and make the modifications to process that will show our future state…the to-be model.
So how does this work?
This process works by cloning an existing package and its content as a new structure and using EA to give the newly cloned diagram a new version number.
For BPMN modellers, there is a trick that you must be aware of. Cloning a BPMN diagram for the purpose of time aware modelling requires that the diagram in question is at the highest possible level within the package being cloned. This means that you cannot have the diagram created beneath a model element as shown here:
If you were to attempt to clone this, all that you would end up with is the package structure. To get the successful cloning your package needs to look like this:
If you have an existing model within a model element, all is not lost. First, you will need to copy the package using this option:
Next, paste the package from the clipboard into your repository & rename it e.g. Package X for Time Aware. Then, open the package and expand the model element. Following that, move the diagram and all the elements to the top level of the package. You can then delete the model element as it will not be used and would still be present on the original version.
Having done this, you will now be able to clone the package successfully to undertake your time aware modelling activities.
There are a few things that you need to be aware of. For example, you must remember to rename the cloned diagram to reflect its new version so that it is obvious at a glance. This will prevent you from confusing the new version with the old.
Additionally, to make use of this functionality you will need to activate the following filters on the new diagram:
- Filter to Version
- New to Version
The ‘filter to version’ option will look at your cloned diagram and then grey-out anything that is the same as within version one. The’ new to version’ option will display any element added to the new version as ‘normal’, allowing you distinguish between features that are in place within your process and the features that you wish to add to your process in the newer version.
You can even make minor modifications to version one elements & have them render for version two. You can do this by right-clicking one of your greyed-out elements and cloning to new version:
You will of course need to ensure that the version number you assign to this cloned element matches the version number that you have assigned to the diagram. This will then allow you to see the new version of the element on your to-be diagram.
With this in mind, let us jump back to the original example in this article and see how it has evolved using this time aware approach:
As you can see, in the to-be version of this simple process model, we can immediately see the differences between version one and version two, in which we have modelled how we would like this process to function in a future state, whilst retaining the ability to see how the original version functioned. This has been achieved through a combination of adding entirely new elements and cloning some of the original elements to this version and altering their properties.
This will allow you to make informed decisions on how you can change your processes over time before making sweeping change without seeing the effect on your current state of play.