S'échapper du vendor lock-in sans tout réécrire

Vendor lock-in has a bad reputation it only partly deserves. Using a managed database, a cloud platform, or a SaaS tool is usually the right call — you are trading dependency for speed, and speed is often worth more. The real risk is not being locked in; it is being locked in without knowing the price of the lock.

This post is about measuring that price, and about the exit planning that costs almost nothing today but saves a renegotiation later.

Lock-in is a spectrum, not a switch

Dependencies come in grades. At the mild end: an open-source library with a healthy ecosystem — replaceable with weeks of work. In the middle: managed services with standard APIs — swappable, but with real migration cost. At the severe end: proprietary interfaces, opaque data formats, or business logic that only exists inside one vendor's configuration language.

The severity that matters is asymmetric: it is not how hard getting in was, but how hard getting out would be, and what happens if the vendor changes the deal. Price increases, deprecated features, acquisition, or a strategic pivot by the vendor are all far more common than vendors going bankrupt — design for the repricing, not just the outage.

Price your dependencies

For each critical vendor, answer four questions in writing. The exercise takes an afternoon and changes how you negotiate:

• Data egress: how much does it cost, in money and engineering time, to get all our data out — and do we actually possess a current export?
• Interface depth: are we calling standard APIs, or proprietary SDKs and query languages that exist nowhere else?
• Skill scarcity: if the vendor relationship ends, how many people on Earth can maintain this integration — and do any of them work here?
• Contract mechanics: what are the renewal terms, price-change clauses, and notice periods that govern how the deal can change?

The exit plan that costs nothing to maintain

The classic mistake is over-engineering against lock-in: abstraction layers around every vendor library 'in case we switch', maintained forever and used never. The cheap alternative is a written exit plan plus a handful of standing practices: keep schema definitions in your repository, take scheduled full exports, and document which parts of the system would need rebuilding.

A good exit plan fits on one page per vendor: what we would lose, what we would rebuild, roughly how long it would take, and what triggers the plan (price above X, feature removal, security posture change). Review it annually. The artifact's value is not the plan itself — it is that having one transforms your negotiating position.

Negotiate from architecture

Vendors price against perceived dependency. The strongest negotiating position is not a threat to leave — it is credible evidence that leaving is possible: a current export, a documented exit plan, and at least one non-critical workload that already runs on an alternative. You do not need to be portable everywhere; you need to be believably portable somewhere.

And when you do choose a proprietary, deeply-integrated service — sometimes you should — make it a deliberate, priced decision. Write down the exit cost at the moment you fall in love with the product. Future-you negotiates much better with a number on paper than with a vague feeling of unease.