Step-by-Step Guide: Integrate Camunda Workflow Engine with Spring Boot

Camunda Overview

Camunda is a flexible workflow and process‑automation framework. Its core is a native BPMN 2.0 engine that runs inside the Java Virtual Machine and can be embedded in any Java application or runtime container.

Official site: https://www.camunda.org/

Getting‑started docs: https://docs.camunda.org/get-started/

Integrate Camunda

Below is a step‑by‑step integration guide.

Preparation

Use Camunda Automation Platform 7 Initializr ( https://start.camunda.com/ ) to generate a Spring Boot project.

Configure the generated project (package name, admin credentials) and click Generate Project to download the archive.

Extract the archive and open it with IntelliJ IDEA.

Edit pom.xml to add Camunda dependencies:

<dependency>
    <groupId>org.camunda.connect</groupId>
    <artifactId>camunda-connect-core</artifactId>
</dependency>

<dependency>
    <groupId>org.camunda.bpm</groupId>
    <artifactId>camunda-engine-plugin-connect</artifactId>
</dependency>

Open application.yaml and adjust configuration, e.g.:

spring.datasource.url: jdbc:h2:file:./camunda-h2-database

camunda.bpm.admin-user:
  id: transduck
  password: 111111

spring.datasource.url

defines the database used by the workflow engine (can be changed for production). camunda.bpm.admin-user configures the admin account.

Create a Simple Workflow

We will build a process that collects two inputs (name and message) and returns a combined output.

Create a data‑model class:

public class Model {
    private String message;
    private String name;
    public Model() {}
    public String getMessage() { return message; }
    public void setMessage(String message) { this.message = message; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    @Override
    public String toString() { return "" + message + ", " + name; }
}

Create a REST controller to receive the inputs:

@RequestMapping("/")
@RestController
public class Controller {
    Logger logger = Logger.getLogger(this.getClass().getName());

    @PostMapping("/message")
    public Model createMessage(@RequestBody Model model) {
        logger.info("-------Message Creator Initialized-------");
        Model m = new Model();
        m.setMessage(model.getMessage());
        m.setName(model.getName());
        logger.info("Message created --> " + m.toString());
        return m;
    }
}

Open resources/process.bpmn in Camunda Modeler and design the diagram:

The diagram contains a User Task for input, a Service Task that calls the REST endpoint, and an End Event.

Configure the User Task form with two fields: name and message.

Add a Service Task and set its connector to call the /message HTTP endpoint.

Connect the tasks: User Task → Service Task → End Event.

Run and Test

Start the Spring Boot application in debug mode. Open a browser at http://localhost:8080/ and log in with the admin credentials defined in application.yaml.

Navigate to the Tasklist, add a simple filter, and start the process. Claim the created user task, fill in the form fields, and complete it. When the Service Task executes, the console will display the combined message, confirming that the workflow ran successfully.

Conclusion

This article demonstrated a complete end‑to‑end setup of a simple Camunda workflow inside a Spring Boot project, covering project generation, dependency configuration, data‑model and controller implementation, BPMN diagram design, and runtime testing.