The Story

Regional analytics ran on dedicated cloud compute. It could be stopped — that was never the problem. The problem was that it could not be resized to match a workload, and it took long enough to come back up that stopping it carried a real cost in people waiting. So we kept long idle timeouts. That was a deliberate decision rather than an oversight: leaving the resource running through quiet periods was less disruptive than making analysts wait for a cold start every time demand picked up again. The idle time was not waste through carelessness. It was the rational response to a slow restart, and it stayed rational for as long as the restart stayed slow. Moving to serverless changed the constraint rather than the discipline. Compute that scales quickly and starts on demand made short idle timeouts viable for the first time, so we shortened them. The platform now spins up when there is work and stands down shortly after there is not, which is what the original setup was supposed to do and could not. The compute itself was the smaller half of the work. Hundreds of downstream systems consumed from that platform — reporting, applications, integrations — spread across markets, functions and continents, owned by teams with their own release calendars and their own reasons to be cautious. Every one of them had to be identified, prepared and repointed. The consumers nobody remembered owning were reliably the ones that mattered, and finding them before the cutover rather than during it was most of the preparation. Sequenced properly, market by market and system by system, that coordination took considerably longer than moving the compute. On cost the honest answer is that it came out comparable rather than dramatically lower — serverless carries a premium per unit that offsets much of the idle time removed. The real gain is that consumption now follows the usage curve almost exactly, so the platform bill reflects what the business actually did rather than how long a resource happened to be left on. Two habits worth keeping: map every downstream consumer before you touch anything, and ask why a stoppable resource never gets stopped. The blocker is almost always restart time rather than willingness, and that is a solvable problem.

These are the problems I find worth the effort: unglamorous, constrained, and consequential. If you have one like it, I would like to hear about it.

Get in Touch