Coordinate work across systems that were never designed to cooperate.
A coordination layer that holds the state of a multi-system process, sequences the calls, and knows how to recover when the fourth step fails after the first three succeeded.
The problem with chained integrations
Point-to-point integrations work until a process needs four of them in order. Then nothing holds the state of the whole sequence, nobody knows how far it got, and a failure halfway leaves records committed in two systems and missing from a third.
- A business process depends on several integrations firing in the right order.
- When something fails midway, somebody fixes it by hand in each system.
- There is no single place that knows how far a given transaction got.
- Adding a system to the process means touching several existing integrations.
What we build
An orchestrator that owns the sequence: it holds state, calls each system in turn, retries what is retryable, and compensates for what has already been committed when the sequence cannot complete.
- A durable state machine per process instance, surviving restarts
- Sequenced calls with per-step timeout and retry policy
- Compensating actions to unwind partial completion
- Dead-letter handling with human resolution for cases automation cannot fix
- A single view of where any transaction has reached
- Systems added or reordered as configuration rather than as a rewrite
How it runs
Designed around partial failure, because in a multi-system process it is the normal case.
- 01Model the sequence
The steps, their order, what each requires and what each commits — including which are reversible.
- 02Make state durable
Every instance persists its position, so a restart resumes rather than restarts.
- 03Define compensation
For each committing step, what would undo it. Where nothing can, that step is sequenced as late as possible.
- 04Execute with policy
Timeouts, retries and backoff per step, tuned to how each system actually behaves under load.
- 05Expose the state
One view showing where every in-flight transaction is, and a queue for those needing human resolution.
What changes once it is running
What owning the sequence changes about multi-system work.
Partial failure stops being manual
The orchestrator retries or compensates instead of someone repairing three systems by hand.
Position is always knowable
"Where did this get to" is a query rather than an investigation across logs.
Change gets cheaper
Adding a system to the process is a configuration change rather than surgery on several integrations.
Consistency is designed
Systems converge on the same state deliberately, rather than by luck and manual correction.
How an engagement is shaped
One process end to end. Orchestration proves itself on a sequence, not on a diagram.
Process and failure design
Two to three weeks modelling the sequence and, more importantly, the compensation for every committing step.
Build and prove
The orchestrator delivered for one process, tested against deliberately injected failures before it carries real volume.
Extend
Further processes onto the same orchestrator, with monitoring of in-flight state and dead-letter volume.
Common questions
The things buyers ask before they commit. If yours is not here, it is a good first question for the assessment.
- How is this different from workflow automation?
- Considerable overlap. Workflow automation is oriented around people and their queues; orchestration is oriented around systems and their consistency. Most real processes need both, and we build them as one layer.
- Do we need a commercial orchestration product?
- Not necessarily. The durable state machine can be built on infrastructure you already run. We recommend a product when the process count justifies the licence, not before.
- What about steps that genuinely cannot be undone?
- They get sequenced as late as possible and gated behind everything that can fail. Where that is impossible, the process needs a human checkpoint, and we design it in rather than discovering the need later.
Describe the process that breaks in the middle.
The one where somebody has to go and fix three systems by hand. That is the sequence worth owning.