AWS Architecture Essentials

The AWS services architects use most (compute, storage, databases, integration, networking, security, observability, IaC and Bedrock) with selection guidance and a reference web architecture.

[!VERSION] Service names, limits and features reviewed November 2026. AWS ships changes weekly; confirm limits in the service quotas documentation before quoting numbers.

Reference architecture: three-tier web application

flowchart TB
  U[Users] --> R53[Route 53]
  R53 --> CF[CloudFront + AWS WAF + Shield]
  CF --> S3W[(S3: static site)]
  CF --> ALB[Application Load Balancer]
  subgraph VPC [VPC across 3 AZs]
    subgraph Public subnets
      ALB
      NAT[NAT gateways]
    end
    subgraph Private app subnets
      EKS[EKS / ECS tasks]
      LAMBDA[Lambda in VPC]
    end
    subgraph Private data subnets
      AUR[(Aurora PostgreSQL<br/>writer + readers)]
      EC[(ElastiCache Valkey)]
    end
  end
  ALB --> EKS
  EKS --> AUR
  EKS --> EC
  EKS --> DDB[(DynamoDB via VPC endpoint)]
  EKS --> SQS[[SQS / SNS / EventBridge]]
  SQS --> LAMBDA
  EKS --> SM[Secrets Manager / KMS]
  EKS --> CW[CloudWatch / X-Ray]

Compute

Service Use for Key considerations
EC2 Full control, special hardware, licensed software Auto Scaling groups; Graviton for price-performance; Spot for interruptible work
ECS (Fargate or EC2) Containers with simpler AWS-native orchestration Lower operational burden than Kubernetes
EKS Kubernetes standardization, portability, ecosystem Karpenter for node autoscaling; EKS Auto Mode manages nodes; add-ons to manage
Lambda Event-driven functions, spiky APIs, glue 15-min max duration; cold starts (SnapStart for Java); concurrency quotas

Storage and databases

Service Use for Notes
S3 Objects, data lakes, static sites, backups Storage classes and lifecycle; Object Lock for immutability; strong read-after-write consistency
RDS Managed MySQL, PostgreSQL, SQL Server, Oracle, MariaDB Multi-AZ deployments; read replicas
Aurora High-performance MySQL/PostgreSQL-compatible Storage replicated 6 ways across 3 AZs; Serverless v2; Global Database for DR
Aurora DSQL Serverless distributed SQL, multi-region strong consistency PostgreSQL-compatible subset; check feature limitations
DynamoDB Key-value/document at any scale Design for access patterns; on-demand or provisioned; global tables; streams
ElastiCache Valkey/Redis OSS/Memcached Cluster mode for scale

Integration

Service Model Typical use
SQS Queue (standard or FIFO) Work queues, buffering, DLQs
SNS Pub/sub topics Fan-out to SQS, Lambda, HTTP, SMS
EventBridge Event bus with content-based rules, schema registry, scheduler, pipes Domain events across services and SaaS integrations
MSK Managed Apache Kafka (provisioned or serverless) Event streaming, CDC, high throughput
Step Functions Workflow orchestration Sagas, long-running processes
API Gateway REST, HTTP and WebSocket APIs Auth, throttling, usage plans

Networking and edge

  • VPC: regional network with subnets per AZ; security groups (stateful) and NACLs (stateless); VPC endpoints/PrivateLink to reach AWS services privately; Transit Gateway or Cloud WAN for hub-and-spoke.
  • CloudFront: CDN with edge functions (CloudFront Functions, Lambda@Edge); origin shield.
  • Route 53: DNS with latency, geolocation, weighted and failover routing; health checks.

Security

  • IAM: identity-based and resource-based policies; roles for workloads (EKS Pod Identity/IRSA, instance profiles); permission boundaries; SCPs in AWS Organizations for guardrails; IAM Identity Center for workforce SSO.
  • KMS: managed keys, customer-managed keys, key policies, envelope encryption; CloudHSM for dedicated HSMs.
  • GuardDuty (threat detection), Security Hub (posture), Inspector (vulnerabilities), Macie (sensitive data), WAF and Shield (edge protection).

Observability

CloudWatch metrics, logs, alarms, dashboards, Application Signals (SLOs), Container Insights; X-Ray/OpenTelemetry (AWS Distro for OpenTelemetry) for tracing; CloudTrail for API audit.

Infrastructure as code with Terraform

module "vpc" {
  source  = "terraform-aws-modules/vpc/aws"
  version = "~> 5.0"
  name    = "shop-prod"
  cidr    = "10.20.0.0/16"
  azs             = ["ap-south-1a", "ap-south-1b", "ap-south-1c"]
  private_subnets = ["10.20.1.0/24", "10.20.2.0/24", "10.20.3.0/24"]
  public_subnets  = ["10.20.101.0/24", "10.20.102.0/24", "10.20.103.0/24"]
  enable_nat_gateway = true
  one_nat_gateway_per_az = true
}

resource "aws_dynamodb_table" "carts" {
  name         = "carts"
  billing_mode = "PAY_PER_REQUEST"
  hash_key     = "cartId"
  attribute { name = "cartId"; type = "S" }
  ttl { attribute_name = "expiresAt"; enabled = true }
  point_in_time_recovery { enabled = true }
  server_side_encryption { enabled = true }
}

Keep state in a remote backend (S3 with locking), separate state per environment and component, and run plans in CI with policy checks (OPA/Conftest, Checkov). AWS CDK and CloudFormation are native alternatives.

Amazon Bedrock

Managed access to foundation models from several providers (Anthropic Claude, Amazon Nova, Meta Llama, Mistral and others) through one API, with Knowledge Bases (managed RAG), Guardrails, model evaluation, fine-tuning for some models, Agents and AgentCore (runtime, memory, identity, gateway, observability for agents). Data sent to Bedrock is not used to train the providers' base models, per AWS documentation.

Well-Architected Framework

Six pillars: operational excellence, security, reliability, performance efficiency, cost optimization, sustainability. Use the Well-Architected Tool and lenses (serverless, SaaS, generative AI) for reviews.

[!ARCHITECT] Default choices for a new AWS workload: multi-account landing zone (Control Tower), VPC per environment with private subnets, ECS/Fargate or EKS for services, Aurora PostgreSQL for relational data, DynamoDB where access patterns are known, SQS/EventBridge for async, CloudFront in front of everything public, Terraform/CDK for all infrastructure.

Interview questions and answers

ECS or EKS?

ECS (especially with Fargate) when the team wants simple AWS-native containers with less to operate. EKS when Kubernetes is an organizational standard, portability matters, or the ecosystem (operators, service mesh, GitOps tooling) is needed.

How do you keep traffic to S3 and DynamoDB private?

Gateway VPC endpoints for S3 and DynamoDB (no NAT cost), interface endpoints (PrivateLink) for other services, endpoint policies restricting which buckets/tables are reachable, and bucket policies requiring the VPC endpoint.

How would you secure IAM across 100 accounts?

AWS Organizations with SCP guardrails (deny disabling CloudTrail, restrict regions), IAM Identity Center for SSO with permission sets, no long-lived IAM user keys, workload roles with least privilege, IAM Access Analyzer, and centralized logging in a security account.