The "Pre-nup" — Designing Your Exit Strategy Before You Sign

Plan the Divorce Before the Wedding

The most important negotiation happens before you sign, not after. Vendor lock-in is not a failure — it is an inevitable consequence of deep integration. The goal is not to avoid lock-in entirely (that is often impossible) but to make the cost of leaving known and manageable before you commit.

The 3 Questions to Ask Every Strategic Vendor Before Signing

1. Data Portability
"If we cancel today, in what format do we receive our data, and how long does the export take?"

Acceptable answers: JSON, CSV, SQL dump, Parquet, standard open formats.
Red flags: "PDF export only," "contact support to discuss," or silence. If your data is trapped in a proprietary format, you are not a customer — you are a hostage.

2. The Transition Period
"After cancellation, do we receive a read-only access window to complete migration?"

Best practice: 30–90 days of read-only access is standard for responsible vendors. If they refuse, negotiate it into the contract. Without this, you face a hard cutoff that forces a rushed, error-prone migration.

3. Price Escalation Cap
"Does the contract cap annual renewal price increases?"

A common trap: Year 1 pricing is attractive, but Year 3 pricing is 40% higher because there is no cap. Negotiate a clause such as "renewal increases shall not exceed 5% per year or CPI, whichever is lower."

Architectural Mitigation: The Abstraction Layer

Do not import a vendor's SDK directly into every service that needs it. Instead, wrap it behind an interface:

# Bad: Vendor SDK scattered across 40 files
import datadog_sdk
datadog_sdk.emit_metric("api.latency", value=42)

# Good: Abstraction layer — swap the engine without touching callers
class MetricsClient:
    def emit(self, name: str, value: float) -> None:
        raise NotImplementedError

class DatadogMetricsClient(MetricsClient):
    def emit(self, name: str, value: float) -> None:
        import datadog_sdk
        datadog_sdk.emit_metric(name, value=value)

class PrometheusMetricsClient(MetricsClient):
    def emit(self, name: str, value: float) -> None:
        # push to Prometheus pushgateway
        ...

When you need to migrate from Datadog to Prometheus, you write one new class and change one dependency injection binding — not 40 files.

Use Standard Protocols Where Possible

Prefer open standards over proprietary ones:
- Use OIDC/OAuth2 instead of a vendor's proprietary auth SDK.
- Use SQL instead of a vendor's custom query language where the data model allows.
- Use OpenTelemetry for observability instrumentation instead of vendor-specific agents.

Standard protocols mean your code works with any compliant vendor. Proprietary protocols mean your code works with exactly one.