0Pricing
AWS Solutions Architect · Lesson

Reliability and Performance Efficiency Pillars

Design for automatic recovery, horizontal scaling, and capacity management; choose the right resource types and monitor to maintain performance over time.

Reliability and Performance Efficiency Pillars is a free AWS Solutions Architect lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the AWS Solutions Architect learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Reliability Pillar Overview

The Reliability pillar of the Well-Architected Framework ensures that a workload performs its intended function correctly and consistently when expected to. Reliability encompasses three areas: foundations (service limits, network topology), workload architecture (distributed systems, avoiding SPOFs), and change management and failure management (monitoring, scaling, recovering from failure). The goal is to build systems that recover automatically from infrastructure or service disruptions.

# Reliability design principles:
# 1. Automatically recover from failure
# 2. Test recovery procedures
# 3. Scale horizontally to increase availability
# 4. Stop guessing capacity (use auto scaling)
# 5. Manage change in automation (IaC + CI/CD)

# Key AWS services for reliability:
# - Auto Scaling Groups
# - Elastic Load Balancing
# - Route 53 health checks
# - AWS Backup

Service Limits and Quotas

AWS enforces service quotas (formerly limits) on resources to protect all customers. For example, default EC2 instance limits per region, VPC limits, and Lambda concurrent executions. If your workload unexpectedly hits a quota, requests will be throttled or rejected, causing reliability failures. Use Service Quotas console or CLI to view current limits and request increases before you need them. Monitor usage metrics to detect when you are approaching limits before they affect availability.

# List service quotas for EC2
aws service-quotas list-service-quotas \
  --service-code ec2 \
  --query 'Quotas[?QuotaName==`Running On-Demand Standard (A, C, D, H, I, M, R, T, Z) instances`]'

# Request quota increase
aws service-quotas request-service-quota-increase \
  --service-code ec2 \
  --quota-code L-1216C47A \
  --desired-value 500

Automatic Recovery from Failure

The Reliability pillar emphasises automatic recovery without human intervention. AWS provides multiple auto-healing mechanisms: EC2 Auto Recovery automatically restores an instance on the same hardware or moves it to healthy hardware when it fails underlying checks. ASG health checks terminate unhealthy instances and launch replacements. RDS Multi-AZ automatically fails over to the standby. Design your architecture so that most failure scenarios trigger automatic recovery actions captured in CloudWatch alarms.

# CloudWatch alarm to auto-recover a specific EC2 instance
aws cloudwatch put-metric-alarm \
  --alarm-name EC2-auto-recover \
  --metrics '[{"Id":"m1","MetricStat":{"Metric":{"Namespace":"AWS/EC2","MetricName":"StatusCheckFailed_System","Dimensions":[{"Name":"InstanceId","Value":"i-12345"}]},"Period":60,"Stat":"Maximum"}}]' \
  --comparison-operator GreaterThanThreshold \
  --threshold 0 \
  --evaluation-periods 2 \
  --alarm-actions 'arn:aws:automate:us-east-1:ec2:recover'

Horizontal Scaling for Reliability

The Reliability pillar recommends scaling horizontally (adding more smaller instances) rather than vertically (scaling up to larger instances) for better reliability. A single large instance is a single point of failure. Many smaller instances behind a load balancer means any individual failure has minimal impact. AWS Auto Scaling automatically adjusts the fleet size to meet demand, ensuring both that you have enough capacity and that you are not paying for idle resources during quiet periods.

# Horizontal scaling: 10 t3.medium vs 1 r5.4xlarge
# 10 t3.medium:
#   - Failure of 1 = loss of 10% capacity
#   - ASG launches replacement automatically
#   - 9 instances absorb load during replacement

# 1 r5.4xlarge:
#   - Failure = 100% downtime until instance recovered
#   - Much higher RTO (new instance launch: 1-3 min)

# Prefer horizontal scaling for stateless tiers

Testing for Reliability

The Reliability pillar requires testing recovery procedures — not assuming they work. Use AWS Fault Injection Simulator (FIS) to inject failures into your system in a controlled way: terminate random EC2 instances, throttle API calls, inject network latency. Run these experiments in production (with safeguards) to validate that your monitoring detects failures, auto-scaling responds, and recovery completes within your RTO. Untested recovery procedures often fail under the stress of a real incident.

# AWS FIS experiment: terminate random instance
aws fis create-experiment-template \
  --description 'Chaos: terminate 1 of 5 instances' \
  --targets '{"instanceTargets":{"resourceType":"aws:ec2:instance","selectionMode":"COUNT(1)","resourceTags":{"Env":"production"}}}' \
  --actions '{"terminateInstance":{"actionId":"aws:ec2:terminate-instances","targets":{"Instances":"instanceTargets"}}}' \
  --stop-conditions '[{"source":"aws:cloudwatch:alarm","value":"arn:aws:cloudwatch::123:alarm:high-error-rate"}]'

Performance Efficiency Pillar Overview

The Performance Efficiency pillar focuses on using computing resources efficiently to meet system requirements and maintaining that efficiency as demand changes and technologies evolve. Key design principles: Democratise advanced technologies — use managed services (RDS, SageMaker) instead of building from scratch. Go global in minutes — deploy to multiple regions with CloudFormation. Use serverless architectures — eliminate infrastructure management. Experiment more often — test different instance types and configurations.

# Performance Efficiency areas:
# Selection:   Right compute, storage, database, network
# Review:      Continuously evaluate new services
# Monitoring:  CloudWatch metrics guide decisions
# Trade-offs:  Consistency vs performance, latency vs cost

# Example: choosing between services
# RDS vs DynamoDB vs Aurora vs ElastiCache
# → depends on access patterns, consistency needs, scale

Selecting the Right Compute

Performance Efficiency starts with selecting the right compute type for your workload. EC2 has dozens of instance families optimised for different use cases: c-series for compute-intensive (video encoding, batch processing), r-series for memory-intensive (in-memory databases, caching), i-series for storage-intensive (NoSQL, data warehousing), p/g-series for GPU workloads (ML training). Using the wrong instance type means paying for capacity you cannot use or degrading performance.

# AWS Compute Optimizer: get right-size recommendations
aws compute-optimizer get-ec2-instance-recommendations \
  --instance-arns arn:aws:ec2:us-east-1:123:instance/i-12345

# Output shows:
# - Current instance utilisation (CPU, memory, network)
# - Recommended instance type
# - Estimated monthly savings
# - Performance risk of changing

# Lambda: match memory to actual usage
# Use Lambda Power Tuning tool for memory optimisation

Caching for Performance Efficiency

Caching is a fundamental performance efficiency technique that reduces latency and database load. ElastiCache (Redis/Memcached) caches database query results in memory for millisecond access. CloudFront caches HTTP responses at edge locations close to users. API Gateway caching reduces Lambda invocations by caching API responses. DAX (DynamoDB Accelerator) adds a microsecond in-memory cache in front of DynamoDB. Choose the right caching layer based on where the bottleneck is — database, API, or edge delivery.

# DAX cluster for DynamoDB microsecond latency
aws dax create-cluster \
  --cluster-name my-dax \
  --node-type dax.r6g.large \
  --replication-factor 3 \
  --iam-role-arn arn:aws:iam::123:role/DAXRole \
  --subnet-group my-dax-subnet-group

# Application connects to DAX endpoint
# Cache hits: microseconds
# Cache misses: fetches from DynamoDB and caches result

Right Storage for Performance

Storage choice dramatically impacts performance. io2 Block Express EBS provides up to 256,000 IOPS for high-performance databases. gp3 is the default for most workloads at lower cost. Instance store provides the highest IOPS (NVMe) for temporary data. S3 scales to thousands of requests per second for object storage. EFS provides shared POSIX file access. Match your storage to the I/O pattern: sequential reads benefit from st1 (Throughput Optimised HDD), while random I/O requires SSD volumes.

# EBS volume performance characteristics:
# gp3: 3,000-16,000 IOPS, 125-1,000 MB/s
# io2: 100-64,000 IOPS (up to 256k with Block Express)
# st1: 40-500 MB/s sequential throughput (HDD)
# sc1: 12-250 MB/s (cheapest, cold workloads)

# Create high-performance io2 volume
aws ec2 create-volume \
  --availability-zone us-east-1a \
  --volume-type io2 \
  --size 500 \
  --iops 50000

Performance Monitoring and Continuous Improvement

Performance Efficiency is not a one-time decision — you must continuously monitor performance metrics and re-evaluate your choices as AWS releases new services. Use CloudWatch dashboards to track p50, p90, p99 latency percentiles (not just averages, which hide tail latency). Use X-Ray traces to identify the slowest parts of a request chain. Set CloudWatch anomaly detection to automatically baseline and alert on abnormal performance deviations. Review AWS announcements regularly — newer instance types often provide better performance at lower cost.

# CloudWatch: track API response latency percentiles
aws cloudwatch put-metric-alarm \
  --alarm-name 'API-P99-Latency' \
  --metric-name TargetResponseTime \
  --namespace AWS/ApplicationELB \
  --extended-statistic p99 \
  --dimensions Name=LoadBalancer,Value=app/my-alb/xxx \
  --period 60 \
  --evaluation-periods 5 \
  --threshold 2.0 \
  --comparison-operator GreaterThanThreshold

Trade-offs in Performance Efficiency

Performance Efficiency sometimes requires trade-offs with other pillars. Adding a cache (ElastiCache) improves performance but adds operational complexity (Operational Excellence trade-off) and cost (Cost Optimisation trade-off). Using DynamoDB instead of RDS improves performance at scale but requires redesigning your data model (Operational Excellence effort). The Well-Architected Framework acknowledges these trade-offs and asks you to make them consciously, documenting the reasoning. In exam questions, look for the option that achieves performance goals with the least operational overhead.

# Common performance vs cost trade-offs:
# Cache:         +Performance, +Cost, +Complexity
# Read Replicas: +Read performance, +Cost
# SSD vs HDD:    +IOPS, +Cost
# Multi-region:  -Latency for users, +Cost, +Complexity

# Common performance vs consistency trade-offs:
# DynamoDB eventually consistent reads: +Throughput, -Consistency
# Aurora Reader endpoint: +Read scale, potential replication lag

Quick Check

Test your understanding of AWS Solutions Architect (SAA-C03) concepts from this lesson.

Lesson Recap

In this lesson you learned: Reliability requires automatic recovery, horizontal scaling, and regular failure testing, Performance Efficiency requires selecting the right compute, storage, and database type for each workload, and caching at multiple layers reduces latency and database load. Both pillars require continuous monitoring and a willingness to revisit architectural decisions. Next up we explore the Cost Optimisation and Sustainability pillars.

Frequently asked questions

Is the “Reliability and Performance Efficiency Pillars” lesson free?

Yes — the full text of “Reliability and Performance Efficiency Pillars” is free to read here on the web, and the AWS Solutions Architect course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the AWS Solutions Architect course, upgrade to CoddyKit PRO.

What will I learn in “Reliability and Performance Efficiency Pillars”?

Design for automatic recovery, horizontal scaling, and capacity management; choose the right resource types and monitor to maintain performance over time. You practise AWS Solutions Architect with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start AWS Solutions Architect?

No prior experience is required. AWS Solutions Architect on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Reliability and Performance Efficiency Pillars” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this AWS Solutions Architect lesson?

Yes. Every AWS Solutions Architect lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Operational Excellence and Security Pillars
  2. Reliability and Performance Efficiency Pillars
  3. Cost Optimisation and Sustainability Pillars
  4. Well-Architected Tool and Review Process
← Back to AWS Solutions Architect