Dashbuilder Runtime Demos

Recently, we shared all the improvements that were made to Dashbuilder in a series of blog posts:

Introducing Dashbuilder Runtime

Gradual Export Dashboards from Business Central

Multi Dashboards support in Dashbuilder Runtime

Dashbuilder Runtime Embedded Mode

Developing Custom Components for Dashbuilder

My colleague Manaswini Das also shared some custom components created by her on this blog post:

New improvements and custom components in Dashbuilder

Most of the Dashbuilder features were summarized in this live about dashboards in jBPM created by KIE Live community:

In this post, we will show everything playing together in a demo that uses all features discussed in the articles above.

Demo Content

The demos source can be found in GitHub and they are container images based. Both demos use Docker compose and dashbuilder runtime is always available in localhost:8280/

There are two demos:

  • world_db_dashboard: A demo showing an authoring environment sharing a database dataset with Dashbuilder Runtime. There are simple dashboards provided in world_db_dashboard/overlay/dashbuilder/models/ which can be imported in the authoring environment and then imported on Dashbuilder Runtime. Use Docker or podman compose to start this demo and you will find an authoring environment in localhost:8080/dashbuilder-webapp and dashbuilder runtime in localhost:8280. It is a lighter demo, hence why we didn’t use Business Central, instead, we used Dashbuilder Webapp.
  • jbpm_integration_dashboards: This is the demo that we will be discussing this article. It is configured to connect to a jBPM installation and it also provides scripts to start process instances in jBPM while following the progress in real-time in Dashbuilder Runtime.

Real-time progress and process execution reporting are found in models Evaluation and Mortgage, and in Kie Server, you will find containers with the same name.

Dashbulder Runtime integrated with jBPM Demo

This is a demo that makes use of jBPM full installation that includes Kie Server and Business Central running on localhost:8080. It requires at least 4 GB of free disk space and 4g of free RAM memory.

Dashbuilder integrated with jBPM

The most important piece of integration is about Kie Server credentials and location, we talked about it in Introducing Dashbuilder Runtime, and the system properties configuration can be found in the custom dashbuilder image.

Kie Server configuration

Other important pieces are the custom external components used in models. You can import and develop it in Business Central, but the components are exported along with the dashboards exported ZIP model. In other words, you do not have to worry about moving it to Dashbuilder Runtime, but bear in mind that in jBPM 7.44 release all components are packed in the exported ZIP.

jBPM integration Dashboards

When you start the jbpm_integration_dashboards demo and access dashbuilder runtime in localhost:8280 you will see that multiple dashboards are listed and it happens because multi-mode is on using system property dashbuilder.runtime.multi.

Dashbuilder Runtime multiple dashboards


Let’s discuss these dashboards in-depth starting by talking about Evaluation. A long time ago jBPM community created an evaluation example, which goal is an employee evaluation along with PM and HR evaluations. Each evaluation process is represented by a human task that gets the task owner evaluation and store as a task variable. Once all evaluations are done the process is also finished.

The Evaluation process

Although evaluation is a very simple process, jBPM gets all information to retrieve knowledge from process executions which allow us to build interesting reports. In the Evaluation dashboard, for example, you will find three pages:

Evaluation Process Data: A summary of all evaluations execution along with a heatmap (heatmap is an external component which we will discuss in-depth soon here in this blog) showing the tasks that took more time to finish. This report is in a good format to embed it in other applications.

Summary for evaluation executions

Evaluation Progress: With this page, we can retrieve real-time execution information of processes and it makes use of Victory Charts to show the completion of the evaluation, a heatmap to show the active process nodes, and two built-in components to show the number of active tasks and the number of process hits in the last minute.

Real-time dashboard using Dashbuilder Runtime
Victory Chart component

Evaluation By Employee: This page contains a management report that relies on historical data, not real-time. It queries multiple jBPM tables to you can see details about each evaluation

After executions, users can build reports by querying jBPM tables.

As you can see this relies on jBPM history tables. To query these tables we used SQL and in a future article we will share all scripts used in these reports, but if you want to see more about it just open Evaluation.zip using Data Transfer and you can see all datasets we created.

With the demo, we also provide the client scripts that access Kie Server and creates users and complete tasks. To see the real-time dashboard in action, open it, and run the script main.sh from demos/scripts/evaluation_demo.

Evaluation Script in action


Another famous community process is the mortgage. We decided to build a demo of it because the process can take different paths during the execution and it involves also business rule tasks.

Mortgages Process Definition

One common concern when running a business process is to identify bottlenecks. The mortgage process has two internal loops:

  • When the user enters bad data the process prompts the user until the inputted is corrected.
  • Another loop is after the task “Increase Down Payment”, which re-triggers the execution of the whole process.

The heatmap component is a good fit to find bottlenecks and what tasks are taking longer to finish. For this purpose, we created a single page in dashboard Mortgage that shows how long each task takes to finish and what tasks are more frequently executed. In other words, if you have such a process in your company and the overall performance does not seem good, but you don’t know what is wrong, you could use dashboards like this to identify what is wrong. In our case:

  • If the report shows that the task “Correct Data” is taking too long to finish then a decision that could be made is to improve the form where users input information or call users to finish the form;
  • If internal tasks like Final Approval or Increase Down Payment are taking longer than expected, a solution could be to hire more people responsible to complete these tasks.

This same dashboard can run also in real-time, showing heat information for each task during the process execution.

Mortgage process execution in real-time

For this same dashboard notice again that we use an external heat map component, but we also integrate with a built-in bar chart and filter object, so we can see only Human tasks if we want to do so.

You can also run this same dashboard using the demo, but this time it requires maven and jbang:

MortgagesRobot is a biased robot to highlight and demo the heatmap component, notice how it takes longer to finish some tasks than others.

The result showing that Final Approval took longer than other tasks to finish due Mortgages Robot algorithm.


In this article, we shared our Dashbuilder Runtime demos. It is a lot to explore and we plan to come back with more demos and more detailed posts. So stay tuned!


This post was original published on here.
0 0 votes
Article Rating
Notify of
Inline Feedbacks
View all comments