Skip to content

The Build vs Buy Decision Framework

Most build vs buy decisions rely on gut instinct and flawed spreadsheets. Here's a scored framework (CORE) I've used across 130+ decisions to consistently make the right call.

8 min read
Illustrative two options for the same small engineering assembly on a single table: a finished precision modular unit in muted teal, and the raw pieces, fitting jig and materials needed to construct an equivalent unit.
On this page

I've watched engineering teams waste over $2M building internal tools they should've bought off the shelf. I've also watched them spend $800K/year on vendor licenses for software a junior dev could've built in two sprints. The build vs buy decision is the most expensive recurring judgment call an engineering leader makes, and most teams get it wrong because they rely on gut feel instead of a repeatable framework.

Over 11 years leading engineering orgs, I've evaluated 130+ build vs buy decisions. 38 of those were wrong calls that I either made or inherited. This post is the framework I use now, and it's saved my last three teams from at least $500K in misallocated spend per year.

Why Most Build vs Buy Analyses Fail

The standard approach looks like this: someone puts together a spreadsheet comparing vendor costs against estimated development time. The spreadsheet always lies. Here's why.

Building costs need a lifecycle estimate. Include implementation, maintenance, security work and the product work the team will postpone. I've tracked my own teams' estimates against actuals across 43 projects, and the median overrun was 3.1x.

Buying costs are underestimated differently. Teams calculate the license fee and stop there. They forget integration costs, migration costs, training costs, the cost of workarounds when the vendor doesn't support your exact workflow, and the ongoing tax of keeping a third-party dependency updated.[1]

Both numbers are wrong. But they're wrong in different ways, which means the comparison is meaningless.

The CORE Decision Matrix

I use a four-factor matrix I call CORE: Competitive advantage, Operational complexity, Rate of change, and Ecosystem fit. Score each factor 1-5, then the math tells you what to do.

Factor 1: Competitive Advantage (Weight: 3x)

Ask this question: "If our competitor had the exact same version of this software, would it matter?"

  • Score 5: This is your product. Building it IS the business.
  • Score 4: Directly differentiates your product in ways customers notice.
  • Score 3: Indirectly supports differentiation. Customers don't see it, but it affects speed or quality.
  • Score 2: Useful internally but doesn't touch the product experience.
  • Score 1: Pure commodity. Authentication, email sending, payment processing for non-fintech companies.

If it scores 1-2 on competitive advantage, stop analyzing. Buy it. I don't care what the other factors say. Building commodity infrastructure is the single most common way engineering teams destroy value.[2]

Factor 2: Operational Complexity (Weight: 2x)

How hard is this thing to keep running after you build it?

  • Score 5: Requires dedicated on-call, specialized knowledge, and constant attention. Think database engines or real-time messaging infrastructure.
  • Score 4: Needs regular maintenance, security patching, and performance tuning. Think internal auth systems.
  • Score 3: Moderate maintenance. Quarterly updates, occasional bug fixes.
  • Score 2: Set-and-forget after initial build. Minor updates annually.
  • Score 1: Truly static. Build once, runs forever.

High operational complexity scores push toward buying because vendors amortize that ops burden across thousands of customers. Compare the operating support available from the vendor with the staff and skills your own implementation would require.

Factor 3: Rate of Change (Weight: 2x)

How fast is this domain evolving?

  • Score 5: Weekly changes in the underlying technology or standards. AI/ML tooling in 2026 is a perfect example.
  • Score 4: Monthly changes. Cloud provider APIs, security compliance requirements.
  • Score 3: Quarterly shifts. Front-end frameworks, CI/CD best practices.
  • Score 2: Annual changes. REST API conventions, database schemas.
  • Score 1: Mature interfaces with a small expected change burden over your planning horizon.

High rate of change pushes toward buying. Vendors track changes because that's their full-time job. Your team has a product to build.

Factor 4: Ecosystem Fit (Weight: 1x)

How well do available vendor solutions fit your specific tech stack and workflow?

  • Score 5: No vendor covers your use case. You'd need to combine 3+ tools and build glue code anyway.
  • Score 4: Vendors exist but require significant customization (>20% of the functionality needs custom work).
  • Score 3: Good vendor options exist with minor gaps. Standard integration effort.
  • Score 2: Multiple strong vendors, well-documented integrations for your stack.
  • Score 1: Dominant vendor that's basically an industry standard. Think Stripe for payments.

Calculating the Score

Build Score = (CompetitiveAdvantage x 3) + ((6 - OperationalComplexity) x 2)
              + ((6 - RateOfChange) x 2) + (EcosystemFit x 1)

Maximum possible: 40
Minimum possible: 8

Proposed score interpretation:

These weights and bands are author heuristics. Check the inputs against your context; the score does not establish a measured probability of project success.

Keep each CORE factor’s direction consistent Competitive advantage Higher rating increases the build score Operational complexity Higher burden decreases the build score Rate of change Faster change decreases the build score Ecosystem fit Larger vendor gap increases the build score Weights and score bands are author heuristics, not validated success probabilities.
Figure 1. The corrected score follows the direction described for each factor.
  • 32-40: Build. This is core to your business and you need full control.
  • 24-31: Lean build, but validate with a time-boxed prototype first.
  • 16-23: Lean buy, but negotiate hard on customization and API access.
  • 8-15: Buy immediately. Every sprint you spend building this is waste.

The Contrarian Take Most Leaders Miss

Here's where I disagree with conventional wisdom: most build vs buy frameworks treat the decision as permanent. They shouldn't. The right answer changes over time.[3]

I schedule build vs buy re-evaluations every 12 months for anything scoring 16-31. Here's why: a tool you built 3 years ago when no vendor existed might now have 5 strong SaaS competitors. A vendor you chose 2 years ago might have tripled their pricing or degraded their API.

At my last company, we built an internal feature flagging system in 2022 because LaunchDarkly was $48K/year and the alternatives were immature. By 2024, three strong open-source options existed. We migrated to one in 6 weeks and freed up an engineer who'd been spending 15% of their time maintaining our custom system. That's 7.8 weeks of engineering capacity recovered annually.

Real Decisions I've Made With This Framework

Authentication (corrected score:12 - Buy)

  • Competitive advantage: 1 (nobody picks your product because of your login screen)
  • Operational complexity: 4 (security patches, OAuth updates, MFA standards)
  • Rate of change: 4 (passkeys, WebAuthn, constantly shifting)
  • Ecosystem fit: 1 (Auth0, Clerk, dozens of options)

We went with Clerk. Total integration time was 3 days. Building equivalent functionality would've taken 8-12 weeks and required ongoing security expertise we didn't have.

Code Analysis Engine (corrected score:26 - Lean Build)

  • Competitive advantage: 5 (this IS our product)
  • Operational complexity: 4 (it's complex, but that complexity is our moat)
  • Rate of change: 5 (AI-powered analysis is evolving weekly)
  • Ecosystem fit: 5 (nothing on the market does what we need)

We built it. Obviously. The score records the assumptions behind that judgement.

Internal Admin Dashboard (corrected score:21 - Lean Buy; commodity rule applies)

  • Competitive advantage: 1 (internal tool, no customer sees it)
  • Operational complexity: 2 (pretty stable once built)
  • Rate of change: 2 (admin needs change slowly)
  • Ecosystem fit: 2 (Retool, Appsmith, multiple strong options)

We bought Retool. My engineering manager wanted to build a custom React dashboard. The CORE score saved us 6 weeks of engineering time.

The Stealable Framework: 72-Hour Validation Sprint

Before committing to any build decision with a score above 24, run a 72-hour validation sprint. Here's the exact structure:

Hours 0-8: One senior engineer builds the simplest possible version that handles the primary use case.

Hours 8-24: Same engineer extends it to cover the top 3 edge cases identified by the team.

Hours 24-48: A different engineer tries to use, modify, and break it. They document every friction point.

Hours 48-72: The team reviews findings and answers: "Based on this prototype, do we still believe the build estimate? What did we miss?"

In my experience, 40% of build decisions get reversed after the 72-hour sprint. Not because building is wrong, but because the prototype reveals hidden complexity the initial estimate missed. That's $200K+ in avoided waste every time it catches a bad call.

Use the prototype to challenge the estimate Primary use case Build the smallest working example Edge cases and review Extend it, then have another engineer test Decision review Compare the findings with the estimate The prototype tests assumptions before a larger commitment.
Figure 2. Record what the prototype changes about the proposed build.

Applying This to Your Next Decision

Pull up the last three tools your team discussed building. Score each one using CORE. I'd bet at least one of them scores below 16 and should be bought instead.

The goal isn't to never build. The goal is to build the right things. Every sprint spent building commodity infrastructure is a sprint not spent on your actual product. And in 2026, with AI accelerating the pace of change in vendor tools, the buy option is stronger than it's ever been.

Keep the framework somewhere your team can reference it. Make it part of your RFC template. The 5 minutes spent scoring CORE will save you months of wasted engineering effort.[4]

Frequently asked questions

When does the framework favour buying software?

The article favours buying when the capability is a commodity and suitable vendor options exist. Include integration, migration, training and maintenance in the comparison. A licence price alone leaves out work the team will still need to do.

How should operational complexity affect a build score?

The post’s factor definitions say higher operational burden favours buying. Its corrected formula therefore reverses that input before adding it to the build score. Keep the direction of every factor consistent with the explanation.

Does a high CORE score prove a team should build?

The score records a judgement about the four inputs and applies the article’s proposed weights. It is not a validated prediction of cost or success. Review the assumptions and use the prototype to test the work that is hardest to estimate.

Should a build vs buy decision be revisited?

Revisit the decision when vendor fit, cost, operating burden or business needs change. The article proposes periodic reviews for close calls. Keep the original rationale and the consequences visible so the later comparison has context.

Sources

  1. [1]You Can’t Buy Integration · Gregor Hohpe, martinfowler.com
  2. [2]Package Customization · Martin Fowler
  3. [3]Let’s Architect! Understanding the build versus buy dilemma · AWS Architecture Blog
  4. [4]Documenting Architecture Decisions · Michael Nygard, Cognitect

Checked against these sources on

Related Articles