← Back to blog

AI Vendor Lock-In: How to Keep Your Product Portable

November 18, 2026
AI Vendor Lock-In: How to Keep Your Product Portable

AI vendor lock-in is the cost, risk and effort of replacing the company that supplies the model or platform your product runs on. The fix is mostly architectural and cheap early: keep your prompts, data, business rules and test cases in code you own, and let the provider do one narrow job, which is generating output. If your product was built inside a hosted AI builder or a single provider's SDK, it is worth finding out where you stand before a customer, an investor or a price change finds out for you.

I am Hanad, a senior software engineer in Vienna. I build the first real version of software products for founders and owner-operated businesses. This guide is written for non-technical founders and business owners, so I explain each term once and skip the vocabulary of enterprise procurement.

Hanad Kubat
Build Software You Can Move
Hanad builds working software in widely known code you own from the first commit, helping keep your product and its core logic portable.
Visit

Key Takeaways

  • Lock-in is not only the model. It also sits in your data, prompts, permissions, workflows and test cases, and those are usually harder to move than the model.
  • Using one provider is not automatically a mistake. It becomes a problem when the provider is the only place where a critical process is defined.
  • The cheapest protection is a thin layer in your own code between your product and the provider, plus your own copy of your data, prompts and evaluation cases.
  • You can test your exposure in a day by moving a half-finished piece of work to a second provider and seeing what breaks.
  • Code you own from the first commit, in a common stack, is the strongest form of portability a small company can have.

Table of Contents

What AI vendor lock-in actually means

You pick an AI provider because it is fast to start with. Your product calls its model, stores conversations in its system, uses its tool format and relies on its quirks. Months later the provider raises prices, retires a model, changes its terms, or a larger customer demands that you use a different vendor. Now you want to switch, and you find that the switch is a project rather than a setting.

That is lock-in: not a contract trap, but accumulated dependence. Each decision was reasonable alone. Together they mean the exit costs more than anyone planned.

For a founder this shows up in three ways:

  • Cost. If your margin depends on one provider's price per request, any price change goes straight to your profit.
  • Reliability. If one provider has an outage or retires a model, your product has the same outage unless you have a fallback.
  • Negotiating position. A buyer who cannot leave pays what the seller asks. A buyer who can leave gets a better conversation.

The 2023 turmoil at OpenAI made this concrete for startups. TechCrunch reported that companies tied tightly to a single provider saw their production systems become brittle, while a company that had built an abstraction layer across several models was far better prepared. An abstraction layer is simply one internal piece of code that your product talks to, which in turn talks to whichever provider you choose.

What gets stuck, beyond the model

Most founders think of lock-in as "we use GPT, so we are stuck with GPT." The model is the easiest part to replace. TechTarget's October 2026 reporting makes the same point: portability extends past the model to context and memory, evaluation sets, identity and permissions, integrations and business logic, and audit and governance records.

Here is that list in plain terms, with what each piece looks like in a small company.

Prompts and output handling

Prompts are the written instructions you give the model. Prompts tuned to one model often behave differently on another. Your code also probably expects the answer in a specific shape, such as a particular JSON structure, and a new provider may format things slightly differently. Models also get retired: providers publish deprecation schedules, and calls to a retired model simply fail.

Data and conversation history

If conversations, uploaded files or user memory live inside the provider's hosted system, you may be able to export the records but not the links between them. Your customers' history is your asset. It should live in your database.

Retrieval setups

Many AI products let the model answer from your own documents. That works through embeddings (numerical fingerprints of text), chunking rules (how documents are cut up) and an index. If the provider built and hosts these, moving means rebuilding them. If you keep the source documents and the scripts that build the index, moving means re-running a script.

Permissions and workflows

Who may see what, and what happens after each step, is often configured inside a platform's visual editor. That is a second rulebook that exists nowhere else. If a hosted builder holds your logic, rewriting it by hand is the migration.

Test cases

How do you know the product still works after a switch? Only with a set of realistic questions and expected-quality checks that you own. Without them, a switch is guesswork. I cover this in more detail in my piece on AI evaluation metrics for production LLMs.

The people side

Your team learns one platform's habits. Switching also means retraining and repeating any safety or security review you already passed. That is real time even when the code change is small.

Why prototypes built in AI app builders hit this hardest

If you built your first version in a hosted builder such as Lovable, Bolt, v0, Replit or Bubble, lock-in tends to stack. The builder hosts the app, the database, the logins and often the AI calls. Every layer is convenient, and every layer is a dependency. This is usually where founders feel the wall: the app breaks under real users, a security review fails, the bill grows, or nobody can extend it.

That does not make the prototype a mistake. It did its job: it proved that people want the thing. The practical question is what the next version should be built on. When I rebuild a prototype, the prototype becomes the specification and the result is ordinary, maintainable code that you own, in a stack the next developer already knows. TypeScript, Next.js, React, Node and SQL are not exciting, and that is the point. Any competent developer can pick them up.

Why prototypes built in AI app builders hit this hardest

When one provider is a reasonable choice

I would be misleading you if I said every founder needs a five-provider setup on day one. You do not. Using a single provider is often the right call early: it is simpler to buy, simpler to secure and simpler to operate.

A useful way to judge it comes from Tian Pan's analysis of lock-in as a spectrum: acceptable dependence has a measurable advantage, a migration cost you have honestly estimated, stable capability, and an abstraction that limits the damage if you leave. The same analysis lists the warning signs:

  • Provider calls scattered through your application code instead of one place.
  • Prompts that were never tested on any other model.
  • Embeddings or chat histories held by the provider with no export.
  • Assumptions about the output format that nobody wrote down.

If none of those apply, you are in good shape. If two or three do, fix them before they are expensive. A helpful rule of thumb: ask whether you would stay with the provider if leaving were free. If yes, you are staying for quality, which is healthy. If you are staying because your data, rules or code are trapped, that is the lock-in to remove.

What switching really costs

Published estimates vary widely, and I would not trust anyone who gives you a single number. What matters is the shape of the work. A switch usually involves rewriting request and response handling, adjusting prompts, rebuilding retrieval, changing how tools are defined, re-running your tests, and accepting different quality, speed and failure behavior. A simple feature that sends text in and gets text back can move in hours. A pipeline with retrieval, tools and multiple steps is a different order of effort, and the more provider-specific pieces it holds, the larger that gets.

There is also a commercial side. Pricing, contract terms or roadmap shifts change your cost structure, and without a way out you have little leverage. If you are weighing plans, my comparison of OpenAI Enterprise versus the API shows how to check costs before committing to a pilot.

What switching really costs

A practical way to reduce lock-in

You do not need to be technical to make these decisions. You need to ask for them, or build them in from the start.

1. Put one thin layer between your product and the provider

Your product should call your own function, something like "generate a summary," and that one function talks to the provider. Then switching providers changes one file, not forty. This is the same idea behind the multi-model approach the TechCrunch piece describes.

2. Let the provider generate, and let your product decide

The model produces text. Your code decides what that text means, whether it may trigger an action, who is allowed to see it and what gets billed. Business rules, permissions and billing logic belong in your code and your database, never inside a prompt or a vendor's editor.

3. Keep your own copy of the things that are yours

Store these in your own database or repository:

  • Conversation history and user memory.
  • Source documents, chunking settings and the scripts that build your search index.
  • Prompt versions, with notes on which model each was written for.
  • Evaluation cases: realistic inputs with the answers you consider good.
  • Usage records: which model answered, how long it took, what it cost, and when it failed.

The last item pays back quickly. When you log provider, model, latency and cost on every call, you can compare providers on your own data instead of on marketing pages.

4. Prefer open formats for workflows and agents

If you use agent or workflow tooling, check that the definitions can be exported in a format other tools can read. Logic that lives only in a vendor's visual editor is the hardest kind to move.

5. Keep a second provider warm

You do not have to run two providers in production. You do need to have run your evaluation cases against a second one at least once, so you know the gap before you need it. Where data cannot leave your own infrastructure, or you want predictable cost at volume, running an open model is another route. I compare the trade-offs in open source versus OpenAI, and teams exploring local AI hardware for running LLMs can see what that setup involves on the machine side.

6. Get portability in writing

If you sign with a platform, make sure data ownership, export rights and notice periods for model retirement are in the agreement, not only in the sales conversation. For the wider checklist, see my guide to running an AI vendor risk assessment.

A one-day exit test you can run

Paper checklists only go so far. InfoWorld describes a one-day exit test for AI agents that works for any AI feature, and I like how concrete it is. The idea: let the system get halfway through a realistic task, export what it says represents the work, and hand only that export to a second provider in a fresh session.

Then watch for four things:

  1. Does the second system repeat work that was already finished?
  2. Does it bring back a decision that was already retired?
  3. How long does a person need to rebuild the missing context?
  4. Which provider-specific files, hooks or credentials broke along the way?

Write down the answers. They are your real switching cost, and they are far more useful than any estimate in a blog post. If the test goes badly, that is useful information, not a failure: it tells you exactly which layer to move into your own code first.

Lock-in in how your business runs

Lock-in is not only a developer's concern. If your staff do daily work through one vendor's AI tool, the knowledge of how the work gets done lives in that tool's configuration. The same applies to AI workflow automation that grows organically around a single provider: nobody decides to depend on it, and then everyone does. For owner-operated businesses I give the same advice as for software: write down the process in plain language, keep the rules in a place you control, and treat the provider as replaceable.

Perspective: build the first version so you can leave

I see the same pattern again and again. A founder builds quickly in a hosted tool, the idea works, and then the product meets real users. The platform's limits, the monthly bill or a security review turns a good prototype into a risk. At that point lock-in is no longer a theory. It is the reason the next step costs more than it should.

My answer is plain. I build the first real version as ordinary code in a common stack, so the next developer can read it and you can take it anywhere. You own the code from the first commit. AI providers sit behind one thin layer, your data and rules live in your own database, and the evaluation cases are yours. I do the work end to end myself, at a fixed price and a fixed scope, usually in two to four weeks, so there is no agency overhead to pay for.

Portability is not a feature you add later. It is a set of small decisions in the first weeks. Made then, they cost almost nothing. Made after launch, they cost a rebuild.

 

Hanad Kubat

If you are deciding what to build next

If your prototype has stalled, or you are planning a first real version that includes AI, the decisions above belong in the build from the start. I build products like this from €12,000, at a fixed price agreed upfront, working end to end myself. You see working progress before you pay, and the code is yours from the first commit. If an off-the-shelf tool would serve you better, I will tell you that honestly. You can see what I build and get in touch on my site. For a view of how I work with technical leaders, see my guide to fixed-price MVPs and AI for DACH CTOs.

FAQ

What does AI vendor lock-in mean?

It means switching your AI provider has become expensive, risky or impractical because your product depends on that provider's models, data formats, tools or hosted features. It is broader than the model: prompts, stored conversations, retrieval setups, permissions and workflows can all be stuck. The earlier you separate them from the provider, the cheaper leaving stays.

Is using one AI provider always a mistake?

No. A single provider can be sensible early on because it simplifies buying, security and operations. The risk appears when it is the only place where a critical process or your customer data lives. Keep an exit path for those, and the single provider becomes a choice rather than a trap.

How do I know if my prototype is locked in?

Ask three questions. Can you export all your data, including the links between records? Do your business rules and permissions exist in code or documents you control? Have your key prompts ever been tested on a second model? Two or more "no" answers mean it is worth fixing before you scale.

Can I fix lock-in after launch?

Yes, though it is cheaper before launch. The usual order is to add the thin layer around the provider first, then move data and rules into your own database, then build your evaluation cases. A rebuild into portable code is the cleanest route when the hosted platform holds the logic.

Hanad Kubat
Discuss Your Product’s Portability
Email Hanad about your product and its current constraints to discuss building a working version in code you own.

Sources