In large organizations, it's hard to coordinate components from different teams converging at the right time if it's continuous delivery.

One way is to have full agile, micro-services, swarms of autonomous sports cars.

The downside of this is that the overall result won't necessarily look coherent.

Any time the different components need to coordinate it will be swirly.

Big coherent changes will be basically impossible.

Another way is with a pipelined, coordinated release schedule.

"We release all new features on the first day of the quarter"

Everyone does their bit, and then waits for the signal to launch it at the same time.

This is not too dissimilar how in a processor, the clock speed is set by how long it will take the longest circuit to flow to the checkpoint before being released by the clock signal.

Obviously this has some wastage because there are some teams that get to the ready state before others, and then just sit there twiddling their thumbs waiting for the clock signal to fire.

But it does make coordination much easier; there's an external clock signal everyone knows won't change and they can time their work off of.

An automatic, impossible to ignore schelling point.

And when you're there waiting at the gate, you aren't just twiddling your thumbs, you're doing quality improvement work, testing, etc.

That's a stage that can take as little or as much time as you want.

So a benefit of this approach is that you can also get higher quality output.

Much less agility and no power of the swarm, but like a steamroller reliably producing quality of a given level.