Held since Friday
A shop that rents out cinema cameras does two things the moment a customer books a kit: it holds the kit and it charges the deposit. Neither needs the other, so the team drew them as parallel branches, and because the card processor is flaky, the charge retries. This is one booking, read back from the logs:
- Friday 17:02: the Fork starts both branches.
- Friday 17:02: Hold kit succeeds, the kit leaves the calendar, and that branch waits at the Join.
- Friday 17:03: the processor has returned an error on all three attempts, and the deposit branch ends at Deposit failed.
- Friday 17:03: the customer sees that the payment failed and rents from someone else.
- Tuesday 09:40: a counter assistant asks why a kit that three people tried to book spent the weekend on the shelf.
The run was still open. One branch had ended, the other was at the Join waiting for it, and nobody had been paged, because from outside that looks like a slow branch. Check the team's diagram one construct at a time and each is right. The bug is in the place where they meet, and those seams are what this article is about. Each construct on its own belongs to Gateways: parallel, inclusive & event, Loops & retries and Error handling & error boundaries.
The branch that will not arrive
A Parallel Gateway both forks and joins: the same node, used at each end of the concurrent section. The join waits for every branch, so the flow only confirms once the hold and the deposit are both done, which is exactly what you want on a good day. A loop's cap gives the deposit branch a second way to finish, and the join knows nothing about it. When retries run out the deposit branch never reaches the Join, so the hold branch would wait there forever and the kit stays held. The failure path must also cancel the other branch and release the reservation, so the Error Boundary in this diagram is not optional.
Where the boundary sits matters as much as whether it exists. It goes on the branch where Cap reached? answers yes, before Deposit failed. Put it one step earlier, on the no of Charged?, and the first blip from the processor cancels a hold the booking still needs if the next attempt works. Skipping it because the happy path "mostly works" in testing is how this ships, since a test processor that answers every call never reaches this path.
Inside the boundary, cancel first, then release: if the hold is still running when the deposit gives up, a release that runs first finds nothing, and then the hold lands on a booking nobody wants. The flowchart has no arrow for stopping another branch, so the boundary's title carries that promise, and whatever runs the flow has to keep it: a cancel that only sends a signal leaves the same race if the hold can still complete after it. The boundary is also where somebody gets paged. A worker that dies mid-charge never reaches it, and a deadline on the wait, kept by something that outlives that worker, is what catches that; BPMN events: timer, message & boundary covers timers. When several steps have to be undone, which undo runs in which order belongs to Saga.
Which node the retry comes back to
Charge deposit needs two ways in, the first attempt and every retry, and on the Grid a Process accepts one. The Fork sits right above it with free ports, which makes it tempting. Wiring the retry loop-back into the Fork instead of a fresh Merge in front of the retried step is the mistake: read as a fork, re-entering it re-runs every branch, so each payment retry would also hold the kit again. In strict BPMN it fails differently: a Parallel Gateway with two incoming edges joins first, so it waits for a retry that can only come after it has let the flow through, and the booking never starts. A Merge that only the charge sits behind keeps the repeat inside one branch. A charge that timed out may also have gone through, so a retry can take the deposit twice unless the call is safe to repeat; Idempotency & exactly-once illusions owns that.
The same swap in the other direction breaks the far end. A Merge passes on each path as it arrives, without waiting. Use one in place of the Join and Confirmed runs as soon as the hold lands, with the deposit still undecided, and then a second time if the deposit clears. Both branches must reach the Join before the flow continues, and only a node that states that wait can promise it.
The other branch pays for the cap
A Delay on the retry edge backs off between attempts, giving a transient failure time to clear before the next one. Inside a fork, every second on that edge is also a second the kit is held. Three attempts 30 seconds apart take about a minute, plus the calls themselves, and nobody notices. Ten attempts with a wait that doubles from 30 seconds take more than four hours, and on a Friday evening that is a kit nobody else can rent, for a deposit that may still fail.
One pick fails, two branches keep going
Parallel Order Fulfillment puts this seam in a warehouse: its brief has an out-of-stock pick fail the whole order and abandon the other branches, and its palette holds the Parallel Gateway and the Error Boundary. When your diagram is drawn, take an order whose pick fails while the packing material and the label are still in progress, and follow those two branches to the end. If one of them is left waiting at a join, or the parcel can still reach the carrier, the failure path is not finished.