Monopoly Index

Near-total monopoly. JSR exists but adoption is tiny. The JS ecosystem runs on npm — there is no realistic alternative today.

The original lock-in machine. Every service you add deepens the moat. Multi-cloud is a myth for most.

SPL queries don't translate anywhere. Dashboards, alerts, and saved searches built over years are non-portable. Contract terms and per-GB pricing make leaving painful.

Dominant position with deep ecosystem lock-in. Git is portable, but Actions workflows, Packages, and social graph are not.

The monitoring trap. Months of dashboard customization, alerts, and runbooks become sunk cost. Contract terms make leaving expensive.

Easy to start, painful to leave. Data export exists but schema and auth migration is manual and lossy.

Product data is exportable but themes, apps, and checkout customizations are Shopify-specific. Merchants stay because rebuilding the storefront elsewhere takes months.

Reactive paradigm spreads through your entire codebase. Convex queries, mutations, and subscriptions are non-portable. Migrating means rewriting your data layer from scratch.

The real lock-in is institutional — years of workflows, custom fields, and integrations. CSV export exists but recreating automation rules and board configurations takes weeks.

OneAgent's auto-discovery creates invisible dependencies. DQL queries, custom dashboards, and topology maps don't transfer. Enterprise contracts add financial lock-in.

Every internal tool, query, and workflow is Retool-specific. No export path to any alternative. Rebuilding in Appsmith or custom code means starting from scratch.

Design files don't export cleanly. Component libraries and plugins are non-transferable. Network effects are strong.

Each Zap must be manually recreated in any alternative. Business logic embedded in automation flows is invisible to most teams. Migration is rebuilding, not exporting.

Dominant in LLM APIs. Fine-tuned models and Assistants are non-portable. Base API calls are easier to switch (OpenRouter/LiteLLM).

State files and HCL configs represent months of work. BSL license pushed some to OpenTofu fork. Provider ecosystem is the real moat — most cloud resources have Terraform providers first.

SurrealQL doesn't translate to SQL or any other query language. Multi-model data (document + graph + relational) has no standard export path. Lock-in is structural.

HTML export loses CMS, forms, interactions, and e-commerce. The visual builder IS the product — there's no equivalent export. Rebuilding in code takes weeks.

Best DX in payments but switching means re-collecting payment methods. Connect platforms are practically stuck.

Flag evaluation code spreads throughout your codebase. Migration means rewriting every flag check. PostHog, Unleash, and Flipt are alternatives but targeting rules don't transfer.

Workflow code is deeply coupled to Temporal's SDK patterns. Activities, signals, and queries don't translate to other engines. Self-hosting is an option but operationally heavy.

HTML export exists but macros, Jira links, and embedded content break. Years of team documentation trapped in Confluence-specific formatting.

Git repos are portable but CI/CD pipelines, issue trackers, and DevSecOps configs are deeply GitLab-specific. Migration to GitHub means rewriting all CI workflows.

Strong second player to OpenAI. MCP gives platform leverage. Claude models are top-tier for code. Switching is API-level easy but agent integrations create soft lock-in.

Export exists but is lossy — databases, embeds, and linked content don't translate. Years of team knowledge trapped in Notion's format.

Best DX in hosted search but pricey at scale. InstantSearch components are the real lock-in — they assume Algolia's query format. Meilisearch is the realistic escape.

Secrets can be exported but dynamic secret generation, policies, and auth methods are deeply Vault-specific. Infrastructure teams build muscle memory around Vault workflows.

Underlying ClickHouse skills transfer. Tinybird's pipe and versioning system is opinionated — porting to raw ClickHouse means rebuilding the deployment workflow.

NestJS decorators and module system permeate every file. Migration to Fastify or Express means rewriting your entire application architecture. Business logic is portable but the framework wiring is not.

Dominant by inertia and price (free). GA4 data export is limited. Plenty of alternatives (Plausible, PostHog, Fathom) but migration means losing history.

Rules and Actions become a second codebase over time. User IDs are Auth0-namespaced so every DB foreign key is tied to them. Okta ownership is pushing enterprise pricing onto startup accounts.

Phone numbers can be ported. Voice/SMS API patterns translate to competitors (Vonage, Plivo). TwiML workflows need rewriting. Segment adds data lock-in.

No code export. The site exists only in Framer. Moving means rebuilding from scratch in code or another builder. CMS content needs manual migration.

Code is structured around Modal decorators — porting to RunPod, Replicate, or self-hosted means rewriting deployment logic. Compute is portable, glue isn't.

webpack.config.js becomes a maintenance burden. Custom loaders need rewriting for Vite/Rspack. Rspack is the closest drop-in. Vite migration requires architectural rethink for non-SPA projects.

Document format is standard JSON but query patterns and aggregation pipelines don't translate to SQL. Atlas features create platform lock-in.

Content is exportable as JSON but the rich text AST is Contentful-specific. Frontend query logic needs rewriting for any alternative CMS. Sanity and Payload are the realistic exits.

Vector data is inherently portable — re-index into Weaviate, Qdrant, or pgvector. The lock-in is minimal. Biggest friction is re-implementing query logic and metadata filters.

Technical switching is moderate — alerting patterns are similar across tools. The real cost is reconfiguring escalation policies and retraining the team on incident workflows.

Has effectively replaced webpack for new projects. Plugin API is a soft lock-in. Migration to Rspack or Turbopack is doable but plugin rewrite needed.

Message history is exportable on paid plans. Integration ecosystem creates friction. Teams switch but lose workflow context.

Component-level integration is the trap. Clerk components appear in dozens of files. Auth logic is abstractable but the UI wiring takes days to replace.

Original assets are downloadable. But transformation URLs (f_auto,q_auto,w_800) are embedded across your entire frontend. Migrating means rewriting every image URL.

PostgreSQL underneath so data is technically accessible. But EdgeQL queries and schema definitions need full rewriting for any other database. The DX is the lock-in.

Scenario definitions are Make-specific JSON. More powerful than Zapier but same migration problem — every flow must be rebuilt from scratch.

NRQL queries and custom dashboards don't export. Agent-based monitoring means code changes to switch. Free 100GB/mo tier creates strong inertia for small teams.

Git is portable. The lock-in is the Jira integration — teams that build workflows around Bitbucket+Jira find switching means losing that deep connection.

Easy to switch to Cline/Copilot/Windsurf — VS Code base means extensions move. Workflow muscle memory is the real lock-in.

If you use Yjs adapter, migration to self-hosted Yjs is realistic. Room/Storage abstractions are Liveblocks-specific — refactor required.

TypeScript is now so standard that 'lock-in' is the wrong frame — JS without types is the alternative and most teams won't go back. Flow is a theoretical alternative. JSDoc is an escape valve for library authors only.

Controls Next.js roadmap. Proprietary edge features create soft lock-in. Alternatives exist but lose DX.

Similar to Mixpanel — SDK code is portable but years of custom reports, cohorts, and taxonomy are not. Data warehouse sync helps with historical data preservation.

Provider-agnostic for models (good) but UI hooks and streaming patterns create React/Next.js coupling. LangChain or direct API calls are the alternatives.

Event tracking patterns are standard but custom dashboards, funnels, and cohorts are platform-specific. Historical data export is possible but expensive at scale.

Visual boards export as flat images — interactive elements, sticky notes, and templates lose structure. Team habits around Miro are the bigger switching cost.

Standard MySQL underneath so data migration is straightforward. The branching workflow and no-FK constraint pattern affect schema design — those assumptions spread through your codebase.

Source videos are downloadable. But playback IDs, player components, and encoding presets need rebuilding. Cloudflare Stream and AWS MediaConvert are alternatives with different APIs.

CI/CD configs are always vendor-specific. CircleCI orbs need rewriting as GitHub Actions or GitLab templates. The actual migration is 1-2 days of YAML rewriting.

Code goes to GitHub so you own it. Supabase choice is the real architectural decision — switching DB later is the cost.

Schema and migration files are Prisma-specific but migrations generate plain SQL — your data is fully portable. The generated client spreads through every query. Drizzle is the realistic exit with 1-2 weeks effort.

Lower lock-in than peers. S3-compatible storage, standard DNS. Workers scripts need rewrite for other platforms.

SQL is mostly portable but advanced features (MergeTree, materialized views, dictionaries) are ClickHouse-specific. Data exports easily but query patterns need rewriting.

Open source so no vendor lock-in on the platform. But years of Groovy pipelines, shared libraries, and plugin configs are Jenkins-specific. Migration means rewriting everything.

Migration to REST or GraphQL means rewriting both server procedures and client calls. Type safety benefit creates psychological lock-in.

Vue components are portable. Nuxt-specific composables (useAsyncData, useFetch wrappers) need replacement. Nitro server routes need adapting. Migration to Vite + Vue Router is a week of work for a mid-size app.

CSV export exists. The real friction is institutional knowledge embedded in issue structure and team habits, not technical lock-in. Switching is a 2-day project, not a 2-week one.

Function logic is readable TypeScript — the business logic ports easily. The step/sleep/retry patterns are Inngest-specific. Self-hosting option reduces platform risk.

Code is in real languages — logic is more portable than HCL. State files need migration. Provider code patterns differ from Terraform. Pulumi Cloud features add platform coupling.

Deno code runs on Deno Deploy natively. Moving to Cloudflare Workers means rewriting runtime-specific APIs. But core TypeScript logic is portable.

Generated code is portable. Lock-in is convenience-only — you can take v0 output to any host. Vercel pushes deployment but doesn't enforce it.

PostgreSQL-compatible so basic queries port easily. But distributed features (multi-region, change feeds) are CockroachDB-specific. BSL license adds uncertainty.

Route configs export as declarative YAML. Custom Lua plugins need rewriting. Core API gateway patterns are standard — switching to Traefik or Envoy is config migration, not a rewrite.

SDK is in your entry file and error boundaries. Switching means swapping one SDK for another — 1-2 days of work. Alert rules need rebuilding. Self-host option is a real exit path.

GitOps principles are universal. Argo Application manifests need rewriting for Flux or other tools. The actual k8s manifests in git are fully portable.

Self-hostable BaaS. Data is in MariaDB (less portable than PostgreSQL). SDK patterns spread through your codebase. Open source reduces platform lock-in but migration means rewriting the data layer.

Mostly Node-compatible — switching back to Node is easy if you avoid Bun-specific APIs. Built-in tooling adoption creates soft lock-in.

Data is standard PostgreSQL — pg_dump and go. Accelerate and Pulse are the platform-specific layers. Losing them means implementing your own connection pool and CDC.

OCI standard keeps lock-in low. Docker Desktop has license costs but Podman/nerdctl are drop-in alternatives.

Self-hostable with exportable workflows, but workflow definitions are n8n-specific JSON. Rebuilding automations in Zapier/Make means starting from scratch on each flow.

SQLite file is fully portable. API calls need rewriting for any alternative. Single binary makes self-hosting trivial but you're tied to one maintainer's vision.

Migration to raw SQL or Kysely is easier than from Prisma. Schema definitions need rewriting but data layer migration is incremental.

Redis protocol is the most-copied API in infrastructure. Valkey, KeyDB, DragonflyDB all speak Redis protocol. Switching is changing a connection string.

turbo.json is the main Turborepo artifact — it defines pipelines. Migration to Nx or Moon means rewriting task definitions (a few hours). Your code doesn't change.

Open source with data export. Self-host option means you always have an escape hatch. Event tracking SDK patterns are universal.

Redis commands are standard — switch to any Redis host. HTTP-based access is the unique part. QStash message queues would need reimplementation on another platform.

Database-first CMS — your data is in PostgreSQL/MySQL you control. Directus is a layer on top. Remove it and your data stays. Flows and dashboards need rebuilding.

Self-hostable with standard SDK patterns. Flag checks in code need updating when switching, but the pattern is the same everywhere. Lower lock-in than LaunchDarkly.

It's PostgreSQL underneath. pg_dump exports everything. Hypertable-specific features (continuous aggregates, compression policies) need reimplementation but data is fully portable.

Open source means no platform lock-in. Switching to Stripe direct or LemonSqueezy is straightforward. Tax handling is the real value, not the API.

OSS library — no vendor at all. Migration to Auth.js or self-built means schema migration but data stays in your DB. Truly low lock-in.

Test logic translates to Cypress/Puppeteer with moderate effort. Page interactions are conceptually identical. The migration cost is rewriting test helpers, not business logic.

Low lock-in by design. Your app runs in Docker — move it anywhere. The only friction is reconfiguring environment variables and networking.

It's SQLite underneath. Dump and go. Embedded replicas and edge-native features are Turso-specific but your schema and queries are fully portable.

Data lives in your database. Code-first config is readable TypeScript. Moving to another CMS means rebuilding the content model but your data stays accessible via standard DB tools.

Open source with exportable dashboards. Data sources use standard protocols (PromQL, LogQL). The lock-in is the institutional knowledge in dashboard configs, not the technology.

Low lock-in by design. Droplets are standard VMs. Spaces uses S3 API. Managed databases are standard PostgreSQL/MySQL. The simplicity is the value, not the lock-in.

It's just Postgres. pg_dump and connect to any other Postgres host. Branching workflow is the only Neon-specific feature you'd lose.

Open source with standard database. Product data is in PostgreSQL — fully exportable. Custom plugins and storefronts need rebuilding but data is yours.

De facto standard for metrics. PromQL is supported by Grafana Mimir, Thanos, VictoriaMetrics. Switching Prometheus backends is painless due to standardization.

Open source with data export. Content is structured JSON, members export as CSV. Theme system is Ghost-specific but content is fully portable.

Switching costs are nearly zero — change base URL and API key. Hardware advantage is real but user code is provider-agnostic.

Lowest lock-in in BaaS. It's just Postgres. pg_dump and go. Auth migration is the only friction point.

Heroku-style simplicity with low lock-in. Standard deployment patterns, standard Postgres. Moving away is a 1-day exercise.

Intentionally Jest-compatible. Most Vitest tests run in Jest with minor tweaks to vi.* mocking. The real lock-in is Vite config integration — not the tests themselves.

Minimal lock-in. Change the API key and endpoint. DNS records transfer. React Email templates are provider-agnostic. Easiest service to switch in your stack.

Open source scheduling with standard calendar protocols. Self-host option means zero platform dependency. Switching to Calendly means only reconfiguring booking pages.

Lowest lock-in possible — it's just Linux servers. The only lock-in is the price: everything else costs 3-10x more. You'll stay because of the bill, not the technology.

Lowest possible lock-in. Self-hosted, open source, Docker-based. Your apps run in containers you control. Moving to another PaaS is a config change.