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.

C# / .NETReactTypeScriptKafkaRedis
RoleBackend-focused full-stack
Core stackC# / .NET · React · TypeScript
Engineering focusForms · Workflow · Integrations
Backend topicsKafka · Redis · APIs · Async processing

Original interface design · Demo data. Identifying values are replaced in edited images. These are separate example workflows, not one continuous production record.

Workflow designer with parallel approvals and SLA settings
Parallel approvals, approver selection, and SLA configuration.View full image ↗

My contribution

From a business rule
to working software.

I added and refined features across the web client and backend—not the entire platform.

AreaWeb / ReactBackend / .NET
Configurable formsWeb / ReactConditional fields, table interactions, remote dataBackend / .NETDependent-field evaluation, data mapping, row operations
Workflow executionWeb / ReactSLA/action configuration, processing statesBackend / .NETTransition checks, approver handling, deadlines
External integrationsWeb / ReactAPI configuration, result/error visibilityBackend / .NETRequest mapping, workers, external-result processing
Operational reliabilityWeb / ReactAutosave coordination, cache behaviorBackend / .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.

Task form builder with demo company and avatar
Forms / Field configuration and layout.View full image ↗
Completed payment request with fictional employee, department and request details
Workflow / A completed request with demo data.View full image ↗

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.

API connection configuration with demo identifiers and send-information mode selected
API configuration / The example shows send-only mode, not result-waiting mode.View full image ↗

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.

A / Outbound workMy implementation · multi-request path
  1. Workflow actionSave data; identify step
  2. Kafka messageAction, tenant, user context
  3. Integration workerLoad state; map payloads
  4. External APISend configured HTTP calls
B / Incoming responsesExisting platform path I worked within
  1. External callbackResolve session; log response
  2. Kafka messageQueue response context
  3. Response workerResolve form and action
  4. Workflow stateMap result; trigger processing
Not every API call goes through Kafka.

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.

01 / SEND

Prepare request

Map form values into the API payload.

02 / WAIT

Keep explicit state

Wait for the external business result.

03 / RECEIVE

Validate and apply

Check the current action; map returned data.

04 / CONTINUE

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.

Existing platform mechanism

Concurrency & state protection

The callback path uses a Redis-backed lock scoped to a form and action to coordinate competing updates.

Lock → Reload state → Validate token/status → Apply result → Release
Coordination against concurrent updates, not a claim of exactly-once processing.
Platform mechanism + my refinements

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.

Service boundaries I worked across

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.

What this work reflects

Understanding the workflow.
Building the details behind it.

My contribution spans business-rule configuration, backend execution, integrations, and the web interfaces that support them.

Forms & workflow

Configurable fields, permissions, conditions, and deadlines run as executable workflows.

Queued integrations

Kafka carries multi-request work; the worker maps payloads and calls the external API.

External results

A workflow waits at the integration step until the business result is validated.