AWS Builder Center
Weekend Showcase Challenge: CloudPilot AI

Weekend Showcase Challenge: CloudPilot AI

# Weekend Showcase Challenge: CloudPilot AI An agentic AWS Solution Architect that turns one plain-language requirement into a reviewed, scored AWS architecture — diagram, Well-Architected scores, prioritized findings, starter Terraform, and a deployment plan.

Cloud AI Architect(AWS/Azure/GCP)

Weekend Showcase Challenge: CloudPilot AI

An agentic AWS Solution Architect that turns one plain-language requirement into a reviewed, scored AWS architecture — diagram, Well-Architected scores, prioritized findings, starter Terraform, and a deployment plan.

Weekend Showcase Challenge: CloudPilot AI

An agentic AWS Solution Architect that turns one plain-language requirement into a reviewed, scored AWS architecture — diagram, Well-Architected scores, prioritized findings, starter Terraform, and a deployment plan.

At a glance



What it is
CloudPilot AI — a virtual AWS Solution Architect you can describe a workload to
Generated output
A reviewed AWS design: layered diagram, Well-Architected scores, prioritized recommendations, starter Terraform, and a deployment plan — generated fresh for each requirement
AI
Amazon Bedrock — Nova Lite (Converse API), run as a sequential multi-agent pipeline
Frontend / hosting
React + TypeScript + Vite SPA on S3 behind CloudFront (OAC, HTTPS-only)
Backend
Python 3.12 AWS Lambda behind API Gateway HTTP API — one orchestrator, eight agents
IaC
Terraform · least-privilege IAM scoped to Bedrock, DynamoDB, S3, and KMS
Persistence
DynamoDB (architecture records) + S3 (artifacts & generated Terraform)
Trust layer
Pydantic validation on every model response, with one JSON repair-retry
Modes
Demo mode (deterministic, no Bedrock calls) / Live mode (Bedrock-powered)
Cost
Fully serverless, pay-per-use, Free-Tier friendly at idle — no always-on compute

Vision & what the app does

Most cloud tooling assumes you already know the architecture. CloudPilot AI starts one step earlier: you describe a workload in plain English — "an AI insurance claims platform that ingests PDFs, extracts and summarizes them, flags missing data, notifies, and keeps an audit trail; serverless, secure, highly available" — pick an environment and an optimization priority, and an agent pipeline composes the whole design.
The output is a complete, opinionated AWS architecture generated for your exact requirement: the minimal set of services to meet it, arranged into a layered diagram from client through security & operations; a security, reliability, and cost review; Well-Architected scores (0–100 across all six pillars, weighted into an overall score); starter Terraform split into proper files; and a step-by-step deployment plan. Change the priority from Balanced to Maximum Security or Lowest Cost and the reasoning shifts with it — because the agents reason over your inputs each time rather than replaying a template.
Every design is saved, so you can reopen, duplicate, export, or delete it later.

How you built it

I split the app into two honest layers so the trustworthy parts never depend on the model behaving.
A deterministic layer owns everything that must be reliable: the orchestration sequence, request validation, the Well-Architected scoring weights, persistence to DynamoDB and S3, error normalization, and structured logging with a correlation ID per request. None of this is left to the model.
An AI agent layer runs on Amazon Bedrock's Nova Lite via the Converse API. Instead of one giant prompt, the orchestrator runs eight focused agents in sequence — Requirements → Architecture → Security → Reliability → Cost → Scoring → IaC → Deployment — threading each agent's validated output into the next agent's context. Each agent has exactly one job and a pinned output schema.
The biggest design decision was not letting the model be the source of truth for structure or scores. My first instinct was to let one prompt emit the entire result; it produced confident, well-written architectures with numbers that didn't add up. Splitting the work into single-purpose agents, validating each response against a Pydantic model, and computing the weighted overall score deterministically turned a nice demo into something you can actually reason about — the model does the thinking and explaining, the code guarantees the shape and the math.
The main challenge was getting reliable JSON out of a chatty model across eight different agents. I solved it the same way each time: pin an exact JSON schema in the system prompt, strip code fences, extract the outer  {...} , and validate with Pydantic — and on a parse failure, issue one low-temperature corrective retry before returning a controlled error rather than a stack trace. Two gotchas earned their place in the code: a structured-log field named  message  quietly collided with the logger's own argument (renamed and guarded), and a KMS-encrypted CloudWatch log group fails to apply unless its key policy grants the logs service principal (dropped the CMK — logs stay encrypted by default).
One more thing worth flagging for anyone deploying: Bedrock needs two gates, not one. An IAM  bedrock:InvokeModel  /  bedrock:Converse  permission is necessary but not sufficient — you also have to enable Model access for Nova Lite in the Bedrock console, per account and per region. The build documents this as a required manual step, and a demo mode ( ENABLE_DEMO_MODE=true ) returns deterministic sample output with no Bedrock calls at all, so the app demos instantly at $0.

AWS services used / architecture overview

  • Amazon CloudFront + S3 — the React/TypeScript SPA is served privately via Origin Access Control, HTTPS-only, with SPA-friendly error routing.
  • Amazon API Gateway (HTTP API) + AWS Lambda (Python 3.12) — a single Lambda hosts the agent orchestrator and all eight agents.
  • Amazon Bedrock — Nova Lite (Converse API, inference profile  us.amazon.nova-lite-v1:0 ) — the model is configured only through an environment variable, never hard-coded.
  • Amazon DynamoDB (architecture records, PK  architectureId , on-demand, encrypted, PITR) and Amazon S3 (architecture JSON + generated Terraform, KMS-encrypted).
  • AWS KMS, IAM, CloudWatch — customer-managed key, least-privilege role scoped to named ARNs, structured logs plus alarms on Lambda errors and throttles.
  • Terraform for all infrastructure, with a  deploy.sh  that packages the Lambda, applies the infra, builds the frontend against the live API URL, and invalidates CloudFront.
Flow: Browser → CloudFront → S3 (SPA) → API Gateway → Lambda orchestrator → Bedrock Nova agent pipeline → validated result persisted to DynamoDB + S3 → rendered as a diagram, score gauge, review findings, and a tabbed Terraform viewer.

Application Screenshots








AWS Service Used Screenshots

Created AWS services in  us-east-1 :
  • Amazon S3
  •  cloudpilot-site-666036096223 
  •  cloudpilot-artifacts-666036096223 
  • 

  • 
  • Amazon CloudFront
  • Distribution:  E14EX8HYQWHB4G 
  • 

  • 
  • Amazon API Gateway HTTP API
  • 

  • 
  • AWS Lambda
  • Function:  cloudpilot-production-api 
  • 

  • 
  • Amazon DynamoDB
  • Table:  cloudpilot-architectures 
  • 

  • 
  • Amazon Bedrock
  • Uses Nova Lite model:  us.amazon.nova-lite-v1:0 
  • AWS IAM
  • Lambda execution role and policy
  • AWS KMS
  • Encryption key and alias:  alias/cloudpilot-production 
  • 
  • Amazon CloudWatch
  • Lambda log groups
  • Error and throttling alarms

What I learned

Let the model reason; keep the truth deterministic. The result you can trust is the one where scoring, validation, and persistence never depend on the model being well-behaved. Drawing that line is a design decision, not a prompt tweak.
Structured output is a design problem. Across eight agents, a pinned per-agent schema plus defensive parsing and a single corrective retry beat hoping for clean JSON — every time.
A layered serverless stack is a superb showcase stack. A static SPA on CloudFront plus one Lambda running the whole agent pipeline needs no always-on compute, stays inside Free Tier at idle, and — with a demo mode — is instantly demoable without a single Bedrock call.

Link to app / repo



Architecture recommendations, Well-Architected scores, and generated Terraform are AI-assisted starting points. Generated Terraform is never applied automatically — review IAM, encryption, networking, and cost before deploying anything to an AWS account.
#application
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article