Picture a fintech company in Bengaluru, call it Tarang Pay. Its platform runs mostly on AWS managed services: DynamoDB for data, SQS for queues, Lambda for compute, with API Gateway on the front. A new board member, reading about outages and price rises, asks a pointed question at the quarterly meeting: “What if AWS doubles its prices or we need to leave? We seem to be 80% locked in.”
Two architects respond. The first says: move everything to Kubernetes with open-source equivalents, PostgreSQL, Kafka and so on, so the whole platform can run on any cloud. The second says: that would be an expensive mistake. They are both partly right, which is why this deserves slow thinking.
Lock-in is not a yes-or-no property
Every technical choice locks you in to something. Choose PostgreSQL and you are tied to its behaviour and your team’s skills. Choose Kubernetes and you are tied to its operational complexity. The useful question is not “are we locked in?” but “what would it cost to leave, how likely is it that we will need to, and what does avoiding lock-in cost us every month until then?”
That last part is the one people skip. Portability is insurance, and insurance has a premium. For Tarang Pay, the premium of the “everything portable” plan would be paid in several currencies.
What the portable route costs
Moving to self-managed open-source equivalents means the company now operates databases, brokers and clusters that AWS currently runs for it. Someone must handle upgrades, patching, backups, failover, capacity and 3 a.m. incidents. That is headcount, or attention taken from product work. Even if cloud bills fall, people costs often rise; the comparison must include them. Teams also tend to underestimate the cost of running Kafka or a large Kubernetes cluster well.
Then there is the lowest-common-denominator problem. To stay portable you avoid features that exist only on one provider, which are frequently the features that make managed services worth using. You pay for the managed service’s capabilities and then decline to use them.
And you may not actually achieve portability. A cluster that runs on any cloud still depends on that cloud’s networking, identity and storage, with different behaviours and failure modes. Moving a large system between clouds is a project of months or years even when it is “agnostic”. Much of the effort lies in data movement, security configuration, operational tooling and retraining people, none of which a container image solves. Data transfer charges for getting large volumes out of a provider can also be significant, and that is true of the open-source route as well.
What staying put costs
The second architect’s plan is not free either. Heavy use of one provider’s proprietary services means a real exit would involve rewriting data access, queue handling and function code. Pricing and terms can change. A provider outage in one region affects everything. For some businesses there are also regulatory or customer pressures: Indian financial regulators, the RBI in particular, have issued guidance on outsourcing and on concentration risk and exit planning for regulated entities, and sector rules on data localisation apply to payment data. If Tarang Pay is a regulated payment aggregator or works with banks, these expectations may be real obligations, and the compliance team should be in the room.
A middle position I would defend
What would I advise Tarang Pay? Not to rebuild, but to manage lock-in deliberately, in layers:
- Keep business logic out of provider-specific glue. Domain code should not import cloud SDKs directly. Put queue, storage and database access behind small interfaces owned by the team, so a replacement touches an adapter, not the whole codebase. This is cheap and pays off whatever happens.
- Prefer standard formats and protocols at the edges. Data exportable in open formats, APIs that follow common standards, infrastructure defined in code you can read.
- Distinguish commodity from core. Where a service has a widely available open equivalent with the same interface (object storage, relational databases, containers), lock-in is mild. Where it is deeply proprietary and woven into the system (a workflow engine, a particular NoSQL access model), make the choice consciously and record why, perhaps in an ADR.
- Write a real exit plan for the critical few. Which systems would be hard to move, what would be the approximate effort, how long, what is the likely trigger. For a regulator or a board, a credible, tested-on-paper plan is worth more than a portability claim nobody has exercised.
- Back up data somewhere independent. Regular exports of critical data to a second account or provider guard against the worst case, loss of the account, much more cheaply than running everything twice.
Multi-cloud active-active deployment is a further step. It is justified for a small number of organisations with extreme availability needs and large engineering teams. For most companies it multiplies complexity far beyond the risk it covers.
Answering the board member
The honest answer to the board is something like this: yes, we depend heavily on one provider, and that dependency buys us speed and a smaller operations team. The risk is real but bounded and we have taken three steps to limit it, with an estimated exit effort for each critical system. Replacing the dependency entirely would cost more, and for longer, than the scenario it protects against. That is a position a board can challenge, and that is exactly what a good answer should invite.
Figures and names in the examples are illustrative.
Leave a Reply