We’re taking a bit more time to ensure the program continues to offer a rewarding experience for all Champions—past, present and future.

How to become a Camunda Champion

There’s no single path to becoming a Champion—we recognize and value a wide range of contributions. Whether you’re writing code, giving talks, creating tutorials, or supporting others, we want to hear from you!

Here are some of the ways you can contribute and we consider key for the program:

• Camunda 8 Expert – Demonstrate deep expertise in Camunda 8
  
• Code Contributor – Enhance Camunda projects with your coding skills
  
• Tutorial Creator – Share your knowledge through engaging YouTube videos
  
• Marketplace Innovator – Build and maintain connectors or blueprints
  
• Blog Writer – Share insights via blog posts, internally or externally
  
• Event Speaker – Present your work and ideas at meet-ups or conferences
  
• Meet-up Organizer – Bring people together by hosting local meet-ups
  
• Knowledge Sharer – Lead knowledge-sharing sessions in your organization
  
• Supportive Mentor – Help others in the community through the Forum
  
• Passionate Advocate – Spread the word and inspire others to build with Camunda
  

If you’re unsure whether you should apply—go for it! When the time comes, fill out the application form when it opens in October.

Learn more about the program and current Champions here: Camunda Champion Program.

Stay Informed

We’ll share more details as the date approaches through the Camunda Developer Newsletter and our social media channels. Be sure to follow us to stay in the loop!

We can’t wait to welcome a new cohort of passionate, engaged, and inspiring Champions this October!

The post 2025 Camunda Champion Program Launching in October appeared first on Camunda.

To celebrate our most active members, we created the Camunda Champion Program. This initiative recognizes our top community leaders and enables them to continue sharing their knowledge and helping others.

This year marks our sixth cohort of Camunda Champions. We received applications from community members worldwide, and we thank each of you for applying. If you weren’t selected this time, we encourage you to apply again in the future!

With that, we’re thrilled to extend a warm welcome to our new Champions joining us this year! We’re equally excited for those returning Champions who continue to lead the way and embody what the Camunda community stands for. To those who are stepping down, we offer our heartfelt thanks for your invaluable contributions.

What it means to be a Champion

	“To me, becoming a Champion means sharing my passion for Camunda in a way that energizes everyone around me. When I talk about Camunda, my enthusiasm inspires others and ignites their curiosity.  It’s about being a driving force that encourages others to explore the possibilities and benefits of Camunda. My goal is to foster that spark of curiosity and motivation, helping others to see the potential for transformation through the power of Camunda.” —Maria Alish, new Champion. Poland, IBA Group/ IBA Poland
	Being a Camunda Champion for me is a great opportunity to contribute to the community, and of course a chance to meet a lot of great people. It is a great joy to be part of such a passionate community. —Tomas Walek, new Champion. Czech Republic, Astomicon
	Becoming a Camunda Champion means that I have the recognition of being a valued contributor in the Camunda community and that I possess both theoretical and technical skills related to the technology and the types of problems it is designed to solve. —Gerard Lapi Emo, new Champion. Belgium, independent consultant
	“I’m absolutely thrilled to be a Champion and to be part of this amazing community! “ —Patrick Wunderlich, returning Champion. Germany, Holisticon

We can’t wait to see what our Champions will accomplish in the coming year. You can learn more about our new Champions and their journeys on our Camunda Champion Program page. Here’s to another great year of growth, collaboration, and innovation! ????

Interested in becoming a Camunda Champion?

We want to hear from you! Find out more about the program and start looking for ways to contribute back to the Camunda community. The next cohort of Champions will start in the fall of 2025. We’ll open up the application period in August 2025. Subscribe to our developer newsletter to be reminded when Champion applications open next!

The post Welcome Camunda Champions! appeared first on Camunda.

Acknowledgment: Thanks to Camunda’s Connector team for introducing the Amazon SageMaker Connector. In a previous article, I explored the concept of Prediction as a Service using Camunda 8’s Lambda Connector. At that time, the Amazon SageMaker connector had been released, but I couldn’t find it in the Connector marketplace—possibly because it was just getting started or wasn’t fully available.

In this article, we explore the extensive use of Amazon SageMaker along with other Connectors such as the SQL Connector and Slack Connector. Additionally, we will utilize the Intermediate Message Catch Event.

Story Telling

As a Bank Manager, thoroughly evaluating applicants for loan eligibility is crucial to making sound financial decisions. Leveraging Machine Learning algorithms can significantly enhance this assessment process. Classification algorithms, such as Logistic Regression, are particularly useful for predicting whether an applicant is likely to qualify for a loan.

By applying these algorithms, we can analyze various features of an applicant’s financial history, such as credit score, income level, debt-to-income ratio, and previous loan repayment behavior. Logistic Regression helps in modeling the probability of an applicant meeting the eligibility criteria based on these features.

Additionally, other classification techniques like Decision Trees, Random Forests, and Support Vector Machines can further refine predictions. These models can be trained on historical data to identify patterns, making more accurate predictions about future applicants.

Integrating these Machine Learning models into our loan assessment process provides a more objective and data-driven approach, potentially reducing the risk of defaults and improving overall loan approval efficiency.

For this use case, I utilized Amazon SageMaker to train a sophisticated machine learning model using historical data. SageMaker’s robust platform enabled me to develop and fine-tune the model effectively. Once trained, the model was deployed as a real-time endpoint, allowing for seamless integration into our loan assessment workflow.

This deployment ensures that we can leverage the model’s predictive capabilities to evaluate applicants efficiently and accurately. By harnessing SageMaker’s powerful infrastructure, we can continuously refine the model with new data, ensuring it adapts to evolving financial trends and patterns, ultimately enhancing our decision-making process for loan approvals. However, in this article we are not covering the deployment process.

Modelling and Implementation

The BPM (Business Process Management) modeling for this use case is straightforward and does not require complex modeling techniques. Once a loan application is submitted, a process instance is triggered. This instance then calls the inference endpoint created in Amazon SageMaker. The endpoint evaluates the applicant’s data and returns a classification indicating their loan eligibility.

Configuration for Camunda Amazon SageMaker Connector:

• IAM User: Use the IAM user that has access to the model and update the Access Key and Secret Key. Also, update the region appropriately.

• Endpoint Name: Update the endpoint name, and payload that’s needed by the model to make predictions (I have stored the applicant’s data as a process variable, which can be accessed via FEEL expressions).

If you have already deployed your model for inference in SageMaker, you can find it in AWS console under SageMaker Service.

• Update target model

Target Model Name can be obtained from AWS console under Inference section of Sagemaker.

Classification and Inference

The model classifies each applicant into one of four categories:

0: Rejection due to Low Credit Score
1: Rejection due to High Debt
2: Rejection due to Missing Information
3: Approval

The inference response, which could be 0, 1, 2, or 3, is then processed by the DMN (Decision Model and Notation). The DMN interprets the numeric response and outputs the corresponding classification type.

The DMN is represented as below:

Once output from DMN is obtained a conditional gateway would decide the route to Slack notification.

Based on the output from the DMN, we notify applicants of their application status. In this example, notifications are sent via Slack.

Use of Camunda for This Case

Camunda’s platform provides an efficient way to orchestrate and automate the loan application process without requiring extensive coding. By leveraging Camunda’s Connectors and BPMN (Business Process Model and Notation) features, we can easily integrate machine learning predictions and decision-making workflows.

Key Benefits:

• No Extensive Coding Required: With Camunda, most of the process orchestration can be configured using graphical BPMN models and built-in Connectors, minimizing the need for custom code.
• Integration with Amazon SageMaker: Using Camunda’s SageMaker connector, we can seamlessly call machine learning inference endpoints to classify loan applicants based on their data.
• Decision Automation: The DMN (Decision Model and Notation) can be used to automatically interpret the machine learning model’s output and determine the applicant’s eligibility status.
• Notification Integration: Camunda’s connectors, like the Slack/Whatsapp connector, allow for easy setup of notifications to communicate the decision to applicants.

Process Overview:

1. Application Submission: A process instance is triggered upon loan application submission.
2. Inference Call: The process instance makes a call to the Amazon SageMaker inference endpoint.
3. DMN Evaluation: The response from SageMaker is processed by the DMN to determine the classification type.
4. Notification: Based on the DMN output, a conditional gateway routes the process to send a notification via Slack.

This streamlined process leverages Camunda’s powerful workflow automation capabilities, enabling quick and accurate loan application processing with minimal manual intervention.

Read next

Looking for more about how process orchestration can help in scenarios just like this? Be sure to check out our blog post, Effective Loan Automation with Process Orchestration.

The post Integrating Process Orchestration with Machine Learning for Bank Loan Applications appeared first on Camunda.

Do you have a passion for Camunda? Do you enjoy sharing your knowledge and helping others succeed? Then you might be a Camunda Champion! Read on to learn how the Camunda Champion Program recognizes and supports outstanding contributors in our community.

Why become a Camunda Champion?

As a Camunda Champion, you’ll gain access to exclusive resources, insider knowledge, exclusive swag, networking opportunities, and special events. Plus, you’ll be publicly recognized for your contributions and play a key role in shaping the future of our community.

Who is a Camunda Champion?

A Camunda Champion is a true community hero, someone who goes above and beyond to make a difference. Champions come in many forms, and their contributions are as diverse as our community. They do outstanding work that benefits the wider Camunda community, but also advocate within their own companies. Here are just a few ways in which you might shine as a Camunda Champion:

• Camunda 8 expert: Demonstrate deep expertise in Camunda 8.
• Code contributor: Enhance Camunda projects with your coding skills, either with contributions to the core Camunda product or community-maintained extensions.
• Tutorial creator: Share your knowledge through engaging YouTube videos.
• Marketplace innovator: Develop, share, and maintain Connectors and blueprints.
• Blog writer: Inspire and inform others with your insightful blog posts, whether internally for your company documentation or externally for the larger technical community to benefit from.
• Event speaker: Talk about your work and share your expertise with others.
• Camunda meet-up organizer: Bring people together by organizing local meet-ups.
• Knowledge sharer: Foster a culture of learning within your company by leading regular knowledge-sharing sessions, also known as a community of practice.
• Supportive mentor: Assist others in the community on our forum.
• Passionate Advocate. Inspire and support community members across the Camunda ecosystem.

What’s new this year?

We have added ways to recognize those whose contributions are internal to their company and not publicly visible. Over time, we have seen more and more potential Champions whose contributions are not externally visible. Maybe you are known as the expert on Camunda within your company and create internal trainings, or you organize knowledge-sharing sessions for your coworkers. Maybe you have a mix of internal and external contributions. Whatever your contributions look like, if you live up to the qualities of a Champion, we would love to see your submission.

How to apply

Applying is simple! Just head over to our application page and apply.

Please note that if your contributions are mainly internal (i.e. not visible to our application committee), we will require a 30-minute meeting between you and one of our Developer Advocates to get to know you better. Be sure to do this as soon as possible, and no later than September 30, to secure your spot. This meeting is a mandatory step to be considered by the selection committee.

Do you know someone who embodies the qualities of a Camunda Champion? Encourage them to apply!

The Champion Program is a year-long program, with the next cohort of Champions starting in November 2024. Applications are open until September 30, 2024, and all candidates will be notified no later than November 1, 2024.

Don’t miss out on the chance to be part of something amazing. We look forward to seeing your applications!

The post Are you a Camunda Champion? appeared first on Camunda.

Five years later, this goal continues to drive everything we do. With new team members joining us, it’s the perfect time to reintroduce ourselves and share our vision. As our team and community have grown, we’re excited to keep fostering a space where knowledge, collaboration, and innovation thrive!

Our community vision

Our vision for the community is simple: it’s all about you, our passionate Camunda users. You’re dedicated to process orchestration excellence and eager to share your insights! Your feedback helps us create a better experience, and the knowledge you share with fellow users helps everyone gain more value.

By creating platforms for you to ask questions, discuss best practices, suggest feedback, and share community-maintained extensions, we connect you to other community members, enhancing the collective learning and growth.

The community programs launched in the last few years, including Champions, Educational License Program and so many more, have empowered you with additional resources, conversations with other Camundi, and early access to product features.

What does this mean on a practical level? For 2024, we’re focused on three key areas:

• Technical Awareness – Through videos, blog posts, talks, and sample code, we aim to help the broader technical community understand process orchestration and the problems it can solve for them.
• User Enablement – Our goal is to help you succeed with Camunda through community platforms, programs, and technical content. We also often support you in creating your own content or helping your fellow community members in the forum!
• Community Growth – While focusing on those of you who are already engaged with us through meet-ups, forum posts, and code contributions (hi!), we also want to attract new community members so that we can all benefit from greater collective knowledge about process orchestration.

The journey so far

Over the past five years, our community has grown and transformed. We’ve expanded, iterated on, and launched various platforms and programs to better support and connect Camunda users. Our forum has become a hub for troubleshooting and sharing knowledge, while our volunteer-run meet-ups continue to offer opportunities to learn and network.

With a little bit of structure and a clear goal, we’ve been able to partner with you to bring even more programs into existence. Here are a few highlights:

• With Camunda’s German roots, we couldn’t overlook Hacktoberfest and its play on words for Oktoberfest. We first participated in October 2020 and have received amazing community contributions to our core products as well as community-maintained repositories ever since.
• January 2021 brought the announcement of Camunda for Common Good, one of Camunda’s philanthropic programs. Qualifying NGOs and nonprofits benefit from access to an enterprise license completely free of charge in an effort to further their mission.
• Our first public commits to the Camunda Community Hub were in March 2021. This GitHub organization collects community-maintained repos in a single place, allowing for easier access to tools that can get you up and running more quickly.
• In April 2021 we hosted our very first Community Summit, geared specifically toward developers, enterprise architects, and process automation experts. We introduced the idea of an “unconference” which was incredibly well-received and has continued to be a part of our in-person CamundaCon events. Join us in NYC in October to participate in the next one!
• The Camunda Champion Program, which supports our most engaged community members, was launched in June 2021. To date, we’ve welcomed 47 different Champions to the program, many of whom have renewed their Champion status every year. Interested in joining this exclusive group? We’re preparing to open applications for our sixth cohort in August!
• Our Community Values were launched with the help of our Camunda Champions in November 2022. These values have become a “north star” for the programs we run and the platforms we oversee, ensuring we continue to be transparent and accountable for our actions, and orchestrate with heart.
• While we’ve been giving guest lectures at universities for years, the Educational License Program was made official in January 2023. Through this program, we give special access to Camunda for university professors who want to teach BPMN or Camunda in their class, or graduate students who want to use Camunda for their thesis. To date, we’ve worked with more than 90 universities from 25 different countries and supported over 750 students!
• In May 2023, Senior Developer Advocate Niall Deehan recognized we needed a more formalized internal feedback loop to pass along all of the wonderful feedback you give us. With a few rounds of iteration, he came up with a simple process that has resulted in more than 80 pieces of feedback handed over to the product management team alone in the past year. Even more exciting, over 50% of those items have made significant progress through the roadmap!
• The Orchestration Hour was created in May 2023 to give us a more interactive way to test out ideas, try new Camunda features, and learn out loud with all of you. We’re exploring new ideas for segments, like the recent “BPMN Battle” episode, so let us know what you want to see!
• We partnered with Marketing to re-launch the much anticipated Camunda Community Podcast in July 2023, interviewing Camunda Engineers and Product Managers in addition to community members to learn all the best tips and tricks.
• The Camunda forum has been around since 2016, providing a place for Camunda users to have discussions, offer feedback, and troubleshoot issues. Throughout 2023, we consolidated and cleaned up the categories and tags in the forum to make it easier to navigate and find the answers you’re looking for.
• We published our first Community Impact Report in January 2024, looking back on an amazing year of contributions, collaborations, content, and more.
• Through all of these additional platforms and programs, we’ve maintained our Camunda meet-up program, now renamed Camunda Chapters. As of July 2024, we have 36 active chapters across 19 countries, all run by amazing volunteers (thank you!).

We continue to produce a wide range of content in various formats. Whether you prefer YouTube videos, blog posts, podcast episodes, sample code, or in-person events, we’ve got you covered!

In the future, we have dreams of expanding the Champion program to include “internal Champions” – folks who contribute heavily to their organization’s success with Camunda but aren’t creating as much external content, creating a guest blogging program for you to share your process orchestration stories, and so much more!

The “Dream Team” behind the Camunda Community

I have the pleasure of leading an absolute dream team of individuals who are making our community vision a reality! Our team of Developer Advocates focuses on technical content for both developers who use and maintain Camunda instances and Enterprise Architects who guide the technical decisions behind a company’s digital transformation.

We also formed a strong community-focused team responsible for enhancing contributor experiences and managing community programs. They also track behind-the-scenes metrics so we can better understand what resources would be useful for you in the future.

Danielle Andrist – Community Growth Manager Joined in March 2020. Data explorer, organization junkie, reformatting fanatic, bad joke teller.
Jacob Plicque – Senior Developer Advocate Joined in June 2024. Storyteller, loud ridiculous hype-man, doggo dad, dice dragon.
Maria Alcantara – Senior Community Manager Joined in July 2021. Modern nomad, enthusiastic runner, yogi, climber, artist, and passionate creator of communities.
Mary Thengvall – Director of Developer Relations Joined in December 2019. Lover of dogs, cheese, live music, community gatherings, and living in the mountains.
Mia Moore – Senior Technical Community Builder Joined in June 2022. Big fan of birds, vegan food, and video games.
Nathan Loding – Developer Advocate Joined in January 2023. Technologist and problem solver, sometimes gardener, and Oreo enthusiast. Known to wear balloon hats in public.
Niall Deehan – Senior Developer Advocate Joined in April 2015. Maker of tutorials, teller of stories, keeper of secrets, and builder of unmaintainable example projects.
Samantha Holstine – Developer Advocate Joined in September 2023. Dancing and rowing enthusiast, corgi mom, foodie, nature junkie.

Feedback welcome!

Above all else, we are motivated to do work that makes a difference for you! While we draw conclusions from forum themes, popular features, and one-on-one conversations, we’d love even more feedback.

• What questions can we answer?
• What resources are you looking for?
• What problems are you trying to solve?
• What features would you like to see?

Our goal is to empower you to do your best work. Head to the forum to let us know how we can help!

—Mary, on behalf of the DevRel Dream Team

The post DevRel “Dream Team”—How we Empower Camunda Users appeared first on Camunda.

We’re looking for:

• Process blueprints: Showcase detailed visual workflows, such as customer onboarding processes
• Technical solutions: Share best practices for challenges such as incident handling of RPA bots, or demonstrate specialized BPMN patterns for modeling complexities
• Diverse perspectives: Whether you have an industry-specific approach or a unique problem-solving technique, your contribution can make a difference

Why contribute?

Whether you have process blueprints to share or you’re building Connectors, we welcome your contributions to Camunda Marketplace. There are two ways to contribute:

• Open source BPMN process models that users can immediately start using in their Camunda instance
• Listing-only blueprints that describe a solution and provide instructions, screenshots, and videos

We look forward to seeing creative and practical solutions that can help shape the future of process orchestration and automation. Join our growing community today!

And don’t forget, if you have suggestions for the Camunda Engineering Team, our partners, or our developer community, visit the Idea Portal and let us know!

The post Introducing Process Blueprints in Camunda Marketplace appeared first on Camunda.

When using tools like incident.io to manage your incidents—not talking about Camunda incidents in your business processes, but incidents that relate to your general system/offering and production system—it is often useful to get an overview of ongoing incidents. Furthermore, it is beneficial to get reports based on certain (custom) filters like affected teams, severity, etc.

Unfortunately, incident.io doesn’t support this type of reporting out-of-the-box. Camunda can help here ????

Today, I want to show you how you can get the necessary statistics from incident.io, extract the necessary results, and post them for example to Slack to create a daily incident statistics update with Camunda.

Get details from incident.io

The incident.io API is rather simple and well-documented. All necessary information can be found in their API docs https://api-docs.incident.io/.

API Key

As a first step, you have to create an API token. Follow this guide to create one.

After you have this make sure to store it somewhere safe.

Incidents API

We want to get the current statistics for the Incidents for that we have to query: https://api.incident.io/v2/incidents.

In our daily update, we are only interested in ongoing incidents for that we need to filter status_category[one_of]=live. Details of this filtering mechanism are also described in their documentation.

It becomes interesting if you want to filter for custom_fields (which you have defined earlier on your own). That can be for example the affected team, or other details you add to your incidents. Be aware that you have to find the corresponding IDs for the custom_field and also the potential options.

To find these you can either query the https://api.incident.io/v2/custom_fields endpoint or run a query against the incidents endpoint, as the response contains all necessary information.

Example

After you find all the necessary filtering (or just if you want to experiment with something) you can use the following script to try your query.

#!/bin/bash
#
# Script to query incident.io API
set -euo pipefail


if [ -z $1 ];
then
  echo "Must provide an api token to query incident.io api"
fi

token=$1

incidents=$(curl --verbose --get https://api.incident.io/v2/incidents \
  -H "Accept: application/json" \
  -H "Authorization: Bearer $token" \
  --data 'custom_field[<CUSTOM_FIELD_ID>][one_of]=<CUSTOM_FIELD_OPTION_ID>&status_category[one_of]=live'
)

# Custom fields need to be addressed with IDs

count=$(echo $incidents | jq '.incidents | length')

echo "$count incidents"
echo $incidents | jq '.incidents[].name'

Example usage

$ ./incidentsStats.sh $token 
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  459k    0  459k    0     0  1054k      0 --:--:-- --:--:-- --:--:-- 1055k
10 incidents
"support-123"
"support-2124"
"support-20124"
"123124"
"SUPPORT-1232"
"Some other incident"
"test incident"
"SUPPORT-2012"
"support-2014212"
"SUPPORT-112"

With that script running we have everything ready and can get things automated.

Automating with Camunda

You can either get a trial account here, or host Camunda on your own, for example with the provided Self-managed version.

For simplicity reasons, I will skip the details here, and we expect the usage of the Camunda SaaS offering. Furthermore, will concentrate on the modeling details mostly (using Web-Modeler).

Follow these instructions here if you are unsure how to model your first diagram.

Adding Incident.io API key as Connector secret

When querying the incident.io API we need an API key, as described above. To make this available to our process instances and connectors we have to create a secret in our Camunda cluster.

For more on how to create a secret for your Camunda cluster, take a look at this guide.

In the end, it should be similar to the below:

Query incident statistics via REST Connector

After we have created our Camunda cluster, added our Connector secret, and started modeling we can add a REST Connector. Details about this can be found in the documentation here.

In the properties panel of the REST Connector, we have to specify all important details, similar to what we used in our script above.

One important part we need to add as well is the result expression which would look like this:

{
   incidentIoResponse: response.body
}

This maps the response body to our variable incidentIoResponse. With that, we are already ready to query the details of our incidents. You can either test this by creating a process instance and verifying the results or you just continue with the next step.

Extracting incident details

After we get all the incident details from incident.io we need to extract the important details. We can do this by defining a script task in our process model and implementing it with FEEL expressions.

Depending on what you are interested in you want to extract different details. For all the potential properties of incidents, you can take a look at the incident.io API documentation here.

In our example, we are interested in:

• Incident name
• Incident Severity
• Incident permalink, which points to the incident.io page
• The related Slack details (channel name and ID)
• The incident command (with name and Slack ID)
• Incident count

All of this can be extracted with the following FEEL expression:

{
    incidents:
      for incident in incidentIoResponse.incidents 
      return { name: incident.name,
               severity: incident.severity.name,
               permalink: incident.permalink,
               slack_channel_id: incident.slack_channel_id, 
               slack_channel_name: incident.slack_channel_name,              
               ic_name: incident.incident_role_assignments[item.role.shortform = "commander"].assignee.name[1],                 
               ic_slack_id: incident.incident_role_assignments[item.role.shortform = "commander"].assignee.slack_user_id[1]
             }
    ,
    incidents_count: count(incidentIoResponse.incidents)
}

With the FEEL for loop, we are iterating over the incidents, and creating for each incident a new context (object).

The FEEL list filter allows us to find the incident commanders and their respective names and Slack IDs.

Sending statistics via Slack Connector

Camunda supports several Connectors out-of-the-box, not only the REST Connector but also a Slack Connector. That Slack Connector we use in our example to send our statistics to a respective channel.

Of course also here we need an API key to access the Slack API, and you can follow this guide to create a Slack OAuth token.

Similar to the REST Connector, we need to add the Slack OAuth Token to our Connector Secrets. Follow this documentation if you need to know how to create/add them to your cluster.

After adding the secret we can start with modeling the Slack Connector.

We have to specify some details, like which channel or user should get the update. Furthermore, we have to specify what the message should look like.

For the Slack message, we can use again a FEEL expression.

":incident-heart: This is your daily incident update :incident-io:\n\n"
+ "We have currently *" +string(incidents_stats.incidents_count) + " ongoing Incidents*\n\n\n"
+
string join(
  for incident in sort(incidents_stats.incidents, function(x,y) x.severity < y.severity)
  return incident.severity + " - <" + incident.permalink + "|" + incident.name + ">" + " IC: <@" + incident.ic_slack_id + ">"
, "\n")

Formatting the Slack message has to follow some guidelines, which we can find in the Slack documentation here.

As the first part of the message, we want to post some header (with some nice Emoji—this of course depends on your Slack workspace whether this is available or not).

As the message field expects a string we have to concatenate everything to one string. We have to iterate over the incidents and join them via the string join function. This function allows us to specify a delimiter, which is in our case a newline.

To sort our incident list by severity we can use the FEEL sort function.

We can now experiment with our model and it should send a message already to a specified channel or DM, when we create a process instance for the definition.

Running it every working day

As the last step, we want to execute/run it every working day at the same time. In our example, we want to do it always before lunch (around 12 o’clock CET). To achieve this we model a timer start event with a cycle expression. Details about this can be found in the documentation here.

The example expression we would use is 0 0 11 * * MON-FRI. We are referring here to 11 as we specify here the time in UTC.

Be aware that tools like crontab-guru don’t parse this expression correctly as they don’t expect the seconds (at the beginning). Here the expression would be 0 11 * * MON-FRI.

Daily incident statistics with Camunda

After modeling all our logic (wiring everything together) we can deploy this to our previously created Camunda cluster, and as soon as the right time is reached we will see a Slack message like this:

As you can see there is not much magic behind it, it is quite “easy” to generate a daily report from an external source, like incident.io.

You don’t need to scrape the statistics manually anymore and put them into a good format to share them with others. We were able to completely automate this.

That is the power of Camunda: “Automate Any Process, Anywhere.”

P.S.: The possibilities for further things are endless, for example, auto-assigning an engineer to an incident, based on current ongoing incidents (related to statistics and load).

P.P.S.: If you like this post please let us know on the forum, where you can leave a comment. I’m open to any other feedback as well.

Editor’s note: This post first appeared on Medium. We have republished it here with slight edits for clarity.

The post Incident.io Daily Statistics with Camunda appeared first on Camunda.

Many within the Camunda Community actively contribute in ways that demonstrate their commitment and generosity, sharing their expertise and shaping our community. Our community members write code that refines the product,  organize meet-ups where local community members get together to learn,  answer questions on our forum, and present to local and international audiences.

The Camunda Champion Program launched in 2021 as a way to formalize Camunda’s acknowledgement and support for those who truly stand out. The intention was clear from the get-go: to recognize, empower, and reward our most dedicated contributors. By doing so, we aim to improve the experience of every community member and make all interactions more meaningful.

Since its launch, we’ve had the privilege to onboard 29 exceptional folks as Camunda Champions. This November, we will onboard the fifth cohort, and there’s still an opportunity for you to become a Camunda Champion, too. Read on for details about what it means to be a Camunda Champion, the benefits of being a Camunda Champion, and where you can apply.

What it means to be a Camunda Champion  

A Camunda Champion is someone who embodies our Community Values. These are the pillars on which our community stands – individuals who are always ready to collaborate, share their knowledge, uplift others, and are passionate about Camunda and BPMN. Their contributions range from addressing questions and to public speaking, to content creation and actively participating across multiple platforms. The Champion program aims to recognize the dedication of these champions, and support them in the area they feel most passionate about.

Embracing the role of a Camunda Champion

Why consider becoming a Camunda Champion? Beyond joining a thriving global community of Camunda Champions, there are multiple benefits waiting for you:

• Grow your network. Create connections with Camunda experts and fellow Champions from around the world.
• Exclusive badges. Showcase your Champion status through special badges across different platforms.
• Insider insights. Stay informed about the latest developments within Camunda, receiving updates firsthand.
• Special access to events. An invitation to the annual Champion Summit, and free tickets to CamundaCon.
• Exclusive swag!

Apply by October 6, 2023

Stepping into the role of a Camunda Champion means joining a community built on knowledge sharing, collaboration, and connection. We are accepting applications now, and we want to hear from you. Apply by October 6, 2023 to be considered for our fifth cohort of Champions in November. The Camunda Champion Program team will review all applications and get back to you via email if you’re accepted.

If you have any questions regarding the program, feel free to contact us via champions@camunda.com.

The post Are you a Camunda Champion? appeared first on Camunda.

The Camunda Carbon Reductor [CCR] can contribute to reduce the environmental impact of digitized business processes in Camunda, by time shifting the execution of energy intensive activities. Executing activities of a business process at times at which energy sources with low CO2 emissions (e.g. solar energy) is available, is called carbon-aware process execution.

In traditional BPM, the main performance dimensions for which processes are optimized for are usually time, cost and quality. With this work, we aim to raise awareness that the dimension of ecology should also be seen as an equal as illustrated in Figure 1.

Camunda Carbon Reductor

The Camunda Carbon Reductor is a Camunda Connector consisting of an element template that is modelled in front of energy-intensive activities and time shifts their execution to time windows when renewable energy sources are available.

Time shifting energy-intensive activities

Energy-intensive activities may not be time shifted arbitrarily. Business processes are subject to constraints, namely, service level agreements (SLA). The most common SLA is the maximum execution time, which specifies a time window for a certain part of a business process, which may not be exceeded when executing this part of the business process.

Assume the business processes, given by Figure 2, consist of a couple of activities at the beginning and an energy-intensive service activity at the end. In front of the energy-intensive activity, the Camunda Carbon Reductor is modelled. For the business process, a milestone and a maximum execution time from this milestone to the end of the business process is specified. Then, it is possible to derive the time since the milestone to the Camunda Carbon Reductor and the time of the remaining activities from the Camunda Carbon Reductor to the end of the business process. Based on these time windows the time window for time shift can be calculated. This time window for time shift is the time window in which the time window with the fewest carbon emissions can be determined.

The following equation describes how to determine the time window for time shift:

tshift = tMET − (tmilestone  + tremaining)

• tshift is the time window for time shift, i.e. the maximum time the subsequent activity may be postponed.
• tMET is the maximum execution time of the business process (i.e. the SLA)
• tmilestone is the duration since milestone
• tremaining is the estimated duration of the remaining activities

For better illustration: To determine the purple time window for time shift in Figure 2 the green arrows need to be subtracted from the red arrow.

Connector implementation

When implementing the approach for the Camunda Carbon Reductor, two challenges need to be faced. First, a forecast of the carbon-intensity of the energy of the region the energy-intensive activity is running in is needed. And second, the Camunda Carbon Reductor shall be a reusable model element that is easy to integrate into process models and effortlessly usable.

For the forecast of the carbon-intensity of energy, there are a few web APIs that might be used. Currently, the Camunda Carbon Reductor supports two of them while being open for the support of further APIs. The supported APIs are CarbonAwareWebAPI of the Green Software Foundation [CASDK] and the CarbonAwareComputing API [CAC].

In order to account for the second challenge, the Camunda Carbon Reductor is implemented as Connector-like System as it is called in the Camunda Docs [CD]. A pure Connector runs in a Connector Environment which takes care of Camunda 8 specific API calls, which is why a Connector does not have access to low-level APIs (at the moment, see [PR]). However, to time shift a business process (i.e. suspend and resume a business process) access to low-level API is necessary. Therefore, the combination of an element template of a Connector and a Job Worker is the perfect fit for this use case. An element template is a reusable building block that integrates easily and effortlessly into process models. The developer who is modelling the process just needs to fill in the configuration and the Camunda Carbon Reductor is running. The following configuration is required:

• The location where the energy-intensive activity is executed in. This information is used to get a forecast of the carbon-intensity of energy.
• An estimated duration of the remaining activities.
• A milestone, which is a timestamp. It is (any) starting point for the SLA based duration calculation; per default, the moment the connector starts as it is shown in Figure 3 with = now().
• The maximum execution time a process instance is allowed to take from the milestone to finish to be SLA compliant.

Figure 3 shows a service task that is configured to be the Camunda Carbon Reductor. It can be seen that the aforementioned configuration fields need to be filled in.

Once a process instance arrives at the Camunda Carbon Reductor the corresponding Job Worker picks up the Job. The following code extract shows schematically how the Job Worker works.

@Component 
public class CarbonReductorWorker { 
    ... 
    @JobWorker(type = "de.envite.greenbpm.carbonreductorconnector.carbonreductortask:1") 
    public void execute(ActivatedJob job) throws Exception { 
        if (!alreadyTimeshifted(job)) { 
            Forecast forecast = getForcast(job); 
            Delay delay = calculateDelay(forecast); 
            writeToProcessInstance(job, forecast, delay); 
            if (delay){ 
	     failJob(job, delay); 
            } else { 
                completeJob(job); 
            } 
        } else { 
            completeJob(job); 
        } 
    } 
    ... 
}   

The Job Worker consists of a method that is annotated with @JobWorker. In the annotation, zeebe:taskDefinition:type is specified so that the Job Worker knows what Jobs to fetch. When the Job Worker gets executed, first, it is checked whether this business process instance was already time shifted. If it was, the job is completed immediately. Otherwise, a forecast of the carbon-intensity is fetched using one of the available APIs. Then, a time window is determined when energy with little carbon emissions is available taking the configuration and the forecast into account. The results are written to the process instance for reporting purposes.

If renewable energy sources are available right away, no delay is calculated. Otherwise, the job is failed with the calculated delay. After the delay, when renewable energy sources are available, the method of the Job Worker is executed again. As this business process has already been time shifted, the job will not be time shifted again, but instead it gets completed immediately.

Evaluation of time shifted activities

The Camunda Carbon Reductor generates output data like the delay of the process instance, the original carbon emissions per kwh (i.e. the carbon emissions that would have been emitted when the process had been executed immediately) and the actual carbon emissions that have been emitted during the execution of the energy-intensive activity.

Using this information, a dashboard like the one displayed in Figure 4 can be created in Camunda Optimize. The dashboard shows, inter alia, the saved carbon emissions per kWh in percentage and in absolute numbers.

Conclusion

Climate change is a challenge for society as a whole. The IT sector also needs to contribute to overcome it by reducing carbon emissions. To this aim, the Camunda Carbon Reductor supports companies with an easy-to-apply approach in making process application carbon-aware, i.e. time windows can be chosen for running the energy-intensive activities in which energy from sustainable sources is available. The Camunda Carbon Reductor is publicly available [CCR] and can directly be used both for Camunda Platform 7 and 8.

It is important that CO2 emissions are not the only KPI in regard to the environmental impact (e.g. water consumption, waste, etc.). However, reducing the carbon footprint is uniformly viewed as important in the context of Green BPM, which makes us confident that the Camunda Carbon Reductor is a positive step towards improving the environmental impact of business processes.

Sources

[CAC] Carbon Aware Computing.

[CASDK] Carbon Aware SDK.

[CCR] Camunda Carbon Reductor.

[CD] Camunda Docs.

[Fr21] Freitag, C. et al.: The real climate and transformative impact of ICT: A critique of estimates, trends, and regulations. Patterns (New York, N.Y.) 9/2, S. 100340, 2021.

[MFS20] Matemilola, S.; Fadeyi, O.; Sijuade, T.: Paris Agreement. In (Idowu, S. et al. Hrsg.): Encyclopedia of Sustainable Management. Springer International Publishing, Cham, S. 1–5, 2020.

[PR] Pull Request.

The post The Camunda 8 Connector for Carbon-Aware Process Execution appeared first on Camunda.

I recently faced this predicament on my own team here at Camunda. I needed to not only help my team decide which projects to prioritize but also help our coworkers understand how (and why) we respond to new requests.

While I could have written and published an internal strategy doc that listed our reasoning, information overload sets in quickly, and I’d rather not ask Camunda employees (Camundi) to read yet another page in our internal wiki every time they have a request. Instead, I turned to DMN and Camunda Platform 8’s new features to build a process model with an integrated form. While it’s not yet perfect, it’s already benefiting my team! How did I get here?

Step 1: Identify the criteria for prioritization

I chose to start with a DMN table, which would be the foundation of the model. Before I could build this table, however, I had to identify the criteria we would use to prioritize the DevRel team’s work. Many DevRel teams prioritize tasks based on impact on the developer community, alignment with the company’s goals, or level of effort.

In our case, the assumption is that the work being submitted to this form is independent of the projects we’ve already taken on as a team for the quarter. This allowed me to keep our criteria simple: alignment with the team goals and the urgency of the task.

Step 2: Create a decision table

With this criteria defined, it’s time to create the DMN table. These tables map the input values (timing and goals) to the output value (priority) based on a set of rules. A nice perk of building the prioritization rules into this table is that as our criteria change over time, I can update the table and the new rules will take effect immediately. Because the table is versioned, I can revert to a previous iteration at any time if necessary.

The first thing I had to define was the input data which the decision table will use to process requests. In my case, I used the following:

• Input: 2023 Goals
• Expression: goals
• Type: string
• Predefined Values: “healthy C8 community” “successful C8 community” “C8 community onboarding” “other”

Note: While filling in predefined values is optional, I found it helpful when populating the decision rules.

I set the second input (Timing) with fairly general ranges: this week, month, or quarter, and next week, month, or quarter, as well as no specific timeframe.

I kept the output value very straightforward: yes or no, with a possible exception that could be raised to me if necessary. Lastly, I’ve used the hit policy “first” in order to evaluate the rules from top to bottom and stop when a match is found.

The end result is a decision matrix that allows us to easily filter company requests that meet these specific goals and aren’t urgent (e.g. can be completed this month, next month, or next quarter). For anything that falls into the “this week” or “next week” timing, it’s likely going to be a no, unless it’s a very high-priority task that also aligns with our goals; in this case, the request is  flagged as a possible exception in need of review. The outcome is a fairly straightforward model that outlines when we can prioritize requests and when we’ll need to either reconsider them at a later time or simply say no.

Step 3: Create a form to populate the decision table

I repurposed a simple Google form we’ve used for years, using the Camunda Form Builder so I could integrate it with my decision table.

Once the form was created, I made sure the key for the questions around the goals and the timing matched up with the expression in my DMN table.

Step 4: Integrate the form and decision table into a process model

An idea is submitted & evaluated

The next step was to create a process model using Web Modeler. This model represents the process of prioritizing tasks, including collecting the criteria via the form, applying the decision table to determine the priority of the task, and communicating the decision to the appropriate Camundi. Let’s take a look at the current model:

The first section of the model includes the completion of the form, the DMN table which helps us prioritize the task, and an automated Slack message (using our Slack Connector) that notifies the DevRel team a new request has been submitted.

I connected the form to the model by copying the JSON from the code editor in the form builder and pasting it into the properties panel of the user task “Complete DevRel Request Form.”

I then added a Business Rule task and connected it to the DMN table I created by associating the following fields:

• I copied the ID for the Decision from the Decision Requirements Diagram (DRD) view and pasted it in the Called Decision: Decision ID field for the Business Rule task.
• In the Result Variable field, I pasted the output name from my DMN table (abilityToHelp).

It was important to me to minimize blockers (including myself) for these requests and better enable my team to take action, so I wanted to make sure the entire team would be alerted whenever someone filled out the form. Using the Slack Connector, I set up an alert to go directly to our team channel.

The next iteration will include a link to the specific request, in addition to the results of the DMN table so it will be easy to see at a glance whether additional insight is needed.

The decision is validated

The next step in our process is to validate the decisions.

There are two decision gateways here:

• Do you need help making a decision? The DMN table will automatically determine this step, moving requests directly to Look at automated decision if the answer is a clear yes or no. If the answer from the DMN table is abilityToHelp = “possible exception,” it will be flagged and go the Escalate to Manager route.
• Do you agree with the decision? When I was first designing this process, our Community Manager Maria Alcantara made the excellent observation that there may be times when users disagree with the automated decision. If this is the case, requests should be escalated to the manager.

Right now, looking at the automated decision as well as making the decision are user tasks that have to be managed within Tasklist. If users need to escalate to manager in either case, they can type in a variable agree = false for the first question and doThing = false for the second. In the next iteration of this model, I’d like to have a Slack integration that allows us to say yes or no to both of these questions in order to move forward seamlessly.

The end result of all these decisions is that we have a clear path forward: we’re either going to tackle this project or not.

The outcome is communicated

Feedback loops are important to us at Camunda, so I wanted to make sure no matter what the decision was, there was a follow-up with the person who requested help.

Rather than listing every Camundi in the Requester DMN table, I chose to include variants of our team members’ names: first name and first + last name, in lowercase as well as camelcase, since DMN tables are case sensitive. The output is groupCamundi with either the value of devrelTeam or colleague.

These final tasks are all user tasks, but again, there are opportunities to include automation here:

• Create a Trello card in our task board based on the form.
• Send a refusal message to the individual who submitted the request.
• Notify the requester when the task is moved to the done column in our task board.

We could likely even turn the form into a Slack bot that then pings the appropriate team member. In short, there are all sorts of possible iterations here, which we’ll definitely explore as we roll this out company-wide.

Step 5: Be more productive

I have high hopes that this process model will continue to help us prioritize our work more effectively, ensuring we focus our efforts on the tasks that will have the greatest impact on our community members as well as Camunda company goals. Additionally, by streamlining the prioritization process, we are able to complete tasks more quickly and efficiently, improving our overall productivity.

While this prioritization of tasks might seem like a relatively small and perhaps insignificant issue compared to the other items on our plate, this DMN table, form, and process model will serve as the foundation for future team endeavors and resource-planning. Here’s to solving “mole hills” before they turn into mountains!

What have you created with Camunda lately? Let us know over in our forum. I’d love to hear how process models have made your day-to-day work easier!

The post Prioritizing Our DevRel Backlog with Form Builder, DMN, and a Process Model appeared first on Camunda.