Business processes
that move work
forward
What is Jmix BPM
Jmix BPM is a business process management platform for building and automating enterprise workflows in Java and Spring Boot applications. It connects tasks, roles, AI agents, application services and external systems into unified end-to-end business processes.
Execution logic, data and user interfaces are built on the platform’s metamodels, allowing process changes to remain consistent across the application.
Jmix BPM brings analysts, architects and developers into the same delivery loop, making collaboration between business process design and implementation faster and more transparent.


Key Benefits
of Jmix BPM
A process layer that fits naturally into your enterprise stack
Jmix BPM gives you a proven architecture for business applications without locking you into a specific domain or industry.
Built entirely on open-source technologies, the platform integrates cleanly into enterprise infrastructure and helps avoid vendor lock-in.

They can move seamlessly between BPMN process models and Java code, and generate user task forms from the application data model with a built-in wizard.

public void startOrderProcess(String json) {
OrderRecord orderRecord = deserialize(json);
if (orderRecord == null) return;
Integer maxDelayTimer = appSettings.load(OrderProcessingSettings.class).getMaxDelayTimer();
int timerNew = random.nextInt(1, maxDelayTimer);
int timerVerified = random.nextInt(1, maxDelayTimer);
String timerNewDuration = Iso8601Converter.convertSecondsToDuration(timerNew);
String timerVerifiedDuration = Iso8601Converter.convertSecondsToDuration(timerVerified);
String businessKey = generateBusinessKey();
Item item = findItemByName(orderRecord.item());
Map<String, Object> map = new HashMap<>();
map.put("orderNumber", businessKey);
map.put("customer", orderRecord.customer());
map.put("address", orderRecord.address());
map.put("quantity", orderRecord.quantity());
map.put("item", item);
map.put("timerNew", timerNewDuration);
map.put("timerVerified", timerVerifiedDuration);
systemAuthenticator.begin("admin");
try {
runtimeService.startProcessInstanceByMessage(START_MESSAGE_NAME,
businessKey,
map);
uiEventPublisher.publishEvent(new IncomingOrderEvent(this, json));
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
systemAuthenticator.end();
}
}
private String generateBusinessKey() {
Integer number = numeratorService.getNext("order");
String formattedNumber = String.format("%05d", number);
return "ORD-" + formattedNumber;
}
public OrderRecord deserialize(String json) {
ObjectMapper objectMapper = new ObjectMapper();
try {
return objectMapper.readValue(json, OrderRecord.class);
} catch (JsonProcessingException e) {
log.error("Bad message: {}", json);
return null;
}
}
private Item findItemByName(String name) {
systemAuthenticator.begin("admin");
try {
return dataManager.load(Item.class)
.query("select e from ord_Item e where e.name = :name")
.parameter("name", name)
.one();
} catch (Exception ignored) {
} finally {
systemAuthenticator.end();
}
return null;
}
Jmix BPM gives analysts a live environment for modeling flows, roles and rules, where a model can become a working process right away, without long handoff cycles between business and development teams.
Analysts and developers work within the same delivery loop: changes in the model are automatically synchronized with code and data, shortening the path from idea to production.


Jmix BPM capabilities
Model-driven and process-driven design in one environment
The platform brings data modeling and process design into one place.
Developers can move easily between the data model and process logic using a single toolset.

directly as regular code
Low-code plus professional development: speed without trade-offs
Jmix BPM combines low-code tools for building entities, screens, roles, and process models with full professional development capabilities on a single platform.
Ready-made components and core infrastructure accelerate engineering work while keeping the architecture transparent and the solution fully under your control.

tools required
Open architecture and integrations: built for compatibility and scale
BPM is built into the overall architecture of a Jmix application: processes use the same services, data layer, and APIs as the rest of the platform.
That gives you predictable integrations and lets process-centric applications scale the same way as any other Jmix module.
Real-time visibility and control over running processes
The built-in console shows the state of processes in real time and lets operators manage execution: restart flows, adjust steps, and investigate incidents without stopping the system.
When needed, process models can be updated in a running application, making it easier to adapt logic quickly and reduce maintenance costs.

A unified workspace for process participants
A ready-to-use task management workspace is included with Jmix BPM and can be adapted to your business processes.
Tasks are displayed with the right business context, priorities, deadlines and forms generated from the application data model.




























