In traditional enterprise software procurement, the build-vs-buy decision follows a fairly stable framework. Buy when the capability is commodity (does every company need this? is it core to your competitive differentiation? no, and no), build when the capability is proprietary (does this encode unique business logic or competitive advantage? do you need control over the roadmap?). Customize where the buy-build boundary creates gaps that neither fully covers.

This framework was imperfect but useful. It provided a vocabulary for discussing options and a set of criteria for choosing between them that most technology leaders could navigate.

AI has broken it in several specific ways, and the enterprises that are making the worst decisions are those applying the old framework to the new context — buying generic AI platforms for genuinely differentiated needs, or building from the foundation layer up for problems that have been commoditized.

How the Framework Broke

The first break is the emergence of a new layer — the foundation model — that did not exist in previous software eras. In traditional software, “build” meant writing code against standard libraries and APIs. In AI, “build” now has at least three distinct levels: building foundation models (which only a handful of companies in the world can do economically), fine-tuning or adapting foundation models (accessible to companies with ML engineering capability), and building applications on top of foundation models via API (accessible to any company with a software engineering team).

Most enterprise discussions conflate these three levels, which produces confused decision-making. A pharmaceutical company deciding whether to “build or buy” AI for drug discovery needs to distinguish between: building or fine-tuning the underlying models (requires specialized ML research capability, potentially worth it for genuine scientific differentiation), building the application layer on top of existing models (potentially worth it if the workflow integration requirements are highly specific), and buying an end-to-end application from a vendor (appropriate if a vendor has solved the domain-specific challenges the company would have to solve themselves).

The second break is the volatility of the competitive landscape. In traditional enterprise software, buying a market-leading product usually provided five to ten years of useful life before a significant reinvestment decision. AI capabilities are moving fast enough that a system architected in 2023 may need substantial redesign by 2026 — not because it failed, but because the models it was built on have been superseded by capabilities that change the feasibility of the entire approach.

This changes the economics of buying versus building. Buying a proprietary AI system locks you to a vendor’s roadmap in a context where that vendor’s relevance could shift dramatically in eighteen months. Building on open-source or API-accessible models gives you flexibility but requires internal capability to manage the model layer actively over time.

The third break is the data flywheel problem. In some AI applications — particularly recommendation systems, personalization, and domain-specific classification — the quality of the AI improves in direct proportion to the quality and volume of the proprietary data you feed it. This means that buying a generic vendor product may permanently limit the AI’s potential quality ceiling if the vendor cannot learn from your proprietary data in a way that feeds back into your specific deployment.

What Most Enterprises Get Wrong

The most common mistake in enterprise AI build-vs-buy decisions is treating the application vendor layer as equivalent to building, when the relevant distinction is between commodity capability and proprietary capability at the right layer.

Consider an e-commerce company evaluating AI for product recommendations. The default framing is: should we build a recommendation engine or buy one? But the recommendation logic itself — collaborative filtering, content-based filtering, hybrid approaches — is not proprietary. The models for doing it are well-understood and widely available. What is proprietary is the company’s customer behavior data, its catalog data, and the specific constraints of its business (margin requirements, inventory availability, promotional priorities) that should shape recommendation outputs.

The right answer in this case is: buy the commodity infrastructure (vector databases, model serving, ML observability) and build the application layer that encodes your specific business logic and connects your proprietary data. Buying an end-to-end recommendation platform from a vendor means giving up control over how your proprietary data shapes the model — often at the most critical layer.

The mirror mistake is building at layers where the commodity market has genuinely commoditized the problem. The 2023-2024 wave saw many enterprises attempting to fine-tune or train their own language models for customer service and document processing — cases where the general capability of foundation models via API would have been more than adequate. The internal model training programs consumed engineering capacity, infrastructure budget, and organizational attention that could have been deployed against the actual differentiated problems.

The Right Framework for AI

The decision framework that works for AI has three questions, applied in sequence.

First: is this problem genuinely proprietary, or is it a commodity problem with proprietary data? If the problem domain is generic (text summarization, classification, entity extraction, Q&A) and the differentiation is in the data, then build the data infrastructure and buy the AI capability. If the problem requires specialized reasoning that generic models do not handle (novel scientific domains, proprietary business logic with complex constraints, performance requirements that exceed generic API capabilities), then evaluate building or fine-tuning at the model layer.

Second: what is the cost of being wrong? AI capabilities are moving fast enough that the architectural decisions you make today may not be the right ones in three years. The appropriate response to this uncertainty is not to defer decisions but to favor reversible decisions at each layer. Deploying on a multi-model architecture that can swap underlying models is more reversible than building deeply coupled to one provider. Using open-source model formats preserves optionality in ways that proprietary model fine-tuning does not.

Third: what are your actual operational capabilities? This question is asked less often than it should be. The build-vs-buy analysis typically evaluates the capabilities required and the market options, but underweights whether the organization has the people to operate what it builds. An AI system built by a consulting team or a short-term external engineering team, without a durable internal capability to maintain and improve it, is not really “built” — it is bought in a more expensive and less flexible way.

The Hybrid Architectures That Work

In practice, the most successful enterprise AI architectures are hybrid in a specific way: they buy at the commodity infrastructure layers (vector databases, model APIs, ML ops tooling), buy or adapt at the model capability layer for generic tasks, and build at the application layer where domain-specific business logic and proprietary data integration create genuine differentiation.

This architecture keeps the components that move fast (models, embeddings, inference infrastructure) on vendor roadmaps, while keeping the components that encode institutional knowledge (workflow integrations, business logic, evaluation criteria, data pipelines) under internal control.

The worst architecture — and it is depressingly common — is the reverse: expensive internal investment in model infrastructure that is irrelevant in three years, while buying end-to-end application vendors whose locked-in data structures prevent the company from capturing the value of its proprietary data.

The build-vs-buy decision in enterprise AI is not a binary. It is a set of distinct decisions at distinct layers, each with different competitive dynamics, different reversibility characteristics, and different organizational capability requirements. Companies that treat it as a single decision are making their choices by accident.

Get the best articles from Think Different

One email a week with practical Mac workflows, useful comparisons and honest tech recommendations.