# Build vs Buy an AI Feature: Model, API or Off-the-Shelf?

Source: https://gravam.com/blog/build-vs-buy-ai-feature
Author: Tan Gravam
Published: 2026-07-29
Reviewed: 2026-07-29
Summary: Build your own model, call a hosted API, or buy an off-the-shelf tool? A solo builder's framework for the AI build-vs-buy call — and when each is the right one.

**The AI build-vs-buy call has three options, not two — build your own model, call a hosted model API, or buy an off-the-shelf tool — and for almost every solo builder the right default is: buy the intelligence, build the product around it.** The mistake I see most is treating "build vs buy" as "train my own model vs use someone else's," when the real decision is where you spend your scarce effort. Here's how I actually make the call.

## The three options

- **Build your own** — train, fine-tune or self-host a model, or write a heavy custom pipeline. Maximum control, maximum ongoing cost.
- **Buy the intelligence, build the product** — call a hosted model API (the Claude/GPT tier) and put your work into the product wrapped around it. This is the default.
- **Buy off-the-shelf** — use a mature tool or SaaS that already does the job. Least effort, least differentiation.

| Option | You spend on | Right when… |
| --- | --- | --- |
| **Build your own model** | Training, infra, ongoing ops | You have a real data moat, cost-at-scale, or a hard latency/privacy/offline need |
| **API + your product** | The product: problem, workflow, decisions | Almost always — the intelligence is a component, not the point |
| **Off-the-shelf tool** | Integration only | The job is a commodity and not your differentiator |

## Why "API + your product" is the default

A hosted model gives you frontier capability for the price of a call. Spending months to train your own to match it is, for nearly everyone, [building a demo of the wrong thing](https://gravam.com/blog/why-most-ai-built-apps-feel-like-demos) — effort poured into a component instead of the product. The product isn't the model; it's the problem you chose, the outcome you defined, and the [human decisions the AI never makes for you](https://gravam.com/blog/how-i-use-ai-without-letting-ai-decide). That's the part no API ships, and the part your users actually pay for.

The failure mode on this side is the thin wrapper: you buy the intelligence and add nothing around it, so you've got a feature anyone can clone. Buying the model is the default _because_ it frees you to build the part that's hard to copy — not as a substitute for building it.

## When to actually build your own

Building your own model is right when you can name the specific reason an API can't serve you:

- **A genuine data advantage** — you have proprietary data that makes a tuned model materially better, and that edge is your product.
- **Cost at real scale** — you're at a volume where per-call pricing genuinely dominates your [unit economics](https://gravam.com/blog/ai-product-unit-economics) and owning the model pays for its own operation.
- **A hard constraint** — latency, privacy, on-prem or offline requirements an external API can't meet.

If you can't state which of these applies, you don't have a reason yet — you have a preference, and it's an expensive one.

## When to just buy off-the-shelf

If the job is a commodity that isn't your differentiator — transcription, generic summarisation, a standard extraction — and a mature tool already does it well, buy it and move on. You build where the intelligence _is_ the product and buy where it's plumbing. Treating everything as build is how a solo project runs out of time before it ships; the discipline is the same [ruthless scope-cutting](https://gravam.com/blog/how-i-scope-an-mvp) the rest of the build needs.

## The honest answer

Build vs buy for AI isn't "my model vs theirs" — it's where your effort earns the most. Default to buying the intelligence and building the product; build your own model only when you can name the moat, cost or constraint that demands it; buy off-the-shelf when the job is plumbing. Get that split right and the AI is a component in a product with a point — which is the whole [operating system](https://gravam.com/blog/my-product-operating-system) this sits inside.

***

_Pressure-test the idea itself with the [AI product idea scorecard](https://gravam.com/tools/ai-product-idea-scorecard)._

## Questions this article answers

**Q: Should I build my own AI model or use an API?**

For almost every solo builder and early product, use a hosted model API and put your effort into the product around it. Training or self-hosting a model is a big, ongoing cost that only pays off with a specific reason — a genuine data advantage, cost at real scale, or hard latency, privacy or offline constraints an API can't meet. Until you can name that reason, building your own model is buying a problem, not a moat.

**Q: When does it make sense to buy an off-the-shelf AI tool instead?**

When the job is a commodity that isn't your differentiator — transcription, generic summarisation, a standard classification — and a mature tool already does it well. Buying there frees your time for the part only you can build. You build when the intelligence IS the product; you buy when it's plumbing.

**Q: What's the default AI build-vs-buy choice?**

Buy the intelligence (a hosted model API), build the product (the judgement, the workflow, the decisions around it). The model is a component; the product is what you wrap around it — the problem you chose, the outcome, and the human decisions the AI never makes for you. Get that split wrong and you either reinvent a model you didn't need or ship a thin wrapper with no point.