CoreWeave (a ~$99B backlog, ~3.5 GW contracted power) and Nscale (~200,000 GB300 GPUs contracted to Microsoft) lock in multi-year commitments to make the capex bankable. The risk is concentration: a handful of counterparties (Microsoft, OpenAI, Meta) dominate the book, so a single renegotiation reprices the whole thesis.

Crusoe self-generates with ~29 GE Vernova turbines at Abilene, and Nscale acquired American Intelligence & Power to integrate energy with compute. Owning the cheapest electricity is the clearest path to a cost moat — but it loads construction and turbine supply-chain risk onto operators not built to be power companies.

Vast.ai pools underutilized third-party GPUs into a low-cost marketplace and SF Compute runs a compute marketplace/clearing model, attacking the utilization problem rather than owning the hardware. This smooths demand but earns thin take-rate margins and depends on a liquid two-sided market that does not yet exist at scale.

Crusoe orders gas turbines to power Abilene directly, bypassing grid timelines, and historically built around stranded/flared energy. This delivers speed but draws emissions and regulatory scrutiny, and bets that on-site gas stays cheaper than a future grid connection or clean baseload.

Nscale builds above the Arctic Circle in Norway for low-cost hydro power and free cooling, while OVHcloud and Scaleway lean on European energy and water-cooling heritage. Geography reduces the cooling and energy bill but concentrates capacity far from where demand and low-latency inference are needed.

Armada ships ruggedized, containerized data centers that drop compute at austere or remote energy sites, and Vapor IO builds automated micro data centers at wireless aggregation hubs. Modularity sidesteps the multi-year hyperscale build but trades away the economies of scale that make gigawatt campuses cheap per FLOP.

Modal, Baseten, and RunPod offer serverless GPU execution that spins capacity up and down per request, squeezing idle time out of inference workloads. The hard part is cold-start latency: keeping GPUs warm enough to respond instantly fights directly against the goal of releasing idle hardware.

Vast.ai and SF Compute backfill idle capacity by matching it to price-sensitive demand on a marketplace, and DeepInfra packs many open-model tenants onto shared GPUs. Higher aggregate utilization comes at the cost of preemptible reliability that frontier workloads cannot tolerate.

Rafay and Spectro Cloud give platform teams Kubernetes-based scheduling and GPU governance across mixed clouds and on-prem clusters, aiming to raise effective utilization through better bin-packing and quota management. The orchestration layer helps only if the underlying workloads are actually schedulable and interruptible.

Fireworks AI, Baseten, and Together AI build custom serving runtimes with continuous batching, speculative decoding, and kernel optimizations to push throughput per GPU. The engineering moat is real but narrow — open-source serving frameworks erode the advantage as they mature.

DeepInfra and fal serve large catalogs of open-source and generative-media models through shared low-cost APIs, amortizing GPU cost across many tenants. The risk is that hosting commoditized open weights becomes a race to the bottom on price with little differentiation.

Baseten and Modal let customers reserve dedicated GPUs for predictable latency while bursting to shared pools under load. This hybrid resolves the isolation-versus-utilization tension only when demand is predictable enough to size the dedicated tier correctly.

Fly.io runs apps on Firecracker microVMs and Cloudflare uses V8 isolates for Workers, both chosen to make sandbox startup near-instant. Lighter isolation cuts startup time but constrains what runtimes and native dependencies can run, and isolates struggle with heavy GPU/model workloads.

Wasmer runs serverless workloads as portable, fast-starting Wasm modules, and Wasm's small footprint sidesteps container boot entirely. The trade-off is a constrained execution model and an immature ecosystem for the libraries that real AI and data workloads depend on.

Modal and Baseten use container/memory snapshotting and pre-warmed GPU pools to shrink cold starts for large models. Snapshots help, but restoring multi-gigabyte model state onto a GPU fast enough for real-time inference still forces a costly warm-capacity buffer.

Macrometa pairs a global data fabric with edge compute (its PhotonIQ network), exposing tunable consistency so apps can pick latency-versus-correctness per operation. Tunable consistency pushes the hard choices back onto developers, who often choose wrong under pressure.

Cloudflare offers Durable Objects and a coordinated key-value/storage layer to give Workers a coherent state model across its 300+ locations, and Fastly extends edge state for its Compute platform. Single-vendor primitives simplify the model but lock applications into one network's consistency guarantees.

Deno (and Val Town atop managed Deno) provide built-in KV and edge-function state so developers get a consistent storage API without operating their own database. The convenience comes with the same underlying physics — global strong consistency still costs latency that the abstraction can hide but not eliminate.

Pulumi (IaC in general-purpose languages) and env0 (governance over Terraform/OpenTofu/Pulumi) aim to make provisioning provider-agnostic and policy-driven. IaC standardizes how infrastructure is declared, but teams frequently adopt open-source tooling and never pay, and declaration alone does not move data or dissolve egress fees.

Spectro Cloud and Rafay manage Kubernetes and GPU clusters across public cloud, bare metal, data center, and edge from one control plane, abstracting where workloads physically run. A unified control plane helps only if customers genuinely run multicloud — most still concentrate on one provider for the managed services.

Northflank and Railway let teams deploy a consistent app/runtime experience across their own cloud accounts, and Render offers a provider-neutral PaaS. Portable PaaS lowers switching costs at the application layer, but the underlying data gravity and egress economics that anchor workloads to one cloud remain unsolved.