BPMN workflows at Rust speed.
Project brief
Gave a Rust BPMN workflow engine an operator console for deployment, inspection, task action, and observability.
Hiring signal
Senior ownership across product framing, execution scope, and shipped interface quality.
Engineering read
Focus on constraints, architecture bets, external systems, and data-flow decisions.
Fluxion is an early-stage BPMN 2.0 workflow engine and HTTP service written in Rust, with an embedded workflow console for process deployment, graph inspection, task operations, metrics, and API review.
Backend and platform engineers need more than a raw workflow API. They need to see whether definitions are deployed, instances are running, tasks are blocked, messages can be correlated, and the service is healthy enough to operate.
I treated the console as an operations surface for a technical runtime: dashboard first, process deployment and graph inspection next, then task actions, message correlation, observability, settings, and a small BPMN modeler for validating workflow structure.
Project method
The core requirement was a workflow engine that could expose BPMN execution clearly enough for backend and platform engineers to deploy, start, inspect, and operate processes. The console needed to make persistence, task actions, process starts, health checks, metrics, authentication modes, tenant isolation, and event integrations visible without forcing users into raw API calls for every step.
Rust and Axum were chosen for a small, predictable HTTP runtime around BPMN parsing and execution. PostgreSQL handled durable definitions, instances, tasks, timers, and history, while Prometheus and OpenTelemetry made the operational surface first-class. The embedded HTML console kept the operator UI close to the service and simple to ship.
The console design system uses a dense dark operations palette, compact cards, status badges, route lists, and graph surfaces. That fit the product better than a marketing-style interface because the main user jobs are scanning runtime health, reviewing process state, and acting on workflow tasks.
The MVP was the full operator loop: check server health, deploy or run BPMN, start an instance, inspect graph and history, act on user tasks, review metrics, and understand available API endpoints. Advanced auth, tenant isolation, Kafka, NATS, and connector details could layer in after that loop was coherent.
The project progressed from the engine and persistence layer into an embedded console that made the runtime inspectable. Dashboard and observability views came first for confidence, then BPMN deployment, process graph rendering, task operations, message correlation, and a lightweight modeler rounded out the operator workflow.
Conclusion
A Rust service with an embedded single-page console that lets an evaluator move from service health to BPMN execution and runtime inspection without stitching together every endpoint by hand.
Proof list
Open channel
Architecture, AI workflows, design systems, and interfaces that need to hold up after launch.