Skip to content
HublinkTech
AI & Engineeringby Babak Abedi

Build or Buy AI: How to Decide

Every company is choosing between building AI features and buying them. The decision rests on three questions, and the cost that gets underestimated is maintenance.

Build or Buy AI: How to Decide

A company decides it needs AI in its operations. The next question is whether to build it, buy it from a vendor, or wait for the software it already uses to add it.

The question is usually framed as a cost comparison, and framed that way it produces the wrong answer, because the costs that dominate the decision are not the ones that appear in the first estimate. Building is cheaper to start than most people expect and considerably more expensive to keep running. Buying is faster than it looks and constrains more than it appears to.

Three questions settle most cases.

Question one: is this how your company competes?

The first and most important question has nothing to do with technology.

Some processes are how a company wins. A specialist distributor's supplier evaluation method, a clinic's patient scheduling logic, a manufacturer's quality judgement — these encode knowledge accumulated over years, and they are the reason customers choose that company over a competitor.

Other processes are necessary and undifferentiated. Payroll, expense approval, document storage, meeting transcription. Doing them better than competitors wins nothing, because customers never see them.

Build where the process is how you compete. Buy where it is not.

This sounds obvious and is routinely got backwards, because the undifferentiated processes are the easiest to build — the requirements are clear, the scope is contained, the demo is quick. Companies end up building their own expense tool while buying a generic system for the thing that actually distinguishes them, and then wondering why the AI feels generic.

A useful test: if a competitor ran exactly this process exactly as well as you do, would you lose anything? If no, buy it.

Question two: can a vendor reach your data and your rules?

The second question is practical, and it determines whether a bought solution will work at all.

Reach. An AI feature is only as good as what it can see. A vendor product that integrates with your CRM but not with the internal system where half the relevant information lives will produce answers that are confidently incomplete. Before evaluating a vendor, list the systems that hold the data the feature needs, and check each against what the vendor actually connects to — not what the sales material implies.

Rules. Every company has conventions that are not written down anywhere: how a deal stage is really defined, what the approval threshold is in practice, which exceptions are routine. Generic AI features have the data and not the rules, which is why they feel competent and shallow. A vendor product that allows this context to be configured can be adapted. One that does not will produce output that is technically correct and operationally wrong.

Jurisdiction. If the feature processes personal data, where the vendor processes it is a constraint rather than a preference. This narrows the field faster than any other criterion, and it is better discovered during evaluation than during a security review after a contract is signed.

Question three: can you maintain it?

This is the question that decides whether a build succeeds, and it is the one most often answered optimistically.

Building a working AI feature is not difficult. A competent engineer can connect a model to a data source and produce something useful within weeks. The difficulty is everything after that.

The model underneath you changes. Providers update models, deprecate versions and change behaviour. A system tuned around one model's characteristics will behave differently after an update that you did not initiate and cannot decline indefinitely.

The data changes. New fields, new document formats, a changed process, a new market in a new language. Each shifts the input distribution away from whatever the system was built against.

The questions change. Users learn what the feature does and start asking harder things. A system tuned for last quarter's questions degrades against this quarter's without anyone changing a line of code.

Evaluation has to run continuously. Detecting any of the above requires an evaluation set and the discipline to run it on every change. Without that, degradation is discovered through complaints.

So the real question is not whether you can build it. It is whether you will still be maintaining it in two years, with someone responsible for it, when it is no longer the interesting new project. Companies that build successfully assign ownership before they start. Companies that build unsuccessfully assign it afterwards, to whoever is available.

The cost comparison, done honestly

Building costs engineering time to construct, ongoing inference costs that scale with use, and continuous maintenance. The first is estimated well, the second adequately, and the third rarely — maintenance is frequently larger than the original build over a two-year horizon, and it is a recurring commitment rather than a project.

Buying costs a subscription that scales with seats or usage, integration work that is usually underestimated, and a switching cost that grows the longer the product is embedded. The subscription is the visible number and often the smaller part.

Waiting for your existing vendor to add it costs nothing immediately and carries its own risk: the feature may not arrive, may arrive in a form that does not fit, or may arrive priced as a separate tier. Waiting is a legitimate choice when the process is undifferentiated and the current cost of doing it manually is low.

The comparison that matters is over the period the system will actually run, including the maintenance year nobody budgets for.

The middle options

Framing this as build-or-buy obscures two positions that are frequently the right answer.

Buy the platform, build the specifics. Use a vendor product for the general capability and build only the layer that encodes your own rules and connects your own systems. This gets most of the maintenance burden carried by someone else while keeping the part that differentiates you under your control.

Build on what you already have. If your core operational systems are consolidated — the same customer, order and invoice in one system rather than three — a large part of the AI engineering is already done, because the data is in one place under one permission model. The hardest part of most enterprise AI work is reconciling systems that were never designed to be joined. A company that has avoided that problem has a different and much cheaper decision in front of it.

A short decision procedure

  1. Is this how we compete? Yes, lean build. No, lean buy.
  2. Can a vendor reach the data? No, build or change the data situation first.
  3. Can a vendor encode our rules? No, build the rules layer at minimum.
  4. Will we still maintain this in two years, and who owns it? No clear name, buy.
  5. Does jurisdiction constrain where this can run? If so, apply that filter before anything else.
  6. What does it cost over three years, including maintenance? Compare that, not the first-year figure.

If questions one through four give a mixed answer, the middle options above are usually where the decision lands.

Why this is being asked now

Two things changed at once. The capability became broadly available, so building is no longer restricted to companies with research teams. And every software vendor added AI features, so buying is no longer restricted to specialist tools.

That means the decision now arrives for processes where it never used to, and arrives repeatedly rather than once. A company that answers it well for the first feature has a framework for the next ten. A company that answers it by cost comparison alone will build the wrong things and buy the wrong things in roughly equal measure.

How we build

Clavix360, our AI CRM and ERP platform, covers sales, operations, human resources and finance in one system. That matters for this decision specifically: when the data is already consolidated, the integration work that dominates most enterprise AI projects does not arise. Each organisation runs on its own dedicated instance with its own database, which also settles the jurisdiction question per customer rather than once centrally.

Where a client's process is genuinely how they compete, we engineer it rather than configure it — that is the engineering side of what we do, as distinct from the platforms we operate.

Ara is the AI B2B trade engine developed by HublinkTech. It decides whether two descriptions, written in different languages and under different naming conventions and customs codes, refer to the same product or company, and builds trade answers on that decision. It runs inside our own platforms first and is designed to be licensed to other organisations as an API. Ara is in development.

The summary: build what makes you different, buy what makes you functional, and be honest about which of your processes is which.

“evaluation set and the discipline to run it” → /en/blog/evaluating-ai-output-llm-evaluation-methods “reconciling systems that were never designed to be joined” → /en/blog/connecting-ai-to-business-systems-integration “where the vendor processes it” → /en/blog/kvkk-ai-systems-engineering-requirements “the data and not the rules” → /en/blog/ai-crm-erp-data-quality-problem “its own dedicated instance” → /en/blog/single-tenant-vs-multi-tenant-saas-architecture

Share

Want more from HublinkTech?

More writing on the way. In the meantime, see what we build at /services or meet us at /about.

Build or Buy AI: How to Decide — HublinkTech