BlogProduct engineering

Build vs buy for AI: a decision framework

For AI the choice is rarely build or buy. There are three options: buy a finished product, assemble your own system from model APIs and platforms, or build custom. Buy what every company needs, assemble where your data and workflow are specific to you, and build custom only where the capability is what customers pay you for or a hard constraint leaves no alternative.

Three options, not two

Buy. A product with the AI already inside: a support desk with an AI agent, a meeting-notes tool, a coding assistant, a contract review service. You configure it. You do not see the prompts and you rarely choose the model.

Assemble. You rent the models through an API and the infrastructure from a cloud, and you own the layer above: the prompts, the tools and integrations, retrieval over your own data, the evaluation set, the rules about what the system may do. Agent frameworks, managed vector stores and observability platforms are bought parts. The system is yours.

Build custom. You train or fine-tune models, run your own inference, or build core components the platforms do not offer. This is for capability that is your product, or for constraints the platforms cannot meet: inference on a device, data that cannot leave a site, response times a network call cannot give you.

Nobody reading this trains a frontier model, so “build” never means that. And most projects that get called custom builds are really assembly. The distinction matters because assembly is far cheaper than people fear when they hear “build”, and far more controllable than they expect when they hear “buy”.

Which criteria decide it?

Seven, in the order we ask them.

How core is it to your business?

If the capability is why customers choose you, owning it is worth a great deal. You will want to improve it faster than a vendor’s roadmap allows, and you will not want a competitor to be able to buy the same thing. If it is something every company does, such as expense reports, meeting notes or first-line IT help, a product will be better than what you would build, and you will never out-invest its vendor.

How unusual are your data and workflow?

Products are built for the typical customer. If your documents, terminology and process look like everyone else’s, that suits you. If your value sits in a pricing rule-set nobody else has, a catalogue of 200,000 parts with its own naming, or a process that crosses five internal systems, a product will cover the easy part and leave the part that matters.

How deep is the integration?

A tool that sits beside the work (summarise this call) integrates through a browser tab. An agent that acts inside the work (change this order, issue this credit) needs write access to your systems, your permission model and your approval rules. The deeper it goes, the more the integration is the project and the less a product’s connectors will cover.

Open standards help here. The Model Context Protocol gives applications a standard way to connect models to tools and data, so an integration written once can serve more than one model or client. That lowers the cost of assembling, and of changing your mind.

How much control do you need over evals and behaviour?

With a product you can usually test outcomes but change little. With an assembled system you can run your own test set on every change, read every prompt and decide exactly what happens to a doubtful case. If a wrong answer is cheap, control matters little. If it reaches a customer, a patient or a ledger, you need to be able to test and change the behaviour yourself.

Regulation adds a twist. Under the EU AI Act, a company that puts its own name on a high-risk AI system, or substantially modifies one, is treated as its provider and takes on the provider’s obligations. Know which role you are in before you white-label anything, and take legal advice if the system is anywhere near a high-risk use.

How much lock-in can you accept?

Lock-in exists at every level. Products hold your configuration and history. Platforms hold your orchestration. The models themselves are temporary: Anthropic’s deprecations page commits to at least 60 days’ notice before a model is retired, and OpenAI’s equivalent page states at least six months for generally available models. If you assemble, you manage those migrations. If you buy, the vendor changes models underneath you and may not tell you.

The portable assets are the same in every case: your data, your evaluation set and your written-down knowledge of the process. Own those whichever option you choose.

What is the total cost over three years?

Compare over three years, not one.

Buying means licence fees, often per seat or per resolved case, that grow with use, plus configuration and the internal time spent managing the vendor. Assembling means build cost up front, then tokens, infrastructure, review time and maintenance. Building custom adds ML engineering, training runs and serving on top. Our article on what an AI agent really costs breaks down the assemble column line by line.

A product is nearly always cheapest in year one. Whether it still is in year three depends on volume.

Can your team run it?

Something you assemble needs an owner: a person who watches quality, runs the evals when a model changes and gets the call when it misbehaves. If you have no engineers who can do that and no partner who will, buy. The alternative is an assembled system that slowly decays.

A decision table

Criterion Points to buy Points to assemble Points to build custom
How core A supporting function Important to how you operate The thing you sell
Data and workflow Like most companies’ Specific to you, in text and standard formats Unusual data types, or a domain where general models are weak
Integration depth Beside the work, read-only Inside the work, writes to your systems Embedded in a product or device
Control over behaviour Vendor defaults are acceptable You need your own evals and rules You need control of the model itself
Lock-in tolerance High, and exit is cheap Medium: you own the layer above Low: you own nearly everything
Three-year cost Low or unpredictable volume Volume high enough for usage fees to overtake build cost Scale or constraints make owning the model cheaper
Team Nobody to own it A small team or a partner An ML team you intend to keep

Read the table by counting columns, then by weight. If most rows land in one column, that is your answer. If “how core” lands on the right and everything else on the left, the honest reading is usually to assemble now and revisit later.

Three scenarios

A 60-person accountancy firm wants meeting notes, email drafting and search across client files. None of it is what clients pay for, the data is ordinary documents, and nobody on staff would maintain a system. Buy. Spend the effort on choosing well: test two products on your own files, read the data terms, check the export.

A freight forwarder wants an agent to handle shipment exception emails: read the message, look up the consignment in the transport system, check the carrier’s portal, propose a reply and update the record. The workflow crosses three internal systems, the exceptions are specific to its lanes and customers, and a wrong update has consequences. No product knows its systems. Assemble: hosted models, its own tools and approval rules, and a test set built from last quarter’s emails. This is the pattern behind most AI agent projects.

A maker of industrial sensors wants defect detection running on the device, on a production line with no reliable network, and intends to sell it as a feature. The capability is the product, the data is its own images and the constraint is hard. Build custom: a small vision model trained on its data and optimised for its hardware, which is edge AI work. Even here, buy the labelling tool and the experiment tracker.

What goes wrong?

Five mistakes account for most of the regret we hear about.

Buying, then finding there is no way to test. If a vendor will not let you run your own cases before you sign, you are buying a demo.

Building the commodity. A home-made meeting summariser is a hobby with a maintenance bill.

Treating a pilot licence as the decision. Six months into a trial nobody measured, the product is embedded and nobody chose it.

Forgetting the exit. Ask how you get your data and configuration out on the day you sign, not the day you leave.

Assuming a build ends at launch. Models are retired, inputs drift and somebody has to own the result.

When you do buy, put these questions to the vendor:

  1. Can we run our own test cases during the trial and see the results case by case?
  2. Which models does the product use, and how are we told when they change?
  3. Is our data used to train anything, where is it processed and how long is it kept?
  4. Can we export our data, configuration and conversation history in a usable format?
  5. What does the audit log record, and can we pull it into our own systems?
  6. What is the price at ten times our current volume?
  7. What happens to our data when we leave?

A vendor who answers all seven without a follow-up meeting has been asked before. That is a good sign.

Can you change your mind later?

Yes, if you kept the portable assets.

A common and sensible path is to buy first, to learn what users actually need, keep a record of where the product falls short, and assemble only the part where it does. The reverse happens too: a team assembles something, the market catches up and a product replaces it. Neither is a failure.

Set a review date when you decide. Twelve months is reasonable. Look at the same seven criteria again with a year of usage data in front of you.

How to start

This week, write one paragraph that says what the capability is, who uses it and what a wrong answer costs. Score the seven criteria with the people who own the process and the systems. Disagreements about the scores are worth more than the scores.

If the answer is buy, shortlist two products and collect 50 real cases to test them with. If it is assemble or build, test the riskiest assumption first with a short proof of concept before committing a budget. Helping teams make this call, and building the assembled option when it is the right one, is part of our AI strategy and product engineering work.

Questions

Asked often.

Should we build or buy AI software?

Buy when the capability is common to most companies and a product already does it well. Assemble your own from model APIs and platforms when your data, workflow or integrations are specific to you. Build custom models or infrastructure only when the capability is what customers pay you for, or a constraint such as on-device use forces it.

What does assembling an AI system mean?

It means renting the models and the infrastructure and owning the layer above them: the prompts, the tools and integrations, the retrieval over your data, the evaluation set and the rules about what the system may do. Most projects described as custom AI builds are really this, and it is usually the right middle path.

How do we avoid lock-in with AI vendors?

Keep the assets that are hard to recreate in your own hands: your data, your evaluation set, your prompts and your integration code. Put a thin layer between your application and the model API so that models can be swapped and re-tested. With products, check that you can export data and configuration before you sign.

Is it cheaper to build AI in-house than to buy?

Rarely in the first year, because a build carries integration, evaluation and hardening costs up front. Over three years the answer depends on volume and on the pricing model: per-seat or per-resolution fees grow with use, while a system you own costs mostly engineering time and tokens. Model both before deciding.

Not on the list? Ask us directly

Keep reading

More notes from the build.

All blogs

Let’s build your stack.

Send a brief and we’ll reply with next steps.