Vendor lock-in has always been the quiet tax on serverless adoption. You build for one cloud's event model, its function runtime, its deployment quirks, and somewhere between the second and third environment you realize the exit cost is higher than the migration bill. Elena van Engelen's presentation on Clean Architecture for serverless is a direct answer to that trap, and it deserves attention not because it is novel, but because it is practical. She shows how to isolate business logic using Spring Cloud Function and Gradle modules, then demonstrates the same Kotlin services running on AWS and Azure via Terraform CDK. The message is not "abandon native capabilities." It is the opposite: keep your logic portable so you can choose the cloud that fits each workload, and change your mind when it no longer does.
This approach lands at a moment when the industry is swinging between two extremes. On one side, you have teams doubling down on managed services, lured by the convenience of a single provider. On the other, you have the push toward multi-cloud and edge deployments, where consistency matters more than raw integration. Van Engelen's talk sidesteps the false choice by separating the part of your code that should never change, the business rules, from the parts that inevitably will, the cloud-specific adapters. That is a discipline, not a feature. It means your team can adopt new cloud services as they emerge without rewriting the core of your application. It also means you can walk away from a vendor negotiation without losing your product. For teams feeling the squeeze of rising cloud bills or the anxiety of a strategic shift, that is not a theoretical benefit. It is a lever.
The practical takeaway here is that portability is not a technical achievement; it is a management decision. You have to enforce the boundaries in your codebase, resist the temptation to let cloud SDKs leak into your domain layer, and invest in infrastructure-as-code that treats your deployment targets as interchangeable. Terraform CDK, as van Engelen demonstrates, makes that tangible by letting you define multi-cloud infrastructure with the same language you use for your application logic. That is a concrete workflow, not a slide deck promise. If you are evaluating this for your own team, ask yourself one question: if you had to move one service to another cloud next quarter, how many files would you need to touch? If the answer is more than a few, this talk gives you a clear path to a better answer.
The broader context is worth noting. As AI deployments mature, the same portability concerns are surfacing in new forms. The Scale AWS Server Deployments Effortlessly with Stateless Model Context Protocol piece shows how AWS is simplifying state management, while Bridging Retrieval and Action: A New Approach to AI Tasks demonstrates the value of decoupling components in AI systems. And for those planning ahead, Explore the Future of AI Deployment: Key Topics at QCon AI New York covers production concerns that will test your architecture choices. The pattern is consistent: the teams that build clean boundaries today are the ones who adapt tomorrow. Van Engelen's talk is a reminder that this principle applies to the foundation of your stack, not just the AI layer. Watch her demo, then go look at your own service boundaries. That is where the real work begins.