Buy commodity capabilities, build what differentiates your business, and assemble the seam between them: that pattern resolves most real-world build-vs-buy decisions. Buying wins on speed and lower upfront effort; building wins on customization and long-term control. The right call depends on the capability, not on a company-wide policy, so score each case across cost, fit, risk, and time before deciding.
TL;DR:
- Scoring each capability individually on differentiation, fit, lock-in, cost, and speed helps determine whether to build, buy, or assemble, rather than applying a one-size-fits-all rule.
- Total cost of ownership assessment must include long-term expenses such as integration, migration, training, maintenance, and staff turnover, not just initial license or development costs.
- Building is most justified when the capability is crucial to competitive advantage, highly customized, and the organization has the in-house expertise to maintain it long-term.
- Buying is preferable for commodity functions with low differentiation, where quick time to value and manageable switching costs outweigh customization needs.
- Assembling involves purchasing standard components and building a thin, owned layer on top, emphasizing loose coupling, clear API contracts, data portability, and dedicated ownership to ensure flexibility and minimize risks.
Table of Contents
- A scoring framework for build, buy, or assemble decisions
- Weighing cost, time, customization, control, and security
- Buying commodity layers and building the differentiated seam
- Modeling the true cost and timeline of each path
- Procurement checklist and contract clauses that protect you
- What Thoughtworks, McKinsey, and practitioners actually agree on
- Why most companies get this decision wrong on principle, not on math
- A scoped path forward if you decide to build or assemble
- Where these frameworks come from
- Sources
- FAQ
A scoring framework for build, buy, or assemble decisions
Most teams treat build versus buy as a single company-wide philosophy. That is the first mistake. The decision belongs at the component level: your scheduling system might warrant a buy decision while your pricing engine warrants a build, even inside the same product.
Thoughtworks' strategic framework recommends assessing business value, implementation risk, time to value, and lifecycle ownership for every capability under review, rather than applying one rule across an entire technology stack. That framing translates into a repeatable scorecard you can run in an afternoon.
Score each capability from 1 to 5 on six dimensions:
- Differentiation value: does this capability change how customers perceive your product, or is it invisible plumbing?
- Operational fit: how closely does an off-the-shelf option match your actual workflow without heavy configuration?
- Lock-in risk: how hard would it be to leave this vendor in three years?
- Total cost of ownership: what does the full multi-year cost look like, not just the license line?
- Speed to value: how fast do you need this working, and what does delay cost you?
- Support and compliance burden: who is on call when it breaks, and what regulatory exposure comes with it?
A high score on differentiation value combined with low operational fit points toward build. A low differentiation score with strong operational fit and acceptable lock-in risk points toward buy. When the scores split, some dimensions favoring build and others favoring buy, that split is itself the signal: you likely have an assemble candidate, where a commodity layer gets purchased and a thin, owned layer sits on top to handle the part that actually matters to your business.
-
Build leans right when differentiation is high, fit is poor, and you have the staff to maintain the result.
-
Buy leans right when the capability is a commodity, time to value matters more than customization, and switching costs stay manageable.
-
Assemble leans right when a vendor solves 80% of the problem well and the remaining 20% is exactly what sets you apart.
Run this scorecard per capability, not once for the whole roadmap. A company can reasonably buy its payment processing, build its scheduling logic, and assemble its customer communication stack, all in the same quarter. Thoughtworks frames this as the normal state of a mature technology organization: buy commodity components, build the differentiated layer, and keep the architecture loosely coupled enough that either piece can be replaced without rewriting the other.
Pro Tip: Score your top five capabilities on a shared spreadsheet before any vendor conversation starts. It keeps sales pitches from framing the decision for you.

Weighing cost, time, customization, control, and security
Every build-versus-buy debate eventually collapses into the same five arguments: it costs less, it ships faster, it fits better, we keep control, or it is safer. Each argument is only sometimes true, and the exceptions are where money gets wasted.
Total cost of ownership is the most commonly underestimated line in the entire decision. Buying a platform is not automatically the cheaper path once you account for the whole picture. McKinsey's analysis of core system modernization points out that integration, migration, process redesign, training, and governance can dominate the implementation cost of a purchased platform, often outweighing the license fee itself. Building carries the opposite trap: it looks controllable on paper, but that control evaporates the moment the one engineer who understands the system leaves.
- Buy-side TCO items include license fees, implementation and integration labor, data migration, staff training, and ongoing vendor management.
- Build-side TCO items include design and development labor, infrastructure, ongoing maintenance, security patching, and the opportunity cost of the roadmap items you did not ship instead.
- Shared blind spot: neither path is complete without staffing for the seam between the new capability and everything else you already run.
Timelines are the second place estimates commonly fail. McKinsey's review of property and casualty insurers found that building a large core system in that sector can take 5 to 10 years, while a commercial platform can go live in 3 to 5 years for comparable scope. The gap is sector specific, but the pattern generalizes: the more foundational the system, the wider the spread between build and buy timelines, and the more painful an underestimate becomes.
Customization only justifies a build when configuration genuinely cannot get you there. If a vendor's settings, workflows, and API let you express your actual process, that is a buy or assemble situation even if the fit feels imperfect on day one. Build when the workflow itself is your competitive edge, not when you simply prefer a different button layout.
Vendor lock-in deserves a harder look than most teams give it. A practitioner framework on build versus buy versus assemble suggests modeling the recurring integration and operations tax as a share of license spend, often landing in the 15% to 30% range annually once you account for upgrade work, custom connectors, and workaround maintenance. That is not a one-time cost. It recurs every year you stay on the platform, which is exactly why lock-in risk belongs in the scoring framework rather than as an afterthought.
Statistic: Thoughtworks recommends factoring ongoing support and maintenance into ROI and TCO calculations, including costs the organization or a support partner absorbs after go-live, not just the initial project bill. Skipping that line is the single most common way a build-or-buy business case ages badly.
Security and compliance cut both directions. Buying can offload risk to a vendor with dedicated compliance staff and existing certifications, which is genuinely valuable for capabilities like payment handling or identity management. Building becomes the safer path when your data handling requirements are unusual enough that no vendor's shared responsibility model actually covers your exposure. Neither path removes your obligation to understand where your data lives and who can touch it.
Pro Tip: Ask any vendor for their data export format and API rate limits before signing, not after. Those two answers predict most of your future lock-in pain.
Buying commodity layers and building the differentiated seam
Assemble is not a compromise between build and buy. It is a third strategy: purchase the commodity capability, build a thin owned layer for the part that differentiates your business, and design the connection between them so either piece can change without breaking the other.

Payments, authentication, and document storage are the classic bought layers. Almost no company gains a competitive edge from writing its own payment processor, its own login system, or its own file storage, so buying those and building the workflow logic that sits on top is the default pattern Thoughtworks and Gartner both point toward.
Getting assemble right depends on how you treat the seam between the bought and built pieces:
- Loose coupling keeps the vendor component swappable; avoid embedding vendor-specific logic directly inside your differentiated code.
- Clear API contracts define exactly what data crosses the boundary, so a vendor update does not silently change your inputs.
- Data portability means your own data stays exportable in a usable format, not trapped in a proprietary schema.
- Named integration ownership assigns one team or person to watch the seam, rather than leaving it as everyone's part-time job.
A practitioner framework on assembling build and buy components treats the integration seam as an architectural surface in its own right. The most common failure modes it identifies are unclear ownership of that seam, upgrade breakage when the vendor changes its API, and an integration tax that compounds year over year as workarounds pile up. None of those failures come from picking the wrong vendor. They come from treating the seam as an afterthought instead of a designed piece of the system.
Operationally, that means monitoring vendor release notes on a schedule, running a planned upgrade exercise instead of reacting to breakage after the fact, and giving the seam an actual owner with the authority to push back on scope creep.
Contract terms should protect the assemble strategy before you need them. Push for data export guarantees, a floor on API rate limits so growth does not get throttled, and exit assistance clauses that specify what help you get if you leave. Those three items cost little to negotiate up front and are expensive to add later once you are dependent on the relationship.
Pro Tip: Write down who owns the seam before the vendor contract is signed. An unowned integration is the most common reason assemble projects quietly become build projects nobody planned for.
Modeling the true cost and timeline of each path
A build-versus-buy business case is only as good as its cost model, and most cost models leave out the items that end up mattering most. Building one that survives scrutiny takes a structured pass through both paths before you compare numbers.
- List every cost item for both paths: licenses or subscription fees, integration labor, data migration, staff training, ongoing maintenance, planned upgrades, and the opportunity cost of the team's time either way.
- Build a 1, 3, and 5 year projection for each path, since license costs and maintenance burden rarely move in a straight line; buy costs often step up at renewal, while build costs often spike around major rewrites.
- State your assumptions explicitly: headcount required, contractor rates if you outsource development, expected staff turnover, and vendor price increases. Thoughtworks warns that vendor-supplied ROI models can obscure real costs, so build your own model rather than adopting a vendor's projection wholesale.
- Run a sensitivity test on your two or three riskiest assumptions, such as integration hours or staff attrition, to see how much the conclusion moves if you are off by 20% in either direction.
- Add a contingency buffer to the build estimate specifically, since custom development timelines slip more often and more severely than vendor implementation timelines in most published comparisons.
For staffing estimates, price both an internal hire and a contractor rate for the skills the build path requires, and weight the comparison by how likely you are to retain that talent. A build that depends on one specialist who never gets replaced is not really a five-year plan, it is a one-year plan with four years of risk attached.
Statistic: McKinsey's review of core system modernization in property and casualty insurance found that building a large core system in that sector can take 5 to 10 years, against 3 to 5 years for a comparable commercial platform. That spread alone often outweighs a marginal cost advantage on paper, since a slower build path delays every benefit the new system was supposed to deliver.
Treat the 1, 3, and 5 year template as a living document, not a one-time exercise. Vendor pricing changes, your team's skills change, and the capability's strategic importance can shift as your business grows, so the model that justified a decision two years ago deserves a second look before you renew or commit further.
Procurement checklist and contract clauses that protect you
A strong technical decision can still fail if procurement and contracting are weak. Before any vendor evaluation starts, define acceptance criteria in writing, assemble a cross-functional team that includes engineering and the people who will actually use the system daily, and insist on a pilot with real data rather than a vendor demo alone.
McKinsey's research on software procurement found that procurement teams often lack the engineering knowledge to judge development bids accurately, and that high-performing procurement functions combine technical market knowledge with a centralized, software-literate process. Require any build proposal to state its architecture boundaries, staffing plan, milestones, and acceptance criteria explicitly, so procurement can judge whether the bid is realistic rather than just cheap.
Contract clauses to negotiate before signing anything:
- Data export and portability rights, specifying format and timeline, not just an assurance that export is "available."
- SLA terms matched to criticality, so a system your business depends on hourly carries a stronger guarantee than one you check weekly.
- Exit and transition assistance, defining what help you receive if you leave and how long that help lasts.
- API rate-limit floors, preventing throttling from becoming a growth ceiling.
- Roadmap commitments, at least a general statement of direction so you are not surprised by a sunset announcement.
Once the system is live, ownership does not end at go-live:
- Name a single owner for the vendor relationship and the integration seam.
- Track vendor release notes on a fixed schedule rather than discovering breaking changes in production.
- Re-evaluate the build-versus-buy decision on a set cadence, at minimum annually, since the right answer for a capability can change as your business scales.
Stakeholders worth including from the start are engineering, the operational team who will use the system, finance for the TCO model, and legal for the contract terms. Skipping any one of those groups is a common reason procurement decisions get revisited within a year.
What Thoughtworks, McKinsey, and practitioners actually agree on
Strip away the branding and the major frameworks converge on the same core idea. Thoughtworks' strategic framework argues that buying gets you proven capability faster with less customization, while building gets you control at a higher and ongoing cost, and that the right call depends on business value, implementation risk, time to value, and who owns the system over its lifecycle. McKinsey's sector work echoes the same tension with harder numbers: core system rebuilds in insurance can run twice as long as comparable commercial implementations, and over-customizing a purchased platform tends to erode the speed advantage that justified buying it in the first place.
Practitioner accounts fill in the failure modes the frameworks describe abstractly. A recurring pattern from build, buy, and assemble analyses includes:
- Integration tax: the ongoing cost of connecting a bought system to everything else, which compounds if the seam has no clear owner.
- Customizations that block upgrades: heavy configuration on a vendor platform that makes every future update a project of its own.
- Staff attrition on built systems: knowledge walking out the door with the one person who understood the custom code.
The assemble approach should treat the integration seam as an architectural surface, with clear ownership, upgrade playbooks, and contractual guarantees for data portability and API stability.
That framing is close to how a firm like Equinox Strategies LLC approaches its own scoped builds: every project is documented with least-privilege access, written data maps, explicit consent flows, and a rollback plan, delivered by a single accountable technical lead rather than a rotating cast of contractors. That kind of documentation discipline is exactly what closes the gap between a framework on paper and a system that survives contact with a real vendor upgrade three years from now.
Why most companies get this decision wrong on principle, not on math
The build-versus-buy debate rarely fails because someone ran the numbers badly. It fails because companies pick a philosophy first, engineering-led shops default to building everything, and finance-led shops default to buying everything, and then reverse-engineer justification for capabilities that never fit that default.
The fix is not a smarter one-time decision. It is a policy: score every capability on its own terms, revisit that score on a schedule, and treat "we always build" or "we always buy" as a warning sign rather than a strategy. A capability that made sense to buy at ten employees can make sense to build at two hundred, and pretending otherwise just because a policy says so wastes money in both directions.
Small pilots do more to reveal the truth than any amount of committee debate. A two-week proof with real data on the vendor's platform, or a scoped prototype of the "build" option, surfaces integration and fit problems that no amount of documentation review will catch. Leaders who insist on a cheap, fast pilot before committing tend to make fewer expensive mistakes than leaders who trust a polished vendor pitch or an optimistic engineering estimate.
— Felix
A scoped path forward if you decide to build or assemble
If your scoring framework points toward build or assemble, the harder part starts after the decision: finding a partner who scopes the work honestly and documents it well enough that you are not locked into their memory of the project. A firm with a scoped, security-first approach can work with service businesses on that seam, building custom lead generation systems, AI voice agents, and automations, and stepping in with tailored software when an off-the-shelf platform genuinely cannot meet the operational need.

Engagements can start with a defined scope and a single accountable technical lead, not a rotating team, so decision ownership remains clear. Projects often include least-privilege access controls, written data maps, and rollback plans as standard practice, which matters most on assemble-style projects.
- Scoped builds: custom software written from your specific brief when standard platforms fall short.
- AI voice and messaging agents: automated inquiry handling and follow-up so no lead goes unanswered.
- Done-for-you automations: integrated workflows connecting your existing tools instead of replacing them wholesale.
| What you get | Why it matters for build vs buy |
|---|---|
| Defined project scope and documentation | Avoids the ambiguity that turns build projects into open-ended cost overruns |
| Single accountable technical lead | Prevents the knowledge loss that hits custom-built systems when staff turns over |
| Security-first design with rollback plans | Reduces operational risk on the assemble path where a seam failure can cascade |
If your next step is a build, an assemble project, or you are still not sure which capability warrants which path, a discovery call with Equinox Strategies is the place to get a scoped answer instead of a generic pitch.
Where these frameworks come from
- Thoughtworks: Build versus buy, a strategic framework for evaluating third-party solutions
- Thoughtworks: Enterprises must embrace both build and buy in software development
- McKinsey: How P&C insurers can successfully modernize core systems
- Practitioner framework: Build vs. buy vs. assemble
- Gartner: Build vs buy strategy guidance
- Betlog: evidence-based decision tracking
Sources
- Build versus buy: A strategic framework for evaluating third-party solutions
- Enterprises must embrace both build and buy in software development
- How P&C insurers can successfully modernize core systems
- Build vs. buy vs. assemble
FAQ
What is the difference between build, buy, and assemble?
Buy means purchasing a ready-made platform for a capability, build means writing custom software for it, and assemble means buying a commodity component and building a thin, owned layer on top for the part that differentiates your business. Thoughtworks frames assemble as the common real-world pattern rather than an edge case.
When should a business build custom software instead of buying it?
Build makes sense when the capability is central to your competitive advantage and no vendor's configuration options can express your actual workflow. Thoughtworks' framework recommends weighing business value, implementation risk, time to value, and lifecycle ownership before committing, since building carries higher ongoing cost and effort than buying.
How long does it typically take to build versus buy a system?
Timelines vary widely by industry and system scope. In property and casualty insurance, McKinsey found that building a large core system can take 5 to 10 years, while a commercial platform can be implemented in 3 to 5 years for comparable scope.
What is vendor lock-in and how do you reduce the risk?
Vendor lock-in happens when switching away from a platform becomes costly or difficult due to data formats, integrations, or contract terms. You reduce it by negotiating data export rights, API rate-limit floors, and exit assistance clauses before signing, and by designing your integrations with loose coupling so the vendor component stays replaceable.
Does Equinox Strategies help with build or assemble projects?
Yes, Equinox Strategies LLC builds custom software from client briefs and designs done-for-you automations for US service businesses, using a scoped, security-first approach with a single accountable technical lead on each project. Pricing for these engagements is available on request through a discovery call.
