Modern methods for BPMN-based low-code solutions: How to manage distributed and legacy-burdened applications?

If you dig deeper into the topic of the visual process of creating software solutions – that is, such a thing as the notation of business process modelling (BPMN).

If you succinctly explain, then this is a standard graphical representation of business process modelling. BPMN provides easy-to-use notation with a flowchart that is independent of the implementation environment.

The main rigour is to maintain notation, which facilitates the translation of business-level models into executable models that recognize BPM engines and workflow mechanisms. In recent years, BPMN has been widely used in products related to business process management (BPM), in particular, by providers of tools for both analyzing and modelling business processes, and BPM engines themselves.

Developers of the MEF.DEV platform explains: their proposed principle of operation is a multi-stage scheme that takes into account the types and organizations of business processes using low-code programming. This is a detailed but effective working model.

Here’s what it looks like in practice with specific examples. It all depends on the level of implementation of tasks. And, as in any process, there is a behavioral regime and active and passive structures.

Business level

At the business level, in the general behavioral dimension, it is given: in a Parallel data-driven gateway, several activities and collective efforts are combined, which are aimed at achieving a common goal (for example, the activation of services). In an Exclusive gateway – we are already talking about making business decisions that are subject to certain multitasking (for example, consumer differentiation). The Service-task that the developer needs to solve is to form an individual business process that produces certain roles (for example, verification of roles in business support systems (BSS). The basic Script-task of the application developer is as follows: business behaviour is based on resources, not on flows (here, as an example, webhook request). There is also a Sub-process – when business behaviour achieves a specific result, as planned in BPMN (for example, creating an invoice). At the same time, in the Event context, there is a state change that triggers or breaks into other business behaviour (in particular, obtaining a new invoice). Also in the overall structure of the platform, there is a place for processing the external process, that is, Call-activity – disclosure of the functionality of other external business elements (payment service). The object of interaction in this case is a passive element Data-reference that has a certain value in terms of a business perspective (invoice).

READ ALSO:  Don't you see the digital transformation? But it is here!

Program level

In a Parallel gateway, it is determined which components are needed to perform a common task (for example, the Service Management API). In Exclusive gateway, how the functionality of the component is exposed to the environment is determined (for example, the Customer Management API). The Service-task here describes the user behaviour of the connected process flow (for example, providing permissions to the user’s role). A Script-task is an automated internal behaviour of a program component (transactional billing mediation API). A Sub-process is an internal behaviour that a software component performs to achieve a specific result (creating an invoice). Event component – indicates a change in state that can start or interrupt the behaviour of another application (request per transaction). Call-activity – represents the shared behaviour or functions of the application (transaction processing). The object option Data-reference contains a part of the information in the form of an object type (billing transaction information).

Technological level

A data-driven Parallel gateway at this stage is several nodes that collaborate to perform a common task (an example is a configuration (resource management). Exclusive gateway – determines how you can access the functions of a node (an example is the life cycle of a customer (managing his account). The Service-task here is programming the specific behaviour of several nodes working together in a process flow (an example is user authorization Single sign-on). In turn, a Script-task is when the internal behaviour of a node can be described by a technological function (for example, reservation of user balance funds during the activation of the Rating API service). The Sub-process at this level is a function similar to the technological one, but which focuses more on sequences (an example is the qualification of the service and the definition of the tariff and the rules of charges). The Event component is implemented as an instant element that can be a trigger or interrupt other technological components (for example, a request for access to the service). Call-activity reveals the functionality of the node and makes it accessible public (for example, data management (customer management). Objects Data-refence here are presented in the form of certain physical entities that can be controlled at the technological level (an example is an artifact).

READ ALSO:  A good billing platform is possible thanks to ... partnership synergy

Below this is all shown graphically on the example of a Telecom provider:

  • At the technological level, integrated BSS/OSS systems with different software and data offer access to these application tasks using the open API interface.
  • Program level: applied tasks that use technological components are added to business processes. BPMN elements with complete logic allow you to work with a customizable Omnichannel.
  • Business level: The ordering process and its steps, which are served by a specific application.

But in fact, the mentioned methods, in fact, are a point solution and then in fact those problems that have already arisen and are known in advance. Is it possible to approach the issue comprehensively? As they say, to act on prejudice and where it is even difficult to make predictions about future complications?

As an option – the MEF.DEV platform with automatic code-generation of updated data models that support pattern such as model-first and database-first, including using the reverse engineering approach.

“Standardization of models for code-generation enables the platform to extract decorator attribute data for developer technical documentation with use cases when loading each Business Logic (NuGet) container. All developers see the current version of the specifications due to the fact that this update is automated. All requirements are reduced to a single standard with an auto-update function,” says Sergey Polovnikov, a chief engineer at MEF.DEV.

But that’s not all, the functionality and benefits of the developer platform don’t end there. According to the founder of the project, there is also a Reference architecture (consistent in a ready-made solution) for calibrating processes in large companies.

The presence of built-in DevOps functions in the low-code platform

There are several systems and solutions that provide access to the DevOps functionality (methodology for automating technological processes for assembling, configuring, and deploying software).

The MEF.DEV engineers believe that the main principles here are the principles of flexibility and integrativity, which provide the user with the opportunity to interact with different applications at an understandable level, even those from disparate development teams.

In particular, one of the main aspects of MEF.DEV is precisely that the proposed BPMN-code is adaptive enough to allow the customer to integrate with different systems using a variety of tools, such as APIs, which reduce the complexity of integration with enterprise-grade CI/CD mechanisms like Jenkins and Azure DevOps.

READ ALSO:  Kyivstar stakes on partnership in the development of IT systems

But that’s not all. MEF.DEV also provides the user with the option of built-in functions that support the entire life cycle of the application.

How does it all work? In fact, it is clear and quite simple:

  • One-click deployment: click a button and you open the user interface, workflows, and components of the backend of the integration, and the dependency analysis engine ensures that all running applications are in good condition.
  • Easy migration: publish a new version, apply the changes, and then watch it happen. MEF.DEV checks dependencies and deploys the application smoothly across all environments.
  • Operations and analytics: You can troubleshoot your apps in seconds with easy-to-use productivity dashboards that are created automatically and help your team focus and solve the most important tasks.
  • Configuration management: MEF.DEV handles configuration and management of the identification of running applications and their dependencies when a group of applications is deployed.
  • Built-in version control: Need to go back to a previous version of the program or visually combine your development? No problem! MEF.DEV version control enables intuitive ways to operate with program history and support a rollback strategy.

This combination makes it easy to deploy a complex application in a work version without having to manually create scripts or tasks. Thus, the platform operates faster and easier than traditional approaches.

Results

A high-quality BPMN-code platform, in fact, is able to combine incompatible – developments from many different teams, integrate them into a single panel, thanks to which the customer has a holistic view of the architecture and interaction of various applications, can quickly integrate, operate them, deploy and work. Even if we are not talking about one program, but about simultaneously deploying and managing several.

All this greatly facilitates the understanding and mastery of processes, saves resource costs, allows you to quickly implement the necessary updates or, on the contrary, make rollback to the particular version.

Low-code and BPM systems: consolidation or not?

Performance of BPMN low-code platforms