Jakub Heidtke logoJakub Heidtke
back to All projects

Professional

Camunda Source

Overview

Camunda Source formed the Camunda-to-messaging side of the workflow integration layer. It polled Camunda external tasks, resolved configured event or command contracts, converted process variables into strongly typed messages, published them through Event Hub, and completed the corresponding Camunda tasks. My strongest contributions focused on extending contract creation beyond primitive values, enabling nested object reconstruction from Camunda variables, and adding warehouse and order command flows to the integration.

My Role

  • Implemented support for reconstructing complex and nested messaging contract properties from Camunda task variables using JSON deserialization, reflection and recursive conversion.
  • Extended the worker so Camunda tasks could create contracts whose static Create methods required complex object graphs instead of only primitive parameters.
  • Added Camunda-to-messaging support for AuthorizeOrderForPickingCommand, including topic configuration and messaging contract integration.
  • Added publishing support for GenerateOrderSummaryCommand from Camunda external tasks.
  • Improved audit logging for non-tenant events by assigning them a consistent global tenant context.
  • Contributed to dependency and platform maintenance, including messaging package upgrades, AutoMapper removal and deployment-configuration cleanup.

Architecture & Technology

  • .NET hosted worker polling Camunda external tasks through the Camunda REST API
  • Configuration-driven mapping between Camunda topic names and Oriflame event or command contracts
  • Reflection-based contract creation using static Create methods
  • Recursive conversion of primitive and complex Camunda variables into strongly typed contract parameters
  • Event Hub publishing through the company Ori.Messaging infrastructure
  • Polly retry handling around Camunda task completion and failure reporting
  • Bounded concurrent processing of fetched external tasks
  • Application Insights telemetry, audit logging, Docker and Azure DevOps CI/CD

Engineering Challenges

  • Convert loosely structured Camunda task variables into strongly typed messaging contracts whose construction rules were defined by static Create methods.
  • Support nested object graphs and complex contract properties while preserving the same mapping model used for primitive parameters.
  • Coordinate message publication and Camunda task completion even though the two operations do not form a shared transaction.
  • Avoid unbounded parallel processing while continuously polling Camunda for new external tasks.
  • Preserve traceability and correlation between Camunda process instances and the messages published to downstream systems.

Decisions & Trade-offs

  • Resolve message contracts from configured Camunda topic names instead of hard-coding message creation into each worker path. This kept the worker generic and allowed new command or event mappings to be introduced primarily through configuration and contract packages.
  • Build complex contract values by inspecting static Create methods recursively rather than bypassing the domain contract construction model with direct property assignment. This kept generated messages aligned with the conventions of the shared messaging contracts.
  • Deserialize complex Camunda variables from JSON and map their members case-insensitively to nested contract parameters. This generalized the integration beyond primitive process variables without requiring a custom converter for each contract type.
  • Publish the message before completing the Camunda external task so failed conversion or publication leaves the task available for retry. Because publishing and completion are not atomic, duplicate publication remains a possible failure mode if task completion repeatedly fails after a successful publish.
  • Limit concurrent processing using configured task capacity rather than fetching an unrestricted number of Camunda tasks.

Results & Impact

  • Removed a major limitation in the integration by enabling Camunda tasks to create events and commands containing nested complex properties.
  • Enabled warehouse and order workflows to publish strongly typed commands from Camunda into the shared messaging platform.
  • Preserved a generic, configuration-driven external-task processing model rather than introducing command-specific worker implementations.
  • Improved audit consistency for global and non-tenant messages.
  • Contributed to the broader asynchronous integration layer connecting Camunda workflow execution with downstream business services.