How to Avoid Vendor Lock-In in Custom Software and Cloud
Vendor lock-in is a spectrum of switching costs. Learn where it forms in software and cloud, how to measure it, and how architecture and contracts keep exit options open.

Vendor lock-in is avoided by treating it as a measurable spectrum of switching costs rather than a yes-or-no condition: the dependency is identified before a commitment is signed, the architecture is built on open standards and portable data, the contract limits term and exit fees, and an exit plan is tested while the relationship is still healthy. Organisations that take these decisions at design time, with the engineers who will build and maintain the system, pay a fraction of what a forced migration costs later.
TL;DR
- Lock-in is a matter of degree: every technology choice carries a switching cost, and the task is to keep that cost small enough to be acceptable.
- The EU’s 2018 study on cloud switching put portability costs between €18,800 and €231,400 across three use cases, which shows how quickly the bill grows with complexity.
- Open formats, standard interfaces, containers and a thin abstraction layer around proprietary services reduce dependency at the architectural level.
- Short contract terms, checked portability fees and an exit plan tested at least annually reduce it at the commercial level.
- Some lock-in is a rational trade for speed, provided it is chosen deliberately and documented.
Table of Contents
- What vendor lock-in actually is
- Where dependency concentrates
- Putting a number on switching cost
- Architecture that keeps options open
- Contracts and procurement
- An exit plan that is actually tested
- When some lock-in is the right choice
- Putting this into practice with Vicedomini Softworks
- FAQ
- Sources
What vendor lock-in actually is
Vendor lock-in rarely takes the form of an explicit prohibition on leaving. AWS’s own guidance on the subject describes it as switching costs high enough to make a move prohibitively difficult or risky, with those costs counted in time, flexibility, functionality and sometimes money: changing technology stacks, migrating data, retraining staff. The mechanism is therefore economic and technical rather than contractual, which is why it tends to be noticed only when a supplier raises prices, withdraws a product or fails to keep pace with requirements.
Cloudflare’s explanation of the concept lists the practical consequences: being tied to a service in decline, product changes that no longer fit the organisation’s needs, a supplier leaving the market, and steep price increases imposed on customers who cannot easily leave. Each of these converts a technical dependency into a negotiating weakness.
A useful corrective comes from Richard Seroter’s analysis for InfoQ, which argues that everything is lock-in to some degree: choosing Java rather than Node.js, for example, creates switching costs of its own, and commitment discounts or early termination fees add financial ones. The operative question is therefore not whether dependency exists but whether the cost of reversing it is large or small, and whether the organisation chose it knowingly.

Where dependency concentrates
Not every layer of a software estate binds equally. An academic framework from Bournemouth University found that lock-in risk rises with the number of components a single vendor supplies, and that SaaS carries the highest risk because the vendor controls every key component, while the data may sit in proprietary formats tied to proprietary application logic. The World Bank’s report on cloud and data infrastructure markets reaches a compatible conclusion: risk is lower with infrastructure as a service than with platform or software as a service, and migrating between providers is complex, slow and costly, partly because of egress charges for moving data out.
The security profession adds a further concept. ISC2 describes data gravity: as data accumulates in one warehouse or with one cloud provider, it becomes progressively more complicated and expensive to move, and reliance on a single provider can limit security options and expose the organisation to that provider’s supply-chain vulnerabilities.
In practice the dependencies that matter fall into a handful of layers, summarised below.
| Layer | How dependency forms | Typical way to keep it manageable |
|---|---|---|
| Data | Proprietary schemas and export formats, egress fees, data gravity | Open, machine-readable formats; documented export routes; periodic test exports |
| Application logic | Business rules written in a vendor’s proprietary language or low-level services | Standard languages and frameworks; business logic kept outside vendor-specific services |
| Infrastructure | Managed services with no equivalent elsewhere | Containers and Kubernetes; abstraction around the few proprietary services that are retained |
| Integration | Point-to-point connections built on vendor-specific APIs | Standard REST or GraphQL interfaces and message-driven integration with a documented contract |
| Commercial | Long terms, volume commitments, termination fees | Short terms with limited renewals; portability fees agreed before signing |
| People | Skills and processes built around a single tool | Documentation, shared ownership of architecture decisions, code the organisation owns |
The newest layer is AI. Usage-based pricing for model inference can bind an organisation to a provider’s rate card and interface in the same way storage once did, and some markets now allow buyers to reserve AI inference capacity under flexible contract durations through an OpenAI-compatible interface, which is a reminder that standard interfaces and flexible terms are the same levers in a new setting.
Putting a number on switching cost
Abstract risk does not move budgets; a figure does. The European Commission’s study on switching cloud services providers, published in 2018, analysed three anonymised use cases and found portability costs of about €18,800 for a simple data-portability case, €119,400 for a medium-complex case and €231,400 for a highly complex one. These sums excluded termination costs such as downtime and running two environments in parallel, and they equalled 125%, 100% and 40% of annual subscription cost respectively. The proportions fall as complexity rises only because the subscriptions in the complex cases were far larger; the absolute migration bill climbs steeply.

A pre-commitment assessment does not need to be elaborate. The NHS Architecture Manual’s requirement on vendor lock-in, T03, asks teams to identify where supplier-specific technologies and platforms are used, to document the commercial, technical, operational and migration risks, to consider alternative products and architectures, to define mitigations, and, where lock-in is accepted, to record the rationale and support it through governance. That sequence translates readily to any organisation, public or private.
A peer-reviewed study in the Journal of Cloud Computing supports the emphasis on timing. Its authors found that integration and incompatibility problems, followed by data portability, were the main lock-in challenges, that 66.4% of business respondents named well-informed decisions before selecting vendors or signing contracts as the leading mitigation, and that 39.3% cited standard software components with industry-proven interfaces. In other words, the decision that matters most is taken before the first line of code or the first signature.
Four questions make a workable assessment before any commitment:
- How much of daily operation would stop if this supplier changed terms or disappeared?
- Can all data be exported in an open, documented format, and at what fee?
- Do the interfaces follow open standards, or only the supplier’s own?
- What would a switch cost in three to five years, in money and in months of effort?
Architecture that keeps options open
The architectural defence rests on a simple principle: use proprietary capability where it earns its place, and isolate it so that it can be replaced without rewriting the business logic around it.
Open standards and portable data
The CERRE report on the regulation of cloud computing, published in February 2024, concludes that data-induced switching costs, technical incompatibility and egress fees can together amount to significant lock-in. It recommends that portable data be offered by default in a structured, commonly used, open and machine-readable format, citing Article 30(5) of the EU Data Act as a suitable model. The same report presents interoperability not as an end in itself but as a means of lowering the switching costs that arise from technical incompatibility, a framing that suits software owners well: standards are adopted where they reduce a real cost, not as dogma.
For an organisation commissioning software, the implication is concrete. The data model should be documented and owned by the client, interfaces should be specified through REST or GraphQL contracts that any consumer can implement, and integration between systems should rely on message-driven patterns with explicit schemas rather than on private connectors.
Containers, Kubernetes and abstraction
Containerisation and Kubernetes orchestration are the best-evidenced route to workload portability. A University of Twente master’s thesis comparing integration platforms found Kubernetes satisfied 11 of 13 portability requirements, and a case applying its target architecture showed a 28% overall cost decrease. A separate five-year total-cost-of-ownership study, published by QIT Press, proposes open interoperability layers, Apache Iceberg for table formats and Kubernetes for workloads, and estimates that they can reduce five-year cost by roughly 18% to 27% against single-vendor designs, at a possible 8% to 12% penalty in raw processing throughput. Both are modelled or case-based results rather than guarantees, and the throughput figure is a reminder that portability is an engineering trade-off to be sized, not a free gain.
The Dutch central bank reaches the same direction from a supervisory standpoint: financial institutions are adopting open standards and containerisation to improve workload portability, precisely because full multi-sourcing so often proves too expensive and too complex. That observation is instructive. Portability is usually achieved not by running everything twice but by designing so that a move is possible and affordable.
Frameworks and runtimes
The choice of application stack is itself a lock-in decision. Mainstream open languages and frameworks, such as Java with Spring Boot or Quarkus, TypeScript with React, Next.js or Angular, run on any infrastructure, are supported by large talent pools and are not controlled by a single commercial owner. A stack of this kind keeps the application separable from the hosting decision, which is the separation that makes every other mitigation cheaper.
Contracts and procurement
Technical portability can be undone by a commercial term. The World Bank’s procurement practice note on cloud computing recommends short-term contracts, for example two years with limited annual renewals, to manage lock-in risk, and observes that UK G-Cloud contracts normally do not exceed 24 months. It also advises checking portability fees, the charge for transferring data between providers, before signing, and listing portability tools and migration activities as optional services in tenders.
Several contractual points follow from this:
- Term and renewal: avoid multi-year commitments whose discount is the main reason to stay.
- Exit assistance: specify the export format, the timeline and the cost of data return at signature, not at termination.
- Intellectual property: for bespoke software, the organisation should hold the source code, documentation and infrastructure definitions, so that a change of supplier does not mean starting again.
- Egress and portability fees: obtain them in writing and model them in the total cost.
Commitment discounts deserve particular scrutiny. As Seroter notes, discounts tied to monthly or annual spend create a disincentive to leave, which is acceptable if the commitment matches a genuine long-term need and harmful if it was chosen mainly for the headline saving.
An exit plan that is actually tested
An exit plan that has never been exercised is an assumption. The UK financial sector’s CMORG third-party exit plan template, dated February 2025, recommends annual testing for materially important outsourced services plus further testing whenever the service changes materially. Desktop walk-throughs are the minimum, complemented by scenario testing that covers technical, cyber and operational risks, with version-controlled documentation and a register of lessons learned.
The GOV.UK guidance on managing technical lock-in in the cloud, published in December 2019, goes a step further. It advises monitoring the portfolio for situations where exit costs could grow disproportionately, setting baseline expectations for acceptable switching costs through a central body, and periodically re-evaluating those estimates by rebuilding or testing critical components in a different provider’s environment. The approach turns a vague worry into a recurring engineering exercise with a measurable outcome.
A proportionate exit plan for a mid-sized organisation records the critical systems, the data each holds and its export route, the alternative platforms considered, the sequence and owners of a migration, and the maximum acceptable downtime. It is reviewed whenever a major service, integration or contract changes.
When some lock-in is the right choice
Total avoidance is neither achievable nor desirable. The same GOV.UK guidance states that in the cloud the advantages of being locked in can often outweigh the disadvantages: accepting some dependency lets teams deliver faster, concentrate on user needs rather than utility operations, and build less complex services. It proposes plotting each service on a value-versus-portability graph, accepting lower portability for something like serverless technology that automates patching and deployment, while declining an obscure storage service whose small extra feature does not justify the loss of portability.
The discipline lies in making the choice visibly. A dependency accepted for a stated benefit, documented with its estimated exit cost and revisited at intervals, is a managed risk. The same dependency, adopted by default because a developer found it convenient, is the kind that surfaces years later as a budget crisis.
Our view: portability is a design decision, not an audit finding
We build and maintain software, and the pattern we meet most often is a system whose dependencies were never chosen so much as accumulated. Each convenient managed service, proprietary connector or platform shortcut was reasonable in isolation, and together they set the price of leaving.
Our model is built to counter that drift. Clients work directly with the engineers who design, build and maintain their software, so the trade-off between speed and portability is discussed by the people who understand its consequences, not relayed through an account layer. We operate without vendor bias, which means a recommendation on stack or hosting follows the client’s requirements, and we deliver written recommendations for consulting engagements so that every accepted dependency has a recorded rationale.
Our stack, centred on Java, Jakarta EE, Spring Boot, Quarkus, TypeScript, React, Next.js and Angular, with REST and GraphQL interfaces, containerisation and Kubernetes, including Red Hat OpenShift, is deliberately mainstream and portable. For organisations that already carry a dependency, our architecture and technology stack work and our code audit and technical debt reviews establish where the real switching cost sits, and legacy modernisation can reduce it step by step.
Pepe F.
Putting this into practice with Vicedomini Softworks
Organisations at the start of a build can settle stack, hosting and integration choices with an independent view, and those with an existing system can obtain a clear picture of its dependencies. We offer an initial assessment from €3,500 one-off, and CTO Advisory from €1,800 per month for continuing technical guidance on architecture and vendor decisions; Fractional CTO and CTO Partner plans, from €4,000 and €7,500 per month, extend that involvement. Details are on the CTO subscription page.

For builds, integrations and modernisation work, our software services cover custom development, architecture and stack selection, code audit, AI and automation, and staff augmentation, with clients speaking directly to the engineers throughout.
FAQ
What is the cost of lock-in?
It is the total of everything needed to move: migration labour, data transfer and egress fees, retraining, new tooling, parallel running and any early termination charges. The EU’s 2018 study measured portability costs from about €18,800 in a simple case to €231,400 in a highly complex one, before downtime. The figure for a given organisation depends on how proprietary its data, interfaces and infrastructure are.
Is multi-cloud the best way to avoid lock-in?
Not necessarily. The Dutch central bank notes that multi-sourcing often proves too expensive and too complex in practice. A more economical route is a single primary provider with containerised workloads, open data formats and standard interfaces, so that a move is feasible without running two estates permanently.
How should vendor risk be managed over time?
By repeating the assessment rather than performing it once. Record each supplier-specific dependency, estimate its exit cost, test the exit plan at least annually for material services, and review it whenever a contract, integration or major service changes.
Does custom software remove lock-in?
It removes dependence on a product vendor’s roadmap and pricing, but it can create dependence on the supplier that built it if the code, documentation and infrastructure definitions are not handed over. Ownership of source code, open frameworks and written architecture records keep bespoke software portable between teams.
Sources
- AWS: Unpicking vendor lock-in
- Cloudflare: What is vendor lock-in?
- InfoQ: Everything is lock-in, focus on switching costs
- Bournemouth University: A holistic decision framework to avoid vendor lock-in
- World Bank: Advancing cloud and data infrastructure markets
- ISC2: Cloud exit strategies
- European Union: Switching of cloud services providers
- NHS Architecture Manual: T03 Vendor lock-in
- Journal of Cloud Computing: Critical analysis of vendor lock-in
- CERRE: Competition and regulation of cloud computing services
- University of Twente: Woudstra thesis on iPaaS portability
- QIT Press: Five-year TCO optimization model
- De Nederlandsche Bank: Digital dependence of the financial sector
- World Bank: Procurement practice note on cloud computing
- CMORG: Third party exit plan template
- GOV.UK: Managing technical lock-in in the cloud
- Touchmark: reserved AI inference capacity
Recommended
This article was produced with AI assistance and reviewed for accuracy. It is provided for general information only and is not professional advice.