Cross-posted from the Renkara engineering blog. This version is the personal one — what the numbers did to my thinking, rather than what they are.
I spent last night pulling apart our AWS bill, and somewhere around midnight I ended up costing out a decision I made five months ago without ever really checking it.
Since March I've built 33 internal tools instead of buying the commercial equivalents. Defect tracking instead of Jira. Chat instead of Slack. Observability instead of Datadog. Accounting instead of QuickBooks. At the time this felt obviously correct in the way things feel obviously correct when you want to do them anyway.
So I ran the numbers properly. Three of them.
What the commercial stack would cost. Twenty-six of those tools map onto a product somebody sells by the seat. At four people, list price, that stack is $52,560 a year. Force in the two products that have no four-person price at all — Glean wants a 100-seat floor, patent portfolio management is quote-only — and it's $127,560.
What mine costs. $280 a month. $3,354 a year. Fifteen production services on six vCPUs and a small Postgres.
What it cost to build. This is the one I hadn't looked at. I log every session to my own leverage tracker with an estimate of how long the same work would have taken a senior engineer who already knew the codebase. Across 397 sessions: 14,105 human-equivalent hours against 225 hours of actual wall-clock time. A factor of 62.7.
Fifteen times cheaper to run. Great. That's the number you put on a slide, and it's the least interesting thing here.
The number that stopped me
14,105 hours is 7.1 person-years. At a $100/hour loaded rate that's $1.41 million.
Spending $1.41M to avoid $49K a year of software is a 29-year payback.
I sat with that for a while, because it means that if I'd had to pay engineers to build this, building it would have been an act of genuine stupidity. Not a close call. Not "defensible if you value control." Stupid. Any competent engineering leader would have killed it in the first meeting and they would have been completely right.
The reason it wasn't stupid is that I didn't spend $1.41M. I spent 225 hours and a subscription.
What I actually learned
I've been telling myself a story where I built these tools because SaaS is overpriced, or because integration between vendors is bad, or because I wanted control over my own data. Those things are all true and none of them are the reason. Plenty of people believe all three and still buy Jira, correctly.
The real reason is that the build number moved and I hadn't consciously noticed.
Build-versus-buy has always been a comparison between one large known cost and one small recurring one. Buy won nearly every time, and it won for a good reason: the build side was enormous, because software took human-years. Every rule of thumb I absorbed over twenty years — don't build what you can buy, focus on your core competency, undifferentiated heavy lifting — is downstream of that one fact.
When the build side drops by a factor of sixty, those rules don't bend at the edges. They break for a whole category of software that was never remotely close before.
The uncomfortable part is that I made this decision on instinct in March and only checked it in August. I got the right answer for reasons I couldn't have articulated at the time. That's not judgement, that's luck with good ergonomics.
The caveats I owe you
The leverage estimates are mine. I made them, about my own work, at the time I did it. They're a considered figure and not a measurement, and if you want to discount them 30% the argument survives fine.
The SaaS prices are list. Real contracts land 10–30% lower. Doesn't change the shape.
And building means owning. Every one of those 33 tools is now mine to patch and migrate and keep alive at 2am. That cost is real, it's ongoing, and it doesn't show up in the $280. It's tolerable for exactly the same reason the build was — maintenance got cheap by the same factor — but "tolerable" is doing real work in that sentence.
I'd also add: this worked for operational tooling. Known requirements, one user, no compliance surface, and I can walk down the hall to the product owner because he's me. I am not about to write my own database.
Where I've landed
The thing I keep turning over isn't the $49K. It's that a rule I'd internalized so deeply I stopped seeing it as a rule — don't build what you can buy — turns out to have been a statement about the price of engineering hours, wearing a costume as a principle.
The hours got cheap. The principle was never load-bearing on its own.
I don't think that generalizes to everything, and I'm suspicious of anyone who says it does. But it generalized further than I expected, and I found that out by accident rather than by checking. So: check. The arithmetic most of us are carrying around is correct against a number that stopped being true.