Designing for Cost and Total Cost of Ownership

Intermediate · 32 min

Why the sticker price is the smallest part of a build-vs-buy decision, and how cost trades off against performance and reliability.

Before thisServerless Architecture Trade-offs

Courier · 32 min

Designing for Cost and Total Cost of Ownership

The player loads from youtube-nocookie.com when you press play. Nothing reaches YouTube before that.

Taught by CourierReport a problem with this video
Not started
Set this lesson's status

What you'll learn

  • Total cost of ownership is the license fee or the engineer-hours to build it, plus integration, migration, training, and ongoing maintenance for the system's entire operating life — and the "plus" is usually larger than the headline number, in both directions.
  • Build costs are systematically underestimated because most of them are future and uncertain — the maintenance burden, the on-call load, the cost of the next feature a vendor would have shipped for free — while buy costs are systematically underestimated because integration, data migration, and training rarely show up in the vendor's quote.
  • The build-or-buy question is really a question about differentiation: a capability that is the reason customers choose you is worth owning and investing in, while a capability every competitor also needs (billing, auth, search infrastructure) is usually a commodity better bought, so engineering time goes toward what's actually differentiated.
  • Cost is not a constraint to satisfy once and move on from — it trades continuously against performance, reliability, and time-to-market, the same way those three trade off against each other, and an architecture decision that ignores cost as a fourth axis is incomplete.
  • A hybrid path — buying the commodity layer and building only the genuinely differentiated piece on top of it — is usually underrated next to the all-or-nothing framing of "build vs. buy," and it's the most common real-world outcome once a team actually does the comparison.

Cost as a fourth axis, not an afterthought

Most of what this roadmap covers so far asks “what’s the right shape for this system?” in terms of performance, reliability, and how fast a team can ship it. Cost is a fourth axis that trades off against all three, and treating it as something to check at the end — after the architecture is already decided — is how a technically elegant design turns into a budget crisis. An architect who can’t put a number, even a rough one, on a design’s ongoing cost hasn’t actually finished the design.

What total cost of ownership actually includes

Total cost of ownership (TCO) is the full cost of a system or capability across its operating life, not just the price tag at the moment of the decision. For something you buy, that’s the license or subscription fee, plus integration work to connect it to the rest of your system, plus data migration if you’re replacing something else, plus training for the people who’ll use or operate it, plus whatever customization and ongoing vendor-relationship management it needs. For something you build, that’s the engineering time to build the first version, plus — and this is the part that’s chronically underestimated — the engineering and operational time to maintain it for years afterward: fixing bugs, patching dependencies, handling on-call incidents, and rebuilding it again when the original design stops fitting new requirements. Industry estimates vary, but the shape is consistent across most of them: maintenance, not initial construction, dominates a system’s lifetime cost. A system that took three engineer-months to build can easily cost several times that over five years in upkeep alone, and a TCO comparison that only looks at the build estimate is comparing an iceberg’s tip to a vendor’s full quote.

Why both sides of the comparison get underestimated, in different ways

Build costs are hard to pin down because most of them are in the future and uncertain: nobody can precisely forecast how many incidents a system will have next year, how much a dependency upgrade will cost in engineering time, or how much slower every future feature touching this system will ship because it now has to account for this piece’s quirks. None of that has a line item, so it’s easy to leave out of a build-vs-buy comparison and end up comparing a vendor’s all-in quote against only the first month of a multi-year build cost. Buy costs are underestimated for the opposite reason: they’re genuinely absent from the vendor’s number. A SaaS contract’s sticker price rarely includes the engineering time to integrate it, the cost of migrating existing data into its format, the training time for the team that’ll operate it, or the switching cost if you ever need to leave. Treating either side’s headline number as the real cost is the single most common mistake in this kind of decision.

Build-or-buy is really a question about differentiation

The clearest decision heuristic available is to ask: is this capability the reason a customer chooses us, or is it table stakes everyone needs? Billing, authentication, generic full-text search, and basic observability are rarely what makes a product win — every competitor needs roughly the same thing, a mature vendor has already solved it at a scale and reliability level a small team won’t match quickly, and every engineer-week spent re-deriving it is a week not spent on what’s actually differentiated. Conversely, the part of the system that embodies your actual competitive edge — the matching algorithm, the core workflow your product is built around — is usually worth owning outright, even at higher short-term cost, because a vendor’s generic version can’t be the thing that makes you better than the next company using the same vendor. This question (differentiator or commodity?) is a faster first filter than a full TCO spreadsheet, and it’s worth asking before building the spreadsheet at all.

The hybrid path is the usual real answer

“Build vs. buy” is often posed as a binary, but the most common real-world outcome is neither pole: buy the commodity substrate (a managed database, an off-the-shelf auth provider, a payments processor) and build only the thin, genuinely differentiated layer on top of it. This gets most of a build’s advantage (full control exactly where control matters) with most of a buy’s advantage (no engineering time sunk into solved problems) and is usually a better answer than either extreme. The job of an architect weighing this isn’t to have a universal rule — it’s to be explicit, for each specific capability under discussion, about where it sits on the differentiator-to-commodity spectrum, and to price both the build and the buy path honestly enough that the comparison means something.

Check yourself

  1. 01Why is a software build's total cost of ownership harder to estimate accurately than a purchased product's?

    A build's costs are mostly future and uncertain — the ongoing maintenance burden, the on-call and incident-response load, and the opportunity cost of engineers not working on something else — none of which have a vendor-quoted number, so they tend to be underestimated or left out of the comparison entirely.

  2. 02What is the "opportunity cost" argument for buying a commodity capability instead of building it?

    Every engineer-week spent building and maintaining a capability that isn't a competitive differentiator (billing, authentication, generic search) is a week not spent on the thing that actually makes the product win, and that lost differentiating work is a real cost even though it never appears as a line item on a budget.

  3. 03How does cost function as a fourth architectural trade-off alongside performance, reliability, and time-to-market?

    Every one of those three can usually be improved further by spending more — more redundant infrastructure for reliability, more optimization work for performance, more parallel teams for speed — so a design that doesn't treat cost as an explicit constraint will keep "improving" the other three past the point where the business actually benefits from it.

Notes

Private to you

Esc
↑↓ navigate↵ open? shortcuts

Keyboard shortcuts

Press Esc to close

Anywhere

⌘K
Search and commands
/
Search
?
This sheet
Esc
Close

Reading a lesson

J
Next lesson
K
Previous lesson
B
Bookmark