You are here

Can open-source Camunda disrupt the BPMS market?

public://pictures/jasonbloomberg-tight-300x412.jpg
Jason Bloomberg, President, Intellyx

When I heard what Camunda, the scrappy open-source vendor of business process management software (BPMS), was up to, I had to head to its hometown of Berlin to see for myself.

On the surface, Camunda appears to be bucking all the major trends in today’s BPMS world. Instead of recasting its platform as low-code, Camunda unabashedly serves Java developers, requiring hands-on Java skills to use its platform effectively.

Camunda also supports and leverages the now-aging Business Process Model and Notation (BPMN) standard—a standard that I have recently taken issue with for being overly verbose and waterfall-centric.

At its annual CamundaCon conference last week, several hundred customers and other fans were all too happy to sing Camunda’s praises, so to be sure, the company is on to something. Here’s my analysis.

[ Learn how to transform your IT with AIOps in TechBeacon's guide. Plus: Download the analyst paper on how AI is changing the role of IT. ]

Taking on the monoliths

Camunda’s market share may be relatively small, but that doesn’t stop it from fighting a triple David-vs.-Goliath battle against low-code BPMN leaders Appian, Pega, and IBM BPM.

Camunda’s angle: These three established players are offering monolithic platforms to their enterprise customers—monoliths that require a cross-departmental commitment from such customers, while delivering a product that will have scalability issues in the end.

Leading BPM thought leader Sandy Kemsley keynoted the event. In her talk, she agreed with Camunda’s position, taking aim at Gartner’s "intelligent BPMS" (iBPMS) categorization as including limited-scalability monoliths.

Instead, customers can deploy Camunda at the departmental level if they wish, in order to support situations where stakeholder requirements may vary from department to department.

Derek Vandivere, enterprise/platform architect for financial services firm ING, found that Camunda’s flexibility and scalability suited his company’s needs. ING had deployed Pega, one of the monoliths, at the regional level—but it wanted to go global with it. The only way it could accomplish this feat was to install multiple copies of Pega, leading to unwieldy complexity and insufficient governance.

To address this challenge, ING is deploying Camunda tactically in specific countries, allowing developers in those locations to craft processes that meet local needs—without having to rip out Pega entirely.

Dennis Kotov, solution architect at Tinkoff Bank in Russia, told the story of how his organization is going further than ING. Tinkoff is replacing its monolithic BPM platform (which he wouldn’t name) by reworking it to call Camunda processes, eventually shifting all functionality over to the new platform.

[ Enterprise Service Management brings innovation to the enterprise. Learn more in TechBeacon's new ESM guide. Plus: Get the 2019 Forrester Wave for ESM. ]

Low-code by any name

Jakob Freund, Camunda's CEO and co-founder, delighted his audience with his takedown of the low-code competition. “With low-code BPMS you can create programs without programming, so you don't need programmers. What could possibly go wrong?” he quipped. “If low-code BPMS made sense, Amazon would be running their entire platform on low-code, but they’re not.”

Ironically, however, when Daniel Meyer, Camunda’s CTO and other co-founder, got on stage and went through a demo of the Camunda Modeler, there was no question the product was actually low-code—and a slick implementation to boot.

In fact, the Modeler doesn’t only provide a low-code visual approach to building workflows (which all the BPMS products do today), but it actually incorporated BPMN notation directly into the visual editor, empowering modelers to build BPMN-compliant models with only a passing knowledge of the standard.

Where Camunda is unabashedly high-code is how it expects developers to connect the models to the functionality they want to automate. In fact, Camunda’s favored approach for implementing such functionality is via Spring Boot, a lightweight subset of the popular Spring Java framework that simplifies the process of creating stand-alone, production-grade Java applications.

This hands-on Java capability was Camunda’s original raison d’être, and it was clearly a primary motivation for choosing Camunda among the crowd at CamundaCon. However, compared with BonitaSoft, another leading open-source BPMS on the market, Camunda generally ranks lower on the ease of building such supporting applications on rating sites such as IT Central Station and TrustRadius.

[ Partner resource: Subscribe to Intellix's Cortex and Brain Candy Newsletters ]

Reaching for the cloud-native brass ring

Camunda may be able to chisel away a bit at the dominance of the Appians, IBMs, and Pegas of the world, but simply bringing a Java-friendly, open-source BPMS to market is unlikely to cause a major disruption in how enterprises think about automating business processes.

Fortunately for Camunda, it has another trick up its sleeve: the Zeebe workflow engine for microservices orchestration. Zeebe is open source and is at the heart of Camunda’s new Camunda Cloud BPMS-as-a-service offering.

With Zeebe, Camunda has essentially reinvented workflow following entirely cloud-native principles. Zeebe runs as microservices on Kubernetes, itself orchestrating and choreographing microservices into workflows that leverage Kubernetes’ massive horizontal scalability.

Zeebe brings two important capabilities to the BPMS game. First, it can support essentially limitless numbers of concurrent process instances, essential for supporting high-volume consumer-oriented processes, for example. (If Amazon had Zeebe back in the day, perhaps it would have built its e-commerce platform on it.)

Second, Zeebe gives developers a cloud-native approach for dealing with the "pinball machine" problem that event-driven microservices architectures exhibit. This problem describes how messages tend to bounce around from microservice to microservice, leading to unpredictable, difficult to manage effects.

Instead, Zeebe brings a balance of both microservices choreography and orchestration to bear. There are problems when each of these approaches is implemented separately: choreography of event-driven microservices leads to the pinball machine problem, thus obscuring the process in question. Orchestration alone leads to monolithic, and thus non-scalable, behavior.

Zeebe thus brings a general-purpose, cloud-native coordination layer to microservices applications, regardless of whether the context for such applications is the automation of a business process or some other kind of workflow. With Zeebe, business processes are but one type of automation scenario that the engine can handle in a cloud-native manner.

Will Zeebe give Camunda a competitive edge?

Kubernetes orchestrates containers that might contain all manner of application code, so there’s no reason why the iBPMS vendors can’t put their platforms in such containers as well. Pega, for example, provides detailed guidance for how to deploy its platform on Kubernetes, and the other vendors no doubt have Kubernetes-based offerings in the works.

But make no mistake: There’s a substantial difference between running code on Kubernetes and rearchitecting an application to be cloud-native—especially when that application itself consists of platform infrastructure.

Zeebe is not simply the Camunda platform running on Kubernetes. Zeebe is a new kind of BPMS platform the Camunda folks built from the ground up to be cloud-native.

Zeebe promises to empower developers to take a model-driven approach to workflow for cloud-native applications, thus supporting a wide variety of automation scenarios across both the business and IT landscapes.

Big vendors with monolithic platforms have a vested interest in confusing customers on this point. Don’t be one of them.

The incumbent iBPMS players should nevertheless take heart. Zeebe is still immature. And because it’s open source, you’re welcome to leverage it yourself—which might be your best course of action once customers figure out that sticking old code into containers does not make it cloud-native.

Appian, BonitaSoft, and IBM are Intellyx customers. None of the other vendors mentioned in this article are Intellyx customers. Camunda covered my expenses at CamundaCon, a standard industry practice.

[ Learn how robotic process automation (RPA) can pay off—if you first tackle underlying problems. See TechBeacon's guide. Plus: Get the white paper on enterprise requirements. ]