aws-solution-architect

Files (9)

• SKILL.md
• expected_output.json · assets/
• sample_input.json · assets/
• architecture_patterns.md · references/
• best_practices.md · references/
• service_selection.md · references/
• architecture_designer.py · scripts/
• cost_optimizer.py · scripts/
• serverless_stack.py · scripts/

SKILL.md (first lines)

# AWS Solution Architect

Design scalable, cost-effective AWS architectures for startups with infrastructure-as-code templates.

---

## Workflow

### Step 1: Gather Requirements

Collect application specifications:

```
- Application type (web app, mobile backend, data pipeline, SaaS)
- Expected users and requests per second
- Budget constraints (monthly spend limit)
- Team size and AWS experience level
- Compliance requirements (GDPR, HIPAA, SOC 2)
- Availability requirements (SLA, RPO/RTO)
```

### Step 2: Design Architecture

Run the architecture designer to get pattern recommendations:

```bash
python scripts/architecture_designer.py --input requirements.json
```

**Example output:**

```json
{
  "pattern_name": "Serverless Web Application",
  "description": "Fully serverless architecture with zero server management",
  "use_case": "SaaS platforms, low to medium traffic websites, MVPs",
  "services": {
    "frontend": { "service": "S3 + CloudFront", "purpose": "Static website hosting with global CDN", "configuration": { "...": "..." } },
    "api": { "service": "API Gateway + Lambda", "purpose": "REST API backend with auto-scaling", "configuration": { "...": "..." } },
    "database": { "service": "DynamoDB", "purpose": "NoSQL database with pay-per-request pricing", "configuration": { "...": "..." } }
  },
  "estimated_cost": {
    "monthly_usd": 35,
    "breakdown": { "CloudFront": "10-30 USD", "Lambda": "5-20 USD", "API Gateway": "10-40 USD", "DynamoDB": "5-30 USD" }
  },
  "pros": ["No server management", "Auto-scaling built-in", "Pay only for what you use"],
  "cons": ["Cold start latency (100-500ms)", "Vendor lock-in to AWS", "Debugging distributed systems complex"],
  "scaling_characteristics": {
    "users_supported": "1k - 100k",
    "requests_per_second": "100 - 10,000",
    "scaling_method": "Automatic (Lambda concurrency)"
  }
}
```

Select from recommended patterns:
- **Serverless Web**: S3 + CloudFront + API Gateway + Lambda + DynamoDB
- **Event-Driven Microservices**: EventBridge + Lambda + SQS + Step Functions
- **Three-Tier**: ALB + ECS Fargate + Aurora + ElastiCache
- **GraphQL Backend**: AppSync + Lambda + DynamoDB + Cognito

See `references/architecture_patterns.md` for detailed pattern specifications.

**Validation checkpoint:** Confirm the recommended pattern matches the team's operational maturity and compliance requirements before proceeding to Step 3.

### Step 3: Generate IaC Templates

Create infrastructure-as-code for the selected pattern:

```bash
# Serverless stack (CloudFormation)
python scripts/serverless_stack.py --app-name my-app --region us-east-1
```

**Example CloudFormation YAML output (core serverless resources):**

```yaml
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Parameters:
  AppName:
    Type: String
    Default: my-app

Resources:
  ApiFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: index.handler
      Runtime: nodejs22.x
      MemorySize: 512
      Timeout: 30
      Environment:
        Variables:
          TABLE_NAME: !Ref DataTable
      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref DataTable
      Events:
        ApiEvent:
          Type: Api
          Properties:
            Path: /{proxy+}
            Method: ANY

  DataTable:
    Type: AWS::DynamoDB::Table
    Properties:
      BillingMode: PAY_PER_REQUEST
      AttributeDefinitions:
        - AttributeName: pk
          AttributeType: S
        - AttributeName: sk
          AttributeType: S
      KeySchema:
        - AttributeName: pk
          KeyType: HASH
        - AttributeName: sk

From LeonMelamud/agentcore-toolkit, MIT.

More from LeonMelamud/agentcore-toolkit