Anyone who has sat through a spine consultation knows the shape of a good second opinion: the surgeon does not ask which treatment sounds nicest, but which option fits the imaging, the workload your daily life demands, and the recovery you can actually sustain. Deciding how far to push NoOps — the ambition of running software with no dedicated operations department — deserves the same discipline. There is no single treatment. There are three recognisable routes, each with its own evidence file, its own failure patterns, and its own recovery period. This piece lays them side by side and scores them against each other, the way a careful patient should score surgical against conservative care: on recorded outcomes, not on bedside manner.
What We Mean by the NoOps End State
Define the target before comparing paths, or the comparison drifts. The end state in question is an organisation where routine operational work has been purchased or scripted to such a degree that nobody’s job title contains the word operations. It is worth saying plainly what that target is not. It is not a world where the work evaporates; provisioning, patching, recovery drills and permission reviews all still happen, just under other roofs or inside other code. It is also not a weekend project. The analyst who coined the term in early 2011 pitched it as the death of DevOps, and his own employer had softened that framing into an augmentation of DevOps within a quarter — a useful reminder that even the originators corrected course once the evidence arrived.
Route One: Buy Execution by the Request
The first route rents computing in units of a single function invocation. You ship code; the provider starts it, scales it, and bills you per use. For genuinely spiky, lightweight, event-driven work this is often the right prescription, and it removes an enormous quantity of server husbandry overnight.
The evidence file has a famous caution stapled to it, though. An engineering team at a large video-streaming service moved parts of its monitoring pipeline onto managed step-and-function building blocks and found the design buckling at roughly one twentieth of the traffic it was meant to absorb; data shuttling between the rented pieces charged them for every hop. Relocating that component onto ordinary rented virtual machines slashed its running bill by roughly ninety percent. The honest conclusion is not that the blocks are bad but that unit economics flip with shape and volume: a therapy that suits a sprain can cripple a fracture.
On the scoreboard, then: fastest duty relief, weakest fit under steady heavy load, and — if the Berkeley assessment of the model holds — bills that are hard to forecast and attachment to the vendor that tightens over time.
Route Two: Hand Duties to Vendors
The second route keeps conventional architecture but buys the operation of whole layers: databases run by someone else, queues run by someone else, sometimes entire stacks watched by an outside firm. Done well, this genuinely shrinks the in-house roster, and for lean teams whose scarcest skill is building the product itself it is frequently the sensible trade.
Two entries belong in this route’s evidence file. First, managed does not mean immortal: Google wound its IoT Core offering down in 2023, stranding customers who had assumed the arrangement would outlast their product plans. Second, managed does not mean defended: the intrusion campaign that hit a major data warehouse’s customers in 2024 needed no flaw in the provider’s platform, because the entered accounts had skipped multi-factor sign-in, credential rotation, and network allow lists. The vendor was not breached; the customers were. Whoever sells you operations cannot sell you your own judgement about keys, data and access — those four duties sit with you in every service model, as Microsoft’s shared-responsibility table has said for years.
Scoreboard: broad duty relief without re-architecting, but a new dependency on one company’s roadmap, and a security residue that stays yours whether or not the contract mentions it.
Route Three: Build the Automation In-House
The third route is the platform-engineering answer: keep a small internal group whose product is automation itself. Pipelines provision environments, policies block unsafe settings before deployment, self-service templates absorb the requests that used to become tickets. Nothing is outsourced; the chore is industrialised instead.
This route costs the most attention up front and pays back slowly, which is why the maturity ladder used in serious assessments runs from “no ops by assertion” at the bottom — the team that disbands its engineers on migration day — through progressively measured stages, to a summit the field calls “low ops by design”, where the remaining residue is counted, owned and rehearsed. The recommended pace is deliberately boring: first write down every recurring duty in a register, then assign each one an owner, then rehearse the failure modes and put a price on leaving any given provider. Thirty, sixty, ninety days — a rehabilitation programme, not an amputation.
Scoreboard: highest control and best reversibility, slowest visible savings, and a real risk that the platform group quietly becomes the operations department with a new name — which, if you read the history honestly, is roughly what happened after Netflix let its developers own deploys and pagers in 2012, and one veteran observer dryly noted that operations had merely been reorganised.
Scoring the Routes Against Each Other
Line them up and five comparison points do most of the work.
- Speed of relief. Route One wins for small spiky services; Route Two for whole categories of undifferentiated upkeep; Route Three rewards patience rather than urgency.
- Cost behaviour. Per-request pricing punishes steady heavy traffic; vendor contracts smooth bills but hide renewal risk; in-house automation fronts its costs early.
- Reversibility. The cheaper a route made your exit look, the more suspicion it deserves. Regulation is finally helping here: from January 2027 the EU Data Act bans switching and egress charges, which lowers the invoice for leaving — though it lowers nothing about the engineering effort of actually migrating.
- Who holds the pager. Route One: mostly nobody, until an outage proves otherwise. Route Two: the vendor, within contract limits. Route Three: your own rota, sized honestly or not at all.
- Security residue. Identical in all three: data, identities, configuration, access rules — yours, on your worst day as on your best.
A word on how to weigh that list, because evidence comes in grades. A published engineering post-mortem with numbers attached outranks a conference anecdote; a retirement notice outranks a rumour about vendor intentions; a regulator’s timetable outranks a sales deck’s promises. Clinic review panels use the same hierarchy when judging treatments, and the habit transfers cleanly to infrastructure choices. When a colleague tells you a route “obviously” works, ask which grade of evidence they are holding. Most disagreements about these three paths dissolve once the room agrees to admit only incident reports, cost records and contract histories — the infrastructure equivalent of imaging before surgery.
What the Evidence Says About NoOps Ambitions
Read together, the record supports a modest, testable claim rather than a revolution. Duties demonstrably move; the department label demonstrably can go; the work demonstrably persists somewhere, and teams that pretend otherwise meet it during their worst week. The pattern across all three routes is that the winner depends on workload shape, team size and exit appetite — variables no keynote can know for you. If the comparison above leaves you wanting the deeper background on the term itself, the Ops Atlas publishes the Ops Atlas NoOps entry, which traces the history and the counter-arguments in one place.
A Decision Order Worth Copying
Practitioners who navigate this well tend to decide in the same sequence, whatever their industry. First, count: a written register of recurring duties, with hours attached. Second, classify: which duties are commodity enough to buy, which are too intimate to hand over, which are worth industrialising in code. Third, pilot on one service and measure the residue, not the rhetoric. Fourth, price the exit from any provider before the dependency deepens, while leaving is still a theoretical exercise. Readers who want the financial half of that discipline will find our simple guide to cloud financial management covers the costing habit, and our piece on the playbook for AI integration, cloud migration, and platform engineering shows how route three is assembled in practice. Spine clinics teach the same order with different nouns: image first, compare options against the evidence, operate only when the conservative routes have been honestly priced — and never mistake the discharge summary for the end of rehabilitation.