The starting point.
Archival work was governed by a process, but operators still needed a practical way to manage the things moving through it: sessions, packages and changing workflow state.
The feature also had to live inside a larger enterprise platform. It could not become a separate product with its own rules. It needed a focused boundary that fitted the surrounding system.
What the design had to solve.
The useful boundary sat between process state and operator action:
- A session and its packages needed to stay understandable as the workflow advanced.
- Operator actions had to map cleanly to valid process transitions.
- Backend rules and frontend state could not drift into separate interpretations.
- The feature had to integrate with the host platform without spreading its logic across it.
The diagnosis.
Camunda could coordinate the process, but orchestration alone was not the operator experience. The missing layer was a coherent application boundary around the workflow.
I separated the concerns: the Spring service owns the application-facing rules and process integration; the React microfrontend presents the current state and the actions that are valid from it.
The resulting application slice.
The microfrontend gives operators a focused surface. The Spring service translates application actions into workflow operations, while Camunda coordinates the process that moves sessions and packages forward.
Decisions that mattered.
The design stays useful by keeping each responsibility in one place.
Put the workflow behind an application service
The React client talks to a focused Spring API rather than encoding process mechanics in the browser.
The service adds a boundary to maintain, but it prevents workflow details from leaking into every screen.
Make state visible before action
The interface centres the current session, its packages and the workflow state so an operator can see what is happening before choosing the next step.
The UI must represent unavailable and in-progress states, not only the happy path.
Keep the feature narrow
A microfrontend contains the archival experience while allowing it to fit inside the wider enterprise platform.
That independence depends on a disciplined integration contract with the host application.
Delivery and verification.
The feature can be checked across the same route an operator uses: create or open a session, inspect its packages, perform an allowed action and confirm that the workflow state returns coherently to the interface.
The important failure cases sit at the boundaries. The service needs to reject invalid transitions, the UI needs to show incomplete or pending state honestly, and the process integration needs to remain the source of workflow truth.
The qualitative result.
The resulting slice covers session handling, package processing and workflow control from the operator interface through to the Camunda process.
Operators get one place to understand the work and move it forward. The wider platform gets a contained feature instead of archival logic spread across unrelated screens and services.