# Managed or Self-Run Source: John Bradshaw — https://bradshaw.cloud URL: https://bradshaw.cloud/strategy/managed-vs-self-run/ Type: insight Date: 2026-11-12 Tags: Cloud, Economics, Platform Engineering, Strategy > The premium on a managed database, queue or search service buys an on-call rota. Self-running open source wins only when the fleet is large enough to spread that fixed cost. ## What the managed premium buys, and what replaces it Four views of one decision. Every figure on this page is illustrative or a stated assumption, to be replaced with numbers from your own estate. ### The managed price is compute plus labour you do not see A managed database, queue or search service costs more than the machines underneath it. The difference pays for patching, version upgrades, failover, tested backups, capacity planning and somebody who answers the page at night. A business case that compares the managed price with raw compute has priced the machines and left the labour out. **Business take:** Before arguing about the size of the premium, list what it covers and put a name against each line in the self-run design. A line with no name is work nobody has agreed to do. ### One instance needs the same rota as fifty Round-the-clock cover is a number of people, and that number does not shrink with the fleet. One engineer on call every week is an attrition plan. As an assumption to replace with your own, sustainable cover needs six to eight engineers who know the technology well enough to repair it under pressure. That cost arrives in full with the first production instance. **Business take:** This is why a small estate rarely wins by self-running. The saving is per instance and the rota is per technology, so the first few instances carry a rota they cannot pay for. ### Self-running pays once the fleet covers the rota The managed premium grows with every instance. The fixed cost of self-running stays roughly flat, with a smaller amount per instance for upgrades and incidents. The two lines cross at a fleet size you can calculate: the fixed cost divided by the saving on each instance. Below that fleet size, self-running costs more. Above it, the gap widens with each instance added. **Business take:** Ask for the break-even fleet size before the migration plan. If the estate is at a third of it and not growing, the answer is to stay managed and spend the effort elsewhere. ### Self-running changes the supplier risk. It does not remove it Running open-source software yourself ends the dependency on a service operator. It leaves a dependency on the project. A licence can change, a free edition can be withdrawn, and a maintainer can stop. Each of those forces a choice between paying, forking, freezing on an old version or migrating, and each choice needs engineers. **Business take:** Put the project in the supplier register alongside the service it replaced. Record who maintains it, what the licence permits, and what the team would do in the quarter after a change. ## Who carries the pager Five ways to operate the same technology. The right-hand label is what each one costs you. ### Operating models for a data service From an operator carrying everything to a shared internal service - Fully managed — The operator patches, upgrades, recovers and carries the pager — Premium per instance - Managed with an exit tested — Standard interfaces, exports rehearsed, restore proven elsewhere — Premium plus a drill - Self-run by each team — Every team operates its own instances and its own on-call — A rota per team - Self-run as a shared service — One team operates the technology for every tenant — One rota, shared - Internal managed service — Shared rota, published service levels, a price per instance — Rota spread thin _The third rung is the expensive one. Each team that self-runs alone pays for a full rota, or goes without one and finds out during an incident. If the fleet justifies self-running, pool it._ ## Decision framework ### Is the fleet above its break-even size? **No, and it is not growing: stay managed.** Divide the fixed cost of self-running by the saving on each instance. If the estate sits well below the result, the premium is the cheaper way to buy round-the-clock cover. Revisit the sum when the fleet doubles, not every quarter. ### Who answers the page at 03:00 in month eighteen? **If the answer is one named person, the design is not finished.** A self-run service needs enough engineers that holidays, illness and resignations do not leave a gap. Count the people who could repair the service under pressure today. The people who could learn do not count yet. ### Can several teams share one rota? **Yes: run it as a shared service. No: the saving is probably not there.** Pooling is what turns a fixed cost into a small cost per instance. A shared team with a published service level and a price per instance is an internal managed service. It needs funding and a product owner like any other service. ### What happens if the project changes its terms? **Write the response down before adopting the project.** Decide in advance whether the team would pay, move to a fork, freeze or migrate, and what each would cost. A project with one commercial sponsor and no independent governance carries a different risk from one with many maintainers. ## Frequently asked questions ### Is self-running open source cheaper than a managed service? It depends on fleet size. The managed premium is paid per instance. Self-running has a fixed cost, mostly the on-call rota, plus a smaller cost per instance. Below the break-even fleet size the managed service is cheaper. Above it, self-running is cheaper and the gap grows with each instance. ### What does the managed premium pay for? Patching, version upgrades, failover, tested backups, capacity planning and round-the-clock incident response. A comparison between the managed price and raw compute leaves all of that labour out of the self-run side. ### How many engineers does a self-run service need? Enough for sustainable round-the-clock cover. This page uses six to eight as an assumption, and you should replace it with your own figure. The number does not fall when the fleet is small, which is why small estates rarely save money by self-running. ### How do I calculate the break-even fleet size? Add up the fixed annual cost of self-running: the share of the rota spent on the service, plus tooling. Divide it by the annual saving per instance, which is the managed premium less the per-instance cost of upgrades and incidents. The result is the number of instances at which the two options cost the same. ### Does self-running remove vendor lock-in? It removes the dependency on a service operator and leaves a dependency on the open-source project. Licences change, free editions are withdrawn and maintainers stop. Each event forces a choice between paying, forking, freezing or migrating, and each choice costs engineering time. ### What is an internal managed service? A shared team that operates a technology for every tenant in the organisation, with a published service level and a price per instance. It spreads one rota across the whole fleet. It is the model that makes self-running pay at scale, and it needs funding and ownership like a product. ## Diagrams Standalone SVG diagrams, licensed CC BY 4.0 with attribution to John Bradshaw — link back to https://bradshaw.cloud/strategy/managed-vs-self-run/ when embedding. - [The managed price is compute plus labour you do not see (SVG)](https://bradshaw.cloud/strategy/managed-vs-self-run/diagrams/premium-faf7f129f3.svg) - [One instance needs the same rota as fifty (SVG)](https://bradshaw.cloud/strategy/managed-vs-self-run/diagrams/rota-a8389c4383.svg) - [Self-running pays once the fleet covers the rota (SVG)](https://bradshaw.cloud/strategy/managed-vs-self-run/diagrams/break-even-918b23ecda.svg) - [Self-running changes the supplier risk. It does not remove it (SVG)](https://bradshaw.cloud/strategy/managed-vs-self-run/diagrams/supplier-risk-427294b93b.svg) ## Interactive companion **Managed or Self-Run: Break-Even Fleet** — Enter the fleet, the managed premium and the rota it would take to run the service yourself. The calculator returns the annual gap and the fleet size at which self-running starts to pay. Every default is illustrative. Live calculator: https://bradshaw.cloud/strategy/managed-vs-self-run/calculator/ ## Related - [Build vs Buy](https://bradshaw.cloud/strategy/build-vs-buy/) — the same total-cost reasoning, applied to software. - [Platform Operating Model](https://bradshaw.cloud/strategy/platform-operating-model/) — how a shared team serves many tenants without becoming a queue. - [Cloud Repatriation](https://bradshaw.cloud/strategy/cloud-repatriation/) — the placement decision that often raises this one. - [FinOps Maturity](https://bradshaw.cloud/strategy/finops-maturity/) — the cost discipline to apply before changing the operating model. - [Cloud exit readiness](https://bradshaw.cloud/writing/cloud-repatriation-exit-readiness/) — the dependency test, including who operates the target. - [All strategy insights](https://bradshaw.cloud/strategy/)