
Weekend Showcase Challenge: arc — An AI Multi-Cloud Architecture Advisor
One sentence of plain language in; an architecture recommendation, an itemized cost estimate, a diagram and deployable Terraform out — for AWS, Azure and GCP side by side. Built on Amazon Bedrock with a manual tool loop, then hardened by measuring where the model was confidently wrong.
The vision: one sentence in, a buildable architecture out
Early architecture decisions are usually made by the few people who hold the knowledge. Everyone else waits for a meeting. And when a design does land, three questions follow immediately: what will it cost, does it comply with our standards, and would it be cheaper somewhere else?
arc answers all three from a single sentence of plain language.
You describe what you need — "a system that processes user-uploaded video, transcodes it, and serves it globally, around 50k users" — and arc returns:
- a recommended architecture, grounded in a knowledge base of service catalogs, architecture patterns, and company standards
- a monthly cost estimate, itemized per service, with each line's share of the total
- a rendered architecture diagram
- deployable Terraform
- and an assistant you can then ask follow-up questions about that specific architecture
Hit Compare instead, and it does the whole thing three times — AWS, Azure, and GCP side by side — so you can see what the same system costs on each cloud before committing to one.
There are 93 priced services in the table, symmetric across all three providers.
How it works
Browser ──POST /chat──> API Gateway ──> Invoker Lambda ──> DynamoDB (job record)
│
└──(async)──> Orchestrator Lambda
│
┌──────────────────────────────────────────────────────────────┤
▼ ▼
Bedrock Knowledge Base (Retrieve) Bedrock Converse API
S3 Vectors · Titan Embed v2 · top_k=10 Claude Haiku 4.5
│ manual tool loop
└──> injected into the system prompt ──────────────────────► │
│
┌──────────────────┬────────────────────┤
▼ ▼ ▼
estimate_cost generate_terraform generate_diagram
│ │ │
└──────────────────┴────────────────────┘
│
written to DynamoDB
│
Browser ──GET /status/{job_id}──(every 2s)─┘
How I built it: four decisions that shaped everything
1. No Bedrock Agents — a manual tool loop instead.
Agents Classic was closed to accounts without prior usage as of July 30, 2026. So the orchestrator Lambda runs its own tool loop directly on the Converse API. This turned out better than the managed path: I can inspect every turn, and — crucially — inject a repair turn when the output fails a check. The Knowledge Base
Retrieve API is independent of Agents, so retrieval was unaffected.2. Async jobs, because 29 seconds isn't enough.
API Gateway has a hard 29-second integration timeout. A full request takes 16–45 seconds. So the API returns a
job_id immediately, the orchestrator runs in the background, and the browser polls /status/{job_id} . Job records carry a 24-hour DynamoDB TTL. The same endpoint later gained an optional root_job_id in the body — when present, the orchestrator skips tools entirely and just answers questions about that architecture. One endpoint, two purposes.3. The model does not draw the diagram.
It only describes the structure — components, groups, arrows. Layout is computed by elkjs in the browser, and the SVG is rendered by my own code. Because the model never computes a coordinate, floating arrows and overlapping boxes are structurally impossible rather than merely unlikely.
4. Closed enums instead of free text, wherever a value must be exact.
The
components field of the estimate_cost tool is an enum generated from the price table itself. The model literally cannot name a service that has no price. It narrows by target cloud, and it only contains full product names — so ambiguous names like "Redis," which don't identify a provider, can't be produced at all.
The hard part: the model was confidently wrong
This is what the build was actually about. Three defects, each handled the same way: measure, try prompting, measure again, then close it in code.
Invented pattern names. arc would cite architecture patterns that didn't exist in its knowledge base — or silently decline to name one at all. Measured across six scenarios: 0 of 6 declared a pattern, and one name was invented outright. Fix: a closed set of pattern names read from the KB document at cold start, an explicit legitimate answer of "No suitable pattern", a structural check on the declaration, and a repair turn when it fails. Re-measured: 6 of 6 declared, 0 invented, 0 silent.
Impossible replication mechanisms. In multi-cloud outputs, it described cross-provider mechanisms that cannot be built — "streaming replication," a "read replica" between AWS and Azure. The diagnosis had two layers: the relevant KB section was retrieved in only 2 of 4 runs, and in the other two the model had it and wrote from memory anyway. So the rule went into the per-cloud instruction block, which is retrieval-independent. 0 of 4 → 4 of 4 correct.
Hybrid service names. "Amazon RDS Aurora PostgreSQL" — a product that does not exist; RDS for PostgreSQL and Aurora PostgreSQL are separate services at different prices. Found in 5 of 43 jobs. Four of them were in diagram labels. Zero were in the cost breakdown — and that's the whole lesson: the cost field is a closed enum, the diagram label is free text. Free-text surfaces are where defects leak.
The general principle I'd take anywhere:
A prompt instruction lowers the frequency of a defect. It does not close the class. If correctness matters, check it in code.
And a second one I learned the harder way: don't trust your measuring tool either. My multi-cloud measurement script was wrong twice before it was right — and both times it made the results look worse than reality. Now I validate any new detector against known-good and known-bad cases before I believe a single number it produces.
Turning arc on itself
arc's knowledge base includes a company standards document — the same one it applies to every user request. Near the end of the build, I ran it against arc's own AWS architecture. 13 standards, 10 met.
One of the misses: "every internet-facing HTTP endpoint must sit behind a web application firewall." arc was recommending a WAF in 54% of the architectures it generated — and didn't have one on its own API.
So I added one. Creating the WebACL was twenty lines of Terraform; the real work was measuring false positives. Within hours, the
CrossSiteScripting_BODY managed rule blocked a completely legitimate request: "I need a service that strips <script> tags from user comments." Anyone asking for an architecture that handles user-generated content was getting a silent 403. I overrode that rule to count — safe here, because the request body is natural language destined for an LLM and is never rendered as HTML — then verified through CloudWatch that blocked requests stayed flat while counted ones rose.Adding a security control is easy. Knowing whether it's quietly breaking your product is the actual job.
AWS services used
Layer | Services |
|---|---|
AI | Amazon Bedrock (Claude Haiku 4.5 via inference profile, temperature 0 ), Bedrock Knowledge Bases with S3 Vectors and Titan Text Embeddings V2 |
Compute | AWS Lambda — invoker, orchestrator, and one Lambda per tool (cost estimation, Terraform generation, diagram generation) |
API | Amazon API Gateway (REST), AWS WAF (WAFv2 regional, two managed rule groups) |
Data | Amazon DynamoDB (on-demand, TTL-expiring job records), Amazon S3 (artifacts + knowledge base + static site) |
Delivery | Amazon CloudFront with Origin Access Control — the S3 bucket is never public; access is signed, single-door |
Ops | Amazon CloudWatch, IAM, all infrastructure in Terraform |
Region:
eu-central-1 . Idle cost is a few cents a month — everything is usage-priced, so no traffic means no bill. A full request costs roughly 3–5 cents in model tokens.282 test cases, all passing. 65 of 65 live jobs completed successfully.
What I learned
Measure before and after — every time. Every claim in this article is a number I produced twice. "It seems better now" is not a result.
Structure beats instruction. Every defect I actually closed was closed by a constraint in code — a closed enum, a structural check, a repair turn — not by a better sentence in the prompt.
Distrust your own instruments. A wrong measuring tool is worse than no measuring tool, because it feels like evidence.
Constraints are design input. Bedrock Agents being unavailable, and API Gateway's 29-second ceiling, each forced a design I'd now choose on purpose.
Apply your own advice to yourself. Running arc's standards against arc's own infrastructure was the highest-value hour of the whole build — it found a real, exploitable gap that no amount of feature work would have surfaced.
See it in action
The UI is open to look at. Running a generation needs an API key, because every request costs real Bedrock tokens and the endpoint is rate-limited — so the walkthrough below shows a complete run end to end.
[Screenshot 1 — A generated architecture]
One sentence of plain language in, and a full recommendation out: the summary, the assumptions arc made explicit, and the rendered diagram. The model describes the structure; layout and SVG are computed in the browser, so the model never places a box.
![[Screenshot 1 — A generated architecture]](https://prod-assets.cosmic.aws.dev/a/3IaPWWqiZGT6efCmWtldB4Fxkbh/Ekra.webp?imgSize=1418x778)
[Screenshot 2 — The cost breakdown]
Every line comes from a 93-item price table, not from the model. The
estimate_cost tool's service field is a closed enum generated from that table, so a service that has no price cannot appear here at all.![[Screenshot 2 — The cost breakdown]](https://prod-assets.cosmic.aws.dev/a/3IaPbfliIZwvSs5vTEpR5goaAQg/Ekra.webp?imgSize=1428x780)
**[Screenshot 3 — Three clouds side by side]**The same requirement, generated independently for AWS, Azure and GCP, with the monthly totals compared. Click any column to load that cloud's full result below.
![[Screenshot 3 — Three clouds side by side]](https://prod-assets.cosmic.aws.dev/a/3IaPjMs1VAdUTyXYTx48LKs1obX/Ekra.webp?imgSize=1418x778)
[Screenshot 4 — Archie, the assistant]
After a generation you can interrogate the result: "why this database?", "how do I cut the cost?", "what's the biggest risk?". The assistant is bound to that specific architecture — it answers from the generated design, not from general knowledge.
![[Screenshot 4 — Archie, the assistant]](https://prod-assets.cosmic.aws.dev/a/3IaPqtJn7V1zwMgWueAwziGz0tD/Ekra.webp?imgSize=1408x774)
**[Screenshot 5 — Generated Terraform]**The output isn't a slide. It's infrastructure code for the architecture that was just described.
![[Screenshot 5 — Generated Terraform]](https://prod-assets.cosmic.aws.dev/a/3IaPwHFh7OzbjCu7tz27ojUHixn/Ekra.webp?imgSize=1410x776)
Tagging a builder
@benfowleraws — for running the Summer Build Series all season. The weekend format did something a personal side project rarely gets: it gave the work a deadline and an audience. Several of the things I'm proudest of in arc exist because a challenge gave me a reason to finish them instead of leaving them at "good enough." Thanks for keeping the series going.
Built solo over the summer. All opinions are my own.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article