Multi-Cloud vs Single-Cloud
debt(d7/e9/b9/t7)
Closest to 'only careful code review or runtime testing' (d7). The detection_hints note automated=no, and while Terraform and Kubernetes can surface some portability issues, the real problem — heavy vendor-specific SDK usage without abstraction — requires deliberate architectural review rather than any automated signal. The code_pattern describes a structural condition that tools can hint at but not reliably flag.
Closest to 'architectural rework' (e9). The quick_fix itself acknowledges the fix is avoiding multi-cloud entirely or introducing cloud-agnostic abstraction layers (Kubernetes, Terraform, S3-compatible storage). Once a system is deeply entangled with provider-specific services across teams, unwinding that requires rewriting integrations, re-architecting data pipelines, retraining teams, and rebuilding tooling — a full architectural rework.
Closest to 'defines the system's shape' (b9). The applies_to covers web and cli broadly, and the why_it_matters makes clear that the choice shapes every downstream decision: teams must learn two platforms, tooling diverges, an abstraction layer must be maintained, and native features are underutilised. The common_mistakes entry 'Different teams per cloud — doubled burden' confirms reach is system-wide. This is a rewrite-or-live-with-it commitment.
Closest to 'serious trap' (t7). The canonical misconception is explicit: 'Multi-cloud always prevents vendor lock-in — cloud-native services create lock-in regardless of multi-cloud strategy.' A competent developer hears 'multi-cloud' and reasonably concludes portability is achieved, when in reality the abstraction cost is enormous and lock-in can still occur. This contradicts the intuitive promise of the strategy itself, scoring t7 rather than t9 only because the gotcha is documented and discussed in the industry.
Also Known As
TL;DR
Explanation
Multi-cloud benefits: vendor independence, best-of-breed. Drawbacks: doubled ops complexity, data egress costs, split expertise. True portability requires containerisation and cloud-agnostic abstractions — using DynamoDB creates lock-in regardless of strategy.
Common Misconception
Why It Matters
Common Mistakes
- Multi-cloud for theoretical risk without real benefit
- Cloud-native services claiming portability
- No egress cost analysis
- Different teams per cloud — doubled burden
Code Examples
$dynamodb = new DynamoDbClient(); $sns = new SnsClient(); // Full AWS lock-ininterface QueueService { public function push(string $m): void; }
class SqsQueueService implements QueueService {}
class PubSubQueueService implements QueueService {}