Most organizations have an exit strategy. The exciting part is that portability is now something you can actually engineer, test, and prove, not just describe in a document. That’s the shift I explored with Dylan de Jong, Chief Architect Sovereign Cloud Europe North at Microsoft.
Sovereignty has grown from a data question into an application question. Not just where is the data stored, but where can this application run next, and how quickly can you make that happen? The answer is getting better every month.
Kubernetes got us moving – Adaptive Apps takes us further
Kubernetes was a genuine leap forward. It standardized packaging, scheduling, rollout, service discovery, and workload placement, and it gave every team a common foundation to build on.
Modern applications simply ask for more. They depend on databases, messaging, secrets, identity, networking, observability, policy, and increasingly AI services, and each platform implements those capabilities in its own way. Adaptive Apps picks up exactly where Kubernetes leaves off: it moves the application, including everything it depends on.
Build once. Configure per environment. Deploy anywhere.
The pattern is elegantly simple. Developers describe the workload and the capabilities it needs once. Platform operators bind those capabilities to the right implementation in each target environment, complete with local policy, identity, networking, and observability standards.
An application asks for a PostgreSQL database. In Azure it resolves to Azure Database for PostgreSQL. On Azure Local it resolves to an in-cluster instance. Same request, right answer every time, and the developer never has to think about it.
Four principles make it work:
- Build once: application code and capability requirements stay stable
- Configure per environment: infrastructure choices adapt through platform-owned mappings
- Deploy anywhere: AKS, Azure Local, Arc-enabled Kubernetes, K3s, or other Kubernetes estates
- Govern centrally: platform teams keep full ownership of recipes, policy, and identity standards
Radius makes the pattern real
Adaptive Apps is the pattern; Radius is how you implement it. It’s an open-source application model that runs as a control plane on your Kubernetes platform, not a library buried inside your application code.
| Component | What it does |
|---|---|
| Application model | Describes workloads, capabilities, and connections once |
| Resource types | Portable contracts: database, broker, identity, AI model |
| Recipes | Implement those contracts with Bicep or Terraform per target |
| Environments | Bind recipes, provider scopes, policies, and parameters to a target |
| Control plane and graph | Resolve deployments, track state, and show dependencies |
Here’s the news platform teams love: Radius builds on your existing investments. Azure Verified Modules, Bicep templates, Terraform modules, landing-zone patterns, all of it keeps working. Approved implementations become recipes, attached to environments and offered to developers as clean resource types. Your platform engineering gets a first-class consumption model, and everything you’ve already built becomes easier to reuse.
Where the portability lives
In the boundary between the app definition, the resource types, and the environment bindings. That’s the part that clicks for people.
The same app.bicep, the same container images, the same capability requests. What changes is the recipe the environment selects. The platform decision gets made once, cleanly, in a place designed to hold it.
What great portability looks like
Portability is a deliberate architectural choice, and teams that treat it that way get excellent results.
Fully portable: the application model, containers, capability declarations, deployment flow, resource contracts, and environment-specific recipes.
Worth planning deliberately: data migration, schema compatibility, managed-service semantics, latency and cost, identity federation, backup and restore, and compliance evidence. Teams that validate across their target environments early build real confidence and that validation becomes a durable asset, not a one-time exercise.
The trade is a good one: slightly less platform-specific depth, considerably more freedom to move.
Why sovereign customers are excited
Requirements around residency, operators, resilience, and connectivity evolve throughout an application’s life. Adaptive Apps give organizations something genuinely valuable: the authority to act. A portable application contract turns movement and substitution into a tested capability, which is a far stronger position than any plan on paper.
Start here
- Explore the Adaptive Apps MicroHack and work through the challenge path
- Try deploying the same application model to Azure and a local-style target
- Learn Radius resource types, recipes, environments, and the application graph
- Contribute back, improve recipes and share what you learn
đź“š Build Portable Applications with Adaptive Apps
đź“š Designing for Cloud Sovereignty with Radius and Dapr
Watch the full conversation with Dylan for the hands-on walkthrough. The moment you deploy the same app model to a second environment, portability stops being a wish and becomes something you own.
Tags: Adaptive Apps, Azure, Azure Local, Cloud, Hybrid Cloud, Microsoft, Microsoft Azure, Multi Cloud, Radius, Sovereign Cloud, Virtualization Last modified: September 15, 2026
