Business Process Management · Engineering case study
Design the process.
Connect the systems.
Keep work moving.
Full-stack delivery. Backend depth.
I extended React configuration interfaces and .NET business logic in a team-built BPM platform, turning form data and business rules into approval workflows.
My focus: API integrations, Kafka workers, and handling external results before a workflow moves forward.
Original interface design · Demo data. Identifying values are replaced in edited images. These are separate example workflows, not one continuous production record.

My contribution
From a business rule
to working software.
I added and refined features across the web client and backend—not the entire platform.
| Area | Web / React | Backend / .NET |
|---|---|---|
| Configurable forms | Web / ReactConditional fields, table interactions, remote data | Backend / .NETDependent-field evaluation, data mapping, row operations |
| Workflow execution | Web / ReactSLA/action configuration, processing states | Backend / .NETTransition checks, approver handling, deadlines |
| External integrations | Web / ReactAPI configuration, result/error visibility | Backend / .NETRequest mapping, workers, external-result processing |
| Operational reliability | Web / ReactAutosave coordination, cache behavior | Backend / .NETStreaming export, integration logging, worker processing |
02 / Forms + workflow
Business rules become
executable workflows.
A request connects configurable fields with permissions, approval conditions, and deadlines. I extended both the configuration experience and the existing execution engine.


Forms
- Rules and dependencies
- I worked on conditional value rules that update related controls when inputs change.
- Table consistency
- I added row-copy APIs and refined handling of row identifiers, values, and dependent fields.
- Context-aware visibility
- I extended permission and section-visibility behavior based on role and workflow participation.
Workflow
- Execution conditions
- I refined next-step handling and error reporting for rollback and invalid transitions.
- Configurable deadlines
- I added SLA options for hours, days, and fixed weekly or monthly dates.
- Operational state
- I worked on processing/error visibility and retry actions in configuration and request-detail views.
03 / External integrations
Sending a request isn’t
always the end of the work.
The platform supports external-system steps. I added a queued multi-request path and support for waiting on an external business result before continuing.

Kafka carries the work; the worker calls the API.
I added the producer and worker for templated multi-request actions. Form data is saved before queueing; the worker reloads the form and action, maps payloads from fields and table rows, and sends HTTP requests.
Direct HTTP paths also exist. The result-update endpoint below applies results directly; it is separate from the Kafka callback path above.
Result-waiting mode · My implementation
An accepted request is not a completed business operation.
The workflow remains at the integration step until the result is validated; an HTTP response alone does not establish that the external business operation has finished.
Prepare request
Map form values into the API payload.
Keep explicit state
Wait for the external business result.
Validate and apply
Check the current action; map returned data.
Advance or recover
Continue on success; expose failure and recovery state.
Result handling & recovery
I added the result-update endpoint, state validation, and response mapping, and worked on configurable retry/error behavior.
External approval
I added support with checks for the active request, current step, external-approval configuration, and eligible approver.
04 / Backend depth
Shared state.
Clear service boundaries.
These features operate within existing concurrency and service mechanisms. My changes build on those boundaries.
Concurrency & state protection
The callback path uses a Redis-backed lock scoped to a form and action to coordinate competing updates.
Targeted caching
The platform caches generated request codes in Redis by form ID with a 30-minute sliding expiry; persisted history remains separate. Redis is not the source of truth.
I refined client-side remote-data cache guards and parameter handling, and bypassed shared caching for selected employee lookups.
BPM, HR & external APIs
Internal service routing supplies people and workflow data; configured HTTP APIs connect external systems.
I extended HR user retrieval into profile and selection interfaces and worked on integration mapping—not every downstream service.
Other engineering work
Large exports
I switched workbook generation to a streaming writer to reduce memory pressure.
Safer draft saving
I refined coordination around autosave, import, and submission.
Background processing
The platform uses Kafka and RabbitMQ for different processing paths.