062 Architecture Patterns Fceffe13

AWS Architecture Patterns for Startups

Reference guide for selecting the right AWS architecture pattern based on application requirements.

Table of Contents

• Pattern Selection Matrix
• Pattern 1: Serverless Web Application
• Pattern 2: Event-Driven Microservices
• Pattern 3: Modern Three-Tier Application
• Pattern 4: Real-Time Data Processing
• Pattern 5: GraphQL API Backend
• Pattern 6: Multi-Region High Availability

Pattern Selection Matrix

Pattern 1: Serverless Web Application

Use Case

SaaS platforms, mobile backends, low-traffic websites, MVPs

Architecture Diagram

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  CloudFront │────▶│     S3      │     │   Cognito   │
│    (CDN)    │     │  (Static)   │     │   (Auth)    │
└─────────────┘     └─────────────┘     └──────┬──────┘
                                               │
┌─────────────┐     ┌─────────────┐     ┌──────▼──────┐
│   Route 53  │────▶│ API Gateway │────▶│   Lambda    │
│    (DNS)    │     │   (REST)    │     │ (Functions) │
└─────────────┘     └─────────────┘     └──────┬──────┘
                                               │
                                        ┌──────▼──────┐
                                        │  DynamoDB   │
                                        │ (Database)  │
                                        └─────────────┘

Service Stack

CloudFormation Template

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

Resources:
  # API Function
  ApiFunction:
    Type: AWS::Serverless::Function
    Properties:
      Runtime: nodejs18.x
      Handler: index.handler
      MemorySize: 512
      Timeout: 10
      Events:
        Api:
          Type: Api
          Properties:
            Path: /{proxy+}
            Method: ANY

  # DynamoDB Table
  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
          KeyType: RANGE

Cost Breakdown (10K users)

Pros and Cons

Pros:

• Zero server management
• Pay only for what you use
• Auto-scaling built-in
• Low operational overhead

Cons:

• Cold start latency (100-500ms)
• 15-minute Lambda execution limit
• Vendor lock-in

Pattern 2: Event-Driven Microservices

Use Case

Complex business workflows, asynchronous processing, decoupled systems

Architecture Diagram

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Service   │────▶│ EventBridge │────▶│   Service   │
│      A      │     │  (Event Bus)│     │      B      │
└─────────────┘     └──────┬──────┘     └─────────────┘
                           │
                    ┌──────▼──────┐
                    │     SQS     │
                    │   (Queue)   │
                    └──────┬──────┘
                           │
┌─────────────┐     ┌──────▼──────┐     ┌─────────────┐
│    Step     │◀────│   Lambda    │────▶│  DynamoDB   │
│  Functions  │     │ (Processor) │     │  (Storage)  │
└─────────────┘     └─────────────┘     └─────────────┘

Service Stack

Event Schema Example

{
  "source": "orders.service",
  "detail-type": "OrderCreated",
  "detail": {
    "orderId": "ord-12345",
    "customerId": "cust-67890",
    "items": [...],
    "total": 99.99,
    "timestamp": "2024-01-15T10:30:00Z"
  }
}

Cost Breakdown

Pros and Cons

Pros:

• Loose coupling between services
• Independent scaling per service
• Failure isolation
• Easy to test individually

Cons:

• Distributed system complexity
• Eventual consistency
• Harder to debug

Pattern 3: Modern Three-Tier Application

Use Case

Traditional web apps, e-commerce, CMS, applications with complex queries

Architecture Diagram

┌─────────────┐     ┌─────────────┐
│  CloudFront │────▶│     ALB     │
│    (CDN)    │     │ (Load Bal.) │
└─────────────┘     └──────┬──────┘
                           │
                    ┌──────▼──────┐
                    │ ECS Fargate │
                    │ (Auto-scale)│
                    └──────┬──────┘
                           │
        ┌──────────────────┼──────────────────┐
        │                  │                  │
 ┌──────▼──────┐    ┌──────▼──────┐    ┌──────▼──────┐
 │   Aurora    │    │ ElastiCache │    │     S3      │
 │ (Database)  │    │   (Redis)   │    │  (Storage)  │
 └─────────────┘    └─────────────┘    └─────────────┘

Service Stack

Terraform Example

# ECS Service with Auto-scaling
resource "aws_ecs_service" "app" {
  name            = "app-service"
  cluster         = aws_ecs_cluster.main.id
  task_definition = aws_ecs_task_definition.app.arn
  desired_count   = 2

  capacity_provider_strategy {
    capacity_provider = "FARGATE"
    weight            = 100
  }

  load_balancer {
    target_group_arn = aws_lb_target_group.app.arn
    container_name   = "app"
    container_port   = 3000
  }
}

# Auto-scaling Policy
resource "aws_appautoscaling_target" "app" {
  max_capacity       = 10
  min_capacity       = 2
  resource_id        = "service/${aws_ecs_cluster.main.name}/${aws_ecs_service.app.name}"
  scalable_dimension = "ecs:service:DesiredCount"
  service_namespace  = "ecs"
}

Cost Breakdown (50K users)

Pattern 4: Real-Time Data Processing

Use Case

Analytics, IoT data ingestion, log processing, streaming data

Architecture Diagram

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  IoT Core   │────▶│   Kinesis   │────▶│   Lambda    │
│  (Devices)  │     │  (Stream)   │     │ (Process)   │
└─────────────┘     └─────────────┘     └──────┬──────┘
                                               │
┌─────────────┐     ┌─────────────┐     ┌──────▼──────┐
│  QuickSight │◀────│   Athena    │◀────│     S3      │
│   (Viz)     │     │  (Query)    │     │ (Data Lake) │
└─────────────┘     └─────────────┘     └─────────────┘
                                               │
                                        ┌──────▼──────┐
                                        │  CloudWatch │
                                        │  (Alerts)   │
                                        └─────────────┘

Service Stack

Kinesis Producer Example

import boto3
import json

kinesis = boto3.client('kinesis')

def send_event(stream_name, data, partition_key):
    response = kinesis.put_record(
        StreamName=stream_name,
        Data=json.dumps(data),
        PartitionKey=partition_key
    )
    return response['SequenceNumber']

# Send sensor reading
send_event(
    'sensor-stream',
    {'sensor_id': 'temp-01', 'value': 23.5, 'unit': 'celsius'},
    'sensor-01'
)

Cost Breakdown

Pattern 5: GraphQL API Backend

Use Case

Mobile apps, single-page applications, flexible data queries

Architecture Diagram

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  Mobile App │────▶│   AppSync   │────▶│   Lambda    │
│   or SPA    │     │  (GraphQL)  │     │ (Resolvers) │
└─────────────┘     └──────┬──────┘     └─────────────┘
                           │
                    ┌──────▼──────┐
                    │  DynamoDB   │
                    │  (Direct)   │
                    └──────┬──────┘
                           │
                    ┌──────▼──────┐
                    │   Cognito   │
                    │   (Auth)    │
                    └─────────────┘

AppSync Schema Example

type Query {
  getUser(id: ID!): User
  listPosts(limit: Int, nextToken: String): PostConnection
}

type Mutation {
  createPost(input: CreatePostInput!): Post
  updatePost(input: UpdatePostInput!): Post
}

type Subscription {
  onCreatePost: Post @aws_subscribe(mutations: ["createPost"])
}

type User {
  id: ID!
  email: String!
  posts: [Post]
}

type Post {
  id: ID!
  title: String!
  content: String!
  author: User!
  createdAt: AWSDateTime!
}

Cost Breakdown

Pattern 6: Multi-Region High Availability

Use Case

Global applications, disaster recovery, data sovereignty compliance

Architecture Diagram

                    ┌─────────────┐
                    │  Route 53   │
                    │(Geo routing)│
                    └──────┬──────┘
                           │
          ┌────────────────┼────────────────┐
          │                                 │
   ┌──────▼──────┐                   ┌──────▼──────┐
   │ us-east-1   │                   │ eu-west-1   │
   │ CloudFront  │                   │ CloudFront  │
   └──────┬──────┘                   └──────┬──────┘
          │                                 │
   ┌──────▼──────┐                   ┌──────▼──────┐
   │ ECS/Lambda  │                   │ ECS/Lambda  │
   └──────┬──────┘                   └──────┬──────┘
          │                                 │
   ┌──────▼──────┐◀── Replication ──▶┌──────▼──────┐
   │  DynamoDB   │                   │  DynamoDB   │
   │Global Table │                   │Global Table │
   └─────────────┘                   └─────────────┘

Service Stack

Route 53 Failover Policy

# Primary record
HealthCheck:
  Type: AWS::Route53::HealthCheck
  Properties:
    HealthCheckConfig:
      Port: 443
      Type: HTTPS
      ResourcePath: /health
      FullyQualifiedDomainName: api-us-east-1.example.com

RecordSetPrimary:
  Type: AWS::Route53::RecordSet
  Properties:
    Name: api.example.com
    Type: A
    SetIdentifier: primary
    Failover: PRIMARY
    HealthCheckId: !Ref HealthCheck
    AliasTarget:
      DNSName: !GetAtt USEast1ALB.DNSName
      HostedZoneId: !GetAtt USEast1ALB.CanonicalHostedZoneID

Cost Considerations

Pattern Comparison Summary

Latency

Scaling Characteristics

Operational Complexity