Roadmap: "minikube for cloud resources" — lifecycle CLI, persistence, profiles, dashboard + differentiators

[thzgajendra]

Summary

cloudemu already has the hard 90% of a local cloud emulator — 1,635 operations across 25 categories and 3 providers in one binary, a real network-topology engine, chaos, cost simulation, resource discovery, and both an in-process Go API and an SDK-wire-compatible HTTP server. What it lacks is the product/UX layer that would make it feel like minikube does for Kubernetes: a managed local instance you start, stop, inspect, and that survives restarts.

This issue tracks turning cloudemu into a first-class "minikube for cloud resources" — adopting minikube's lifecycle ergonomics, matching LocalStack's dev-experience features (our real competitor), and leaning into the things neither of them can do.

Framing

• minikube = right UX model, wrong competitor (it only does k8s).
• LocalStack = the real competitor for cloud resources.
• Goal: minikube-grade CLI/UX + LocalStack-grade features + cloudemu's unique engine strengths.

What already exists (baseline)

• Breadth: 1,635 ops / 25 categories / AWS+Azure+GCP (docs/services.md).
• Network topology reachability engine that actually enforces SG/ACL/route rules — CanConnect, TraceRoute (docs/topology.md). Neither LocalStack nor minikube has this.
• Chaos injection (features/chaos), cost simulation (services/cost), cross-cloud resource discovery (services/resourcediscovery), auto-metrics + alarm evaluation (SetMonitoring), recorder/metrics/ratelimit/error-injection (features/).
• Admin control plane /_cloudemu/{reset,seed,health}, seed fixtures (seed/), Docker + compose + Testcontainers (contrib/testcontainers), emulated k8s API with kubeconfig (services/kubernetes).

Gap analysis

vs minikube UX

minikube	cloudemu today	gap
start/stop/status/delete/pause	serve (foreground) + version/help	no lifecycle CLI / daemon
survives restarts	in-memory only (#107)	no persistence
profile (multiple clusters)	single instance	no named profiles
dashboard (web UI)	JSON endpoints only	no dashboard
addons	fixed feature set	no opt-in modules

vs LocalStack (the real competitor)

• Persistence + Cloud Pods (save/version/share/restore state snapshots) — we have nothing (Add Time Travel with State Snapshots and Fork #107). LocalStack's flagship.
• IAM policy enforcement — we evaluate policies (CheckPermission) but never enforce on requests (no signature validation).
• Web console / resource browser.
• Init hooks (run setup scripts on boot).
• MCP server (AI-agent-driven cloud dev; LocalStack shipped one in 2026).

Proposed roadmap (prioritized)

P0 — minikube-ification core

• Lifecycle CLI: cloudemu start|stop|status|delete|logs that daemonizes serve (PID + endpoints file, or manages the Docker container). Thin wrapper, high payoff.
• Persistence (Add Time Travel with State Snapshots and Fork #107): snapshot/restore state to disk so stop→start keeps resources. Biggest gap vs LocalStack; build a state model + JSON/SQLite snapshot. The /_cloudemu/reset atomic-swap is a foundation.

P1 — parity ergonomics

• Profiles: named, isolated instances (--profile / per-profile ports).
• Cloud snapshots (Cloud-Pods analog): cloudemu snapshot save/load/list on top of persistence — versioned, shareable state bundles.
• Web dashboard / resource browser over the existing resourcediscovery engine (unified cross-cloud inventory already exists — mostly a frontend).
• Init hooks: run seed fixtures / scripts on boot (extends seed/).

P2 — differentiators ("better than minikube/LocalStack")

• Expose the topology engine as a CLI/UX feature: cloudemu net can-connect A B, cloudemu net trace — "will my SG/route actually allow this?" Nobody else has this locally.
• Cost preview: surface the cost simulator (cloudemu cost / dashboard panel) — estimate a Terraform apply before touching real cloud.
• Optional IAM enforcement mode (--enforce-iam) using the existing policy evaluator — catch permission bugs locally.
• MCP server — let AI agents provision/inspect the local cloud.

Explicit non-goals

• Do not reimplement a container runtime. cloudemu emulates APIs; if a user needs real pods to run, that's minikube/kind/k3s. Keep our k8s as an API emulator and let it compose with a real cluster (run cloudemu as a pod; apps point AWS_ENDPOINT_URL at it).
• Do not block this on 100% Azure/GCP parity — coverage is AWS-heavy today; breadth is a separate track from the UX gap this issue targets.

Relationships

• Depends on / subsumes Add Time Travel with State Snapshots and Fork #107 (state model, persistence, snapshot/restore).

Bottom line

The engine (multi-cloud wire-compat emulation + topology enforcement) is done. The path to "minikube for cloud resources" is a lifecycle CLI + persistence + profiles + dashboard on top of it, plus leaning into topology-reachability and cost simulation as genuine differentiators.

---

Competitive landscape (researched Aug 2026) & how cloudemu wins

We surveyed the local cloud-emulator market. Nobody offers what cloudemu's engine already does — all three clouds, wire-compatible, in one open-source binary, with a topology engine. The competitors split into three camps:

1. LocalStack — the closest, but AWS-only and heavily paywalled

• Coverage/pricing: free Hobby ≈ 30 core services and is non-commercial only; Base $39/user/mo (~85 services), Ultimate $89/user/mo (110+). Per-seat, commercial use requires paid plans.
• Paywalled features: Cloud Pods (state snapshots), Ephemeral Instances, Chaos API (Enterprise), IAM policy enforcement/stream tooling, Extensions, and the Web Console are all behind paid tiers.
• cloudemu wins by: being fully open-source, all services free, no per-seat cost, no non-commercial restriction, and multi-cloud (LocalStack is AWS-only). Our chaos, cost, and topology engines already ship for free what LocalStack gates behind Enterprise. Roadmap snapshots (P1) = free "Cloud Pods."

2. moto — AWS-only, Python-first

• Great for Python unit tests; has a server mode but with caveats (hosts-file edits for some services), and it's API-level only — no topology, cost, chaos-as-product, or multi-cloud.
• cloudemu wins by: language-agnostic wire compat + single Go binary + multi-cloud + the simulation engines.

3. First-party vendor emulators — siloed, single-service, inconsistent

• Azure: Azurite (Blob/Queue/Table only; no ADLS Gen2), Cosmos DB vNext emulator (preview; container/RU limits), Service Bus emulator (no VNet/Entra/portal). No emulator for App Service, Azure SQL, Key Vault, Cognitive Services, ML, most PaaS.
• GCP: gcloud beta emulators for Bigtable, Datastore, Firestore, Pub/Sub, Spanner (+ Storage/Functions). IAM, quotas, networking not emulated; several are server-side-only.
• cloudemu wins by: unifying dozens of services across all three clouds behind one consistent lifecycle/CLI/endpoint set, instead of N different single-service emulators each with its own setup, ports, and quirks.

4. Direct multi-service rivals (narrower than us)

• miniblue — 21 Azure services in a Go binary (Azure only).
• localgcp — "LocalStack for GCP" (GCP only).
• cloudemu wins by: being the only one that spans AWS and Azure and GCP in a single binary/process, sharing one topology/discovery/cost model across them — enabling cross-cloud scenarios none of the single-cloud tools can express.

Competitive matrix

Capability	LocalStack	moto	Vendor emulators	miniblue / localgcp	cloudemu (target)
Multi-cloud (AWS+Azure+GCP)	AWS only	AWS only	single-service	single-cloud	all three
Open-source, no seat/commercial limits	partial (paywalled)	yes	yes	yes	yes, fully
Wire-compat HTTP (any language)	yes	server mode (caveats)	yes	yes	yes
In-process API for unit tests	no	Python only	no	no	yes (Go)
Chaos / fault injection	Enterprise	no	no	no	free (features/chaos)
Cost simulation	no	no	no	no	yes (services/cost)
Network topology reachability	no	no	no	no	yes (docs/topology.md)
State snapshots / persistence	Cloud Pods (paid)	no	partial	partial	planned P0/P1 (#107)
Lifecycle CLI (start/stop/status)	yes (CLI)	no	mixed	mixed	planned P0
Web console / resource browser	paid	no	no (mostly)	no	planned P1

Sharpened positioning

"One open-source binary that emulates AWS, Azure, and GCP — with the resilience (chaos), cost, and network-reachability tooling that today is either paywalled or nonexistent — plus minikube-style lifecycle UX."

The roadmap items above map directly onto competitive gaps:

• P0 lifecycle CLI + persistence → reach LocalStack/minikube table-stakes UX (and give away "Cloud Pods" for free).
• P1 dashboard / snapshots / profiles / init hooks → close the remaining LocalStack dev-experience gap, unpaywalled.
• P2 topology CLI + cost preview + IAM enforcement + MCP → capabilities no competitor offers, turning cloudemu from "a LocalStack alternative" into a category of its own.