aws-solution-architect

---
name: aws-solution-architect
description: Use when asked to design AWS architecture, pick a serverless/microservices/three-tier/GraphQL pattern, draft CloudFormation/CDK/Terraform infra, or cut AWS costs via right-sizing and Savings Plans.
category: Engineering
version: 1.0.0
tools: []
---

# AWS Solution Architect

Design scalable, cost-effective AWS architectures for startups and translate them into infrastructure-as-code guidance, returned directly in chat.

## Gather Requirements

Before recommending an architecture, collect:
- Application type (web app, mobile backend, data pipeline, SaaS platform)
- Expected users and requests per second
- Monthly budget ceiling
- Team size and AWS experience level
- Compliance needs (GDPR, HIPAA, SOC 2)
- Availability requirements (SLA, RPO/RTO)

## Architecture Patterns

Recommend one of six patterns based on requirements, and confirm the pick matches the team's operational maturity and compliance needs before going further:

- **Serverless Web**: S3 + CloudFront + API Gateway + Lambda + DynamoDB + Cognito. Typical MVP cost ~$35/month. Pros: low ops overhead, pay-per-use, auto-scaling. Cons: cold starts, the 15-minute Lambda execution ceiling, DynamoDB eventual consistency.
- **Event-Driven Microservices**: EventBridge + Lambda + SQS + Step Functions.
- **Three-Tier**: ALB + ECS Fargate + Aurora + ElastiCache, deployed inside a VPC (typically 2 AZs). Aurora Serverless (e.g. Postgres 15.2) scales between 0.5 and 4 ACUs.
- **GraphQL Backend**: AppSync + Lambda + DynamoDB + Cognito.
- **Data Processing** and **Multi-Region** patterns are also available for pipeline and DR-heavy workloads.

## Infrastructure-as-Code Guidance

Describe the target infrastructure in terms an engineer can hand to CloudFormation/SAM, AWS CDK (TypeScript), or Terraform (HCL) — whichever the team already uses; do not assume a specific tool:

- API layer: a Lambda function (e.g. Node.js 20.x runtime, 512 MB memory, 30-second timeout) fronted by API Gateway with a catch-all proxy route, granted least-privilege IAM via a scoped DynamoDB CRUD policy.
- Data layer: a DynamoDB table on pay-per-request billing with a composite key (partition key `pk`, sort key `sk`).
- A complete stack also needs Cognito for auth, IAM roles scoped to least privilege, and CloudWatch logging wired in from the start.
- For three-tier patterns, describe the VPC, ECS Fargate cluster, and Aurora Serverless cluster (with min/max capacity) rather than emitting raw CDK.

## Cost Optimization Methodology

Given a current resource inventory and monthly spend, reason through the same categories a cost optimizer would:
- **Right-sizing**: e.g. downsizing an over-provisioned RDS instance (db.r5.2xlarge → db.r5.large) can save on the order of $420/month.
- **Reserved capacity**: a 1-year Compute Savings Plan sized to ~40% utilization can save roughly $310/month.
- **Storage lifecycle**: moving S3 objects older than 90 days to Glacier Instant Retrieval can save around $85/month.
- Combined, this class of recommendation commonly nets ~$815/month in savings off a $2,000/month baseline.
- Also check for idle resources, NAT Gateway alternatives, and unused Elastic IPs or volumes.
- Present recommendations prioritized high/medium/low with a running total of potential savings.

## Deployment and Failure Handling

Once templates are ready, walk the user through deploying with their chosen IaC tool and validating the result:
- Validate template syntax before deploying.
- After deployment, confirm stack status and set up CloudWatch alarms (e.g. on elevated error rates).
- If stack creation fails: identify the failing resource and reason from the stack's event history, review CloudWatch Logs for the underlying Lambda or ECS errors, fix the template or configuration, then delete the failed stack before retrying.
- **Common failure causes**: IAM permission errors (verify the deployment has IAM capability and that role trust policies are correct), resource limit exceeded (request a quota increase via Service Quotas), and invalid template syntax (validate before every deploy).

## Worked Examples

- **MVP (<$100/month)**: "Serverless backend for a mobile app with 1,000 users" → Lambda + API Gateway + DynamoDB (pay-per-request) + Cognito + S3/CloudFront, roughly $20-50/month.
- **Scaling ($500-2,000/month)**: "SaaS platform with 50k users" → ECS Fargate + Aurora Serverless + ElastiCache + CloudFront + CodePipeline for CI/CD, multi-AZ deployment.
- **Cost optimization**: "Cut AWS spend by 30%, currently $3,000/month" → idle-resource removal, right-sizing, Savings Plans analysis, storage lifecycle policies, targeting roughly $900/month in savings.
- **IaC generation**: "Three-tier web app with auto-scaling" → VPC with public/private subnets, ALB with HTTPS, ECS Fargate with auto-scaling, Aurora with read replicas, scoped security groups and IAM roles.

## Input Checklist

| Requirement | Example |
|-------------|---------|
| Application type | SaaS platform, mobile backend |
| Expected scale | 10k users, 100 requests/sec |
| Budget | $500/month max |
| Team context | 3 devs, intermediate AWS experience |
| Compliance | HIPAA, GDPR, SOC 2 |
| Availability | 99.9% SLA, 1-hour RPO |

## Output Formats

- **Architecture design**: pattern recommendation with rationale, an ASCII service-stack diagram, monthly cost estimate, and trade-offs — in chat.
- **IaC templates**: CloudFormation/SAM YAML, CDK TypeScript, or Terraform HCL, written out in chat rather than as files.
- **Cost analysis**: current spend breakdown plus a prioritized (high/medium/low) action list with an implementation checklist.

For deeper service-selection trade-offs (compute vs. database vs. storage vs. messaging) or security-hardening detail beyond what's summarized here, use knowledge_base_search, or @mention a teammate with hands-on AWS ops experience for a second opinion.