Case study · Live in production

Gateway.

~25

Microservices

~75K

Lines of code

AI agents

Live

Status

The problem

Designing a system and shipping it are two different worlds

You whiteboard an architecture in Lucid or Excalidraw, then translate it by hand into Terraform, service scaffolds, and CI. Every hand-off is a chance to drop a dependency, forget a security group, or quietly pick a different region than the diagram implied. The drawing and the running system start drifting apart the moment the first ticket closes.

There's also no feedback while you design. You don't find out the diagram has a single point of failure or a runaway cost until code review, staging, or the post-incident retro. Gateway collapses that gap. One artifact carries a project from source code all the way to a running, observed system on AWS, so the design and production stay the same thing.

How it works

Repo in, running system out

Ingest

Point Gateway at any Git repo or Docker project. It reads the code and figures out what the system actually is.

Design

The architecture lands on a visual canvas where every box is a real cloud primitive, and exports as deployable Terraform, not a diagram.

Simulate

Stress-test the design before it ships: load, failure, and security simulations surface bottlenecks and single points of failure.

Test

Gateway writes and runs AI-generated end-to-end and integration tests, plus chaos tests, against the running system.

Deploy

It provisions the whole thing on real AWS (ECS, ALB, RDS) via Terraform and CodeBuild. From repo to a live URL.

Observe

Metrics, logs, and alerts come back as an observability bundle, opened as a pull request, ready to merge.

Environments

Every deploy is append-only

Each deployment lives in an environment with a full revision history. A promote or a rollback isn't a mutation. It's a new revision, forward-applied. Nothing is ever destroyed, so you can always see exactly what was live and when, and step back to it by moving forward. Artifacts (a container image, a managed database) are versioned and pinned per revision.

The AI layer

Five agents, one job each

Each agent has a single responsibility, a tight system prompt, and access to the canvas through tool calls. They share a retrieval layer over your architecture plus a curated corpus of system-design references.

Guide

Walks you through designing a system, asking about scale and constraints as you go.

Tutor

Explains why a component is there, what it does, and the trade-offs behind it.

Reviewer

Audits a finished design and scores it across five dimensions: scalability, reliability, maintainability, performance, and security.

Generator

Turns a plain-language problem statement into a first-draft architecture on the canvas.

Atlas

Diagnoses deployments. When a build fails and the heuristics don't match, it reads the logs and tells you why.

Architecture

How it's built

Microservices

~25 FastAPI services behind an API gateway (JWT, circuit breaking), talking over a RabbitMQ event bus with a shared library.

AWS, provisioned by code

Terraform + CodeBuild stand up ECS, ALB, and RDS per customer environment. The deploy path is infrastructure-as-code end to end.

AI layer

Five agents running on Amazon Bedrock (moving to the Claude ADK), each with a tight prompt and grounded retrieval over the user's architecture. Atlas streams over SSE.

Data + observability

Postgres and Redis for state, structured logs and metrics that export to CloudWatch, Prometheus, or Datadog.

Takeaways

What building it taught me

Service boundaries and event-driven contracts across ~25 services: where to draw the line, and how to keep them talking without tight coupling.
Designing LLM agents with guardrails and grounded retrieval, so each one stays in its lane and answers from the user's actual system.
Terraform module design where it counts: the export has to produce real, deployable infrastructure, not a plausible-looking approximation.
Append-only deploys change how you think about safety. If a rollback is just another forward revision, nothing is ever truly destroyed.

AWS ECSTerraformReact + ViteFastAPIAmazon BedrockClaude ADKCodeBuildRabbitMQPostgresRedis