About the Project

The inspiration

We kept seeing teams stall at step zero: choosing a cloud architecture. Too many options, unclear costs, and weeks lost bouncing between docs and DevOps. We wanted a path from “what we’re building” to “a clear, priced plan we can launch”—in minutes, not months.

What it does

Describe your app and goals in plain language. Our backend returns a simple, render-ready plan—an ordered list of components with provider, region, cost, scale, desc, and connections. When you’re happy, click Export Terraform to download a ready-to-run zip.

Two endpoints only
- POST /chat → returns { components[], connections[], notes } (all strings, easy to render).
- POST /terraform → turns that plan into main.tf + variables.tf and streams a zip.
Stateless: the frontend sends full context each time; the backend stores no session state.

How we built it (architecture)

Minimal contract: each component is a human-readable line, e.g.
aws:alb | region=us-west-2; cost=25/mo; scale=med; desc=Application Load Balancer
Reasoning loop:
1. We send the user’s context, history, and message to an LLM “Cloud Architect”.
2. The model proposes components and edits (“make it cheaper”, “add a load balancer”).
3. The backend normalizes to a tiny catalog, fills costs from small defaults, and adds desc for clarity.
IaC generation: we convert the plan into a deterministic prompt and call Qodo to emit Terraform, zip it, and stream it back.
Observability: we log traces and export events so we can show judges real runs end-to-end.

How we used Claude, Gladia, Qodo, HoneyHive, Lovable and MiniMax

Claude (LLM “Cloud Architect”)

What for: Understand goals, propose an architecture, and handle edits (“more scalable”, “cheaper”, “switch DB”).
Guardrails: Outputs are constrained to a small catalog (alb, ecs_service, rds:postgres, cloudfront, s3:static, etc.). The backend enforces formatting and injects costs so answers are consistent and predictable.

Gladia (Speech-to-Text, optional)

What for: Capture voice prompts during the demo and convert them into /chat messages—no typing required.
Why it helps: Teams often ideate verbally. Gladia removes friction between “idea” and “architecture change”.

Qodo (Terraform generation)

What for: Turn the finalized plan into deployable Terraform (main.tf, variables.tf).
How: A small wrapper calls qodo gen --yes --ci --tool filesystem with a stable prompt. We stream a zip back to the browser for one-click download.

HoneyHive (Observability & traces)

What for: Log each /chat run (inputs/outputs, estimated total cost) and each /terraform export (success/failure, zip size).
Why it helps: Judges can see real traces—what users asked for, what we generated, and when exports happened.

Lovable (UI skeleton)

What for: Quick frontend starter so we could focus on backend + LLM.
How we used it: Generated the base layout (header, chat panel, components view, “Export Terraform” button) and then we tweaked styling/logic.
Result: Working UI in hours, not days.

MiniMax (demo audio & video)

What for: Create the demo media fast.
How we used it: Generated voiceover audio and produced some video segments; the rest we screen-recorded and combined.
Result: A clear end-to-end demo without heavy editing.

What we learned

Minimal contracts > complex schemas: a tiny, stable shape made FE/BE iteration fast and resilient.
AI proposes; code enforces: let the model suggest, but normalize and price in the backend for determinism.
Determinism wins demos: a small catalog and consistent TF export beat black-box magic.
Operational polish matters: non-interactive flags, timeouts, and clear errors saved hours.

Challenges & how we solved them

NPM global permissions (EACCES) → used an npx/wrapper binary for Qodo.
Interactive approvals blocking CI → added --yes --ci to Qodo calls.
“Zip is corrupted” (actually an error body) → surfaced content-type and increased TF timeout.
502 timeouts on first run → bumped Qodo timeout for model warm-up.
macOS SSL certs (HoneyHive) → pointed Python to certifi for TLS trust.
Scope creep → stayed disciplined with two endpoints and string-based components.

Team cadence

Backend: FastAPI, Claude orchestration, cost normalization, Qodo exporter, HoneyHive logging.
Frontend: Renders component strings, draws connections, triggers TF download; holds all context client-side.

Bottom line: We turn cloud choice paralysis into a clear, priced plan and a deployable Terraform zip—in just two API calls.