The Friction of Cloud Gravity
When an organization builds an application for the cloud, they rarely rent raw, isolated virtual machines. Instead, to maximize efficiency, developers rely on value-added, high-level proprietary services: managed databases, serverless function orchestrators, machine learning pipelines, and specialized event triggers.
However, this convenience comes with a hidden cost. As Yehia Elkhatib argues in Mapping Cross-Cloud Systems: Challenges and Opportunities, these proprietary ecosystems exert a form of "cloud gravity." The deeper an application integrates with a specific provider's unique APIs and service semantics, the more difficult and expensive it becomes to decouple that application later. This technical debt effectively locks organizations into a single vendor, preventing them from migrating workloads to optimize costs, leverage specialized edge hardware, or deploy multi-cloud architectures.
This fragmentation spans the entire computing stack:
- Databases: The authors of MINDS: A Translator to Embed Mathematical Expressions Inside SPARQL Queries point out that database vendors frequently implement proprietary built-in functions to compensate for missing features in query standards, breaking cross-platform compatibility.
- Serverless (FaaS): Giuliano Casale et al. observe that serverless applications are heavily bound by unique event triggers and proprietary APIs, making multi-cloud function migration a manual re-engineering nightmare (RADON: rational decomposition and orchestration for serverless computing).
- Low-Code Platforms: Even in user-centric development environments, Peng Liang et al. highlight how closed-source, commercial low-code environments restrict customization and trap software within a single vendor's infrastructure (Characteristics and Challenges of Low-Code Development: The Practitioners' Perspective).
The Core Mechanism: Decoupling Intent from Implementation
To break cloud gravity, this research direction introduces a vital architectural layer: model-driven abstraction. The core insight is that application logic should be defined completely independently of the underlying infrastructure. Instead of writing code that directly calls a specific provider's API, developers express their application's topology, workflows, and data dependencies using a platform-agnostic intermediate representation.
This is frequently achieved through Domain-Specific Languages (DSLs) or Model-Driven Engineering (MDE). For example, in conversational AI development, Gwendal Daniel et al. developed a framework that uses DSLs to separate chatbot logic from specific natural language processing (NLP) backends (Xatkit: A model-based chatbot development framework - Extended Abstract).
By separating what the application intends to do from how a specific cloud executes it, the application becomes a declarative model. This model serves as a clean blueprint that can be analyzed, optimized, and compiled down to any target environment.
+-------------------------------------------------------+
| Platform-Agnostic Model |
| (Declarative Intent: Workflows, Topologies, Logic) |
+-------------------------------------------------------+
|
v
+-------------------------------------------------------+
| Automated Translation Layer |
| (TOSCA Compilers, Orchestrators, DSLs) |
+-------------------------------------------------------+
|
+-----------------+-----------------+
| |
v v
+------------------+ +------------------+
| AWS Lambda API | | Google Cloud Run |
+------------------+ +------------------+
Orchestration and Automated Translation
Once an application is defined as an abstract model, an automated translation engine maps that model to provider-specific execution scripts.
A prominent standard in this space is TOSCA (Topology and Orchestration Specification for Cloud Applications). In TORCH: a TOSCA-Based Orchestrator of Multi-Cloud Containerised Applications, Orazio Tomarchio et al. demonstrate a "design once, deploy anywhere" architecture. By combining TOSCA modeling with Business Process Model and Notation (BPMN) workflows, their orchestrator isolates high-level orchestration logic from low-level cloud APIs. When a deployment is triggered, the orchestrator reads the abstract TOSCA topology and dynamically generates the exact API calls required by the chosen cloud provider.
A similar challenge exists in serverless workflows, where cloud providers utilize highly heterogeneous programming models and distinct billing structures. As highlighted in SeBS-Flow: Benchmarking Serverless Cloud Function Workflows, the absence of a unified representation forces developers to completely rewrite control logic when moving between platforms. By implementing platform-agnostic transcription layers, workflows can be automatically translated and deployed across diverse cloud backends without manual intervention.
Why It Works: Shifting the Interoperability Burden
To understand why this approach succeeds, consider the alternative. Without an abstraction layer, migrating $M$ applications across $N$ cloud providers requires $M \times N$ distinct engineering efforts. Every time a cloud provider updates an API, or an organization decides to switch vendors, developers must manually rewrite infrastructure-specific code.
By introducing a standardized abstraction layer, the complexity drops from a multiplicative problem to an additive one ($M + N$). Developers write their $M$ applications once using the abstract model. Meanwhile, platform maintainers or the open-source community write $N$ drivers or translators for the orchestrator—one for each cloud provider.
As Gordon S. Blair et al. argue, adopting standardized protocols and common communication layers is the only sustainable path to reducing vendor lock-in and enabling a truly federated cloud environment (Perspectives on cloud computing: interviews with five leading scientists from the cloud community). This architectural shift transforms cloud infrastructure from a series of isolated, proprietary silos into a fluid, decentralized resource market, as envisioned by Rajkumar Buyya et al. in A Manifesto for Future Generation Cloud Computing: Research Directions for the Next Decade. Ultimately, model-driven abstraction works because it removes the burden of interoperability from individual application codebases and places it squarely into a reusable, automated translation layer.
Key Foundational Work
Programming language interoperability in distributed computing environments (1999) — contributed 2 concept elements to this direction.