SOA-C02 Reliability and Business Continuity Practice Question
A company runs a production web application on AWS using Auto Scaling groups (ASGs) behind an Application Load Balancer (ALB). The application state is stored in an Amazon RDS for MySQL Multi-AZ DB instance. The application experiences periodic traffic spikes, and the current ASG uses a simple scaling policy based on average CPU utilization. Recently, during a spike, the application became unresponsive for several minutes. The CloudWatch metrics show that the CPU utilization on the RDS instance peaked at 80%, and the DB Connections metric reached the maximum allowed. The read replica lag increased to over 10 seconds during the spike. The web servers are stateless and scale out quickly. The operations team needs to improve the reliability and performance of the application to handle future spikes. Which solution should the team implement?
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Increase the DB instance size to a larger instance class and implement an Amazon ElastiCache cluster to cache frequent database queries.
Increasing the DB instance size provides more CPU and memory capacity to handle the load, and caching with ElastiCache reduces read load on the database by serving frequent queries from cache. This directly addresses high CPU and connection limits on RDS, and reduces read replica lag. Option A is wrong because increasing ASG size and adding more read replicas may increase database load further due to more connections and replication overhead. Option C is wrong because switching to DynamoDB and Lambda would require significant application changes and DynamoDB may not be suitable for complex queries. Option D is wrong because reducing MaxConnections on RDS would make the problem worse, and modifying application code to reduce queries is not a quick fix.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
Increase the desired capacity of the ASG and add more read replicas to distribute the database load.
Why it's wrong here
Increasing the desired capacity of the ASG adds more EC2 instances, each of which opens new connections to the RDS database, so it actually intensifies connection pressure and CPU contention instead of alleviating it. Adding read replicas only offloads SELECT traffic and requires the application to implement read/write splitting; it does nothing to reduce the primary write workload and can introduce replication lag and additional overhead. This approach treats the symptom by scaling horizontally without addressing the root cause—database CPU saturation and connection limits.
- ✓
Increase the DB instance size to a larger instance class and implement an Amazon ElastiCache cluster to cache frequent database queries.
Why this is correct
Scaling the DB instance to a larger class directly increases available vCPU, memory, and the maximum connection limit, giving the primary database the headroom needed to absorb the current CPU spike. Implementing an ElastiCache cluster (for example, Redis or Memcached) in front of the database caches the results of frequent, repetitive queries, so those reads never reach the RDS instance, which lowers CPU usage and frees connections for writes and less frequent queries. Together these actions provide both immediate compute capacity and durable read-path relief, exactly matching the incident's requirements.
- ✗
Migrate the database to Amazon DynamoDB with auto scaling and rewrite the application to use a serverless architecture with AWS Lambda.
Why it's wrong here
Migrating to DynamoDB and rewriting the application to use Lambda is a complete re-architecture that is risky, time-consuming, and far beyond the scope of an urgent production issue. An existing MySQL relational schema with joins, transactions, and complex queries cannot simply move to a NoSQL key-value store without significant data modeling changes and rewritten application logic. It also does nothing to restore availability for the current RDS workload while the migration is being planned and executed.
- ✗
Reduce the maximum connections parameter on the RDS instance to prevent connection exhaustion and modify the application code to reduce the number of database queries.
Why it's wrong here
Reducing the MaxConnections parameter is counterproductive because legitimate traffic will then be rejected with 'too many connections' errors even sooner, while the application continues to attempt the same number of sessions, so connection exhaustion is simply enforced at a lower threshold. Modifying application code to reduce the number of database queries is a valid long-term optimization, but it cannot be implemented quickly enough to mitigate an ongoing production event. This option lacks any immediate capacity increase and instead tightens a constraint, which will harm active users immediately.
Quick reference
Cloud Service Model Comparison
| Model | You Manage | Provider Manages | Examples |
|---|---|---|---|
| IaaS | OS, runtime, apps, data | Hardware, hypervisor, networking | EC2, Azure VMs, GCP Compute Engine |
| PaaS | Apps and data | OS, runtime, middleware, hardware | Elastic Beanstalk, Azure App Service |
| SaaS | Data and settings only | Everything else | Microsoft 365, Salesforce, Workday |
| FaaS / Serverless | Function code only | Infra, scaling, runtime | Lambda, Azure Functions, Cloud Run |
| CaaS | Containers and apps | Kubernetes, OS, hardware | EKS, AKS, GKE |
Go deeper
Related to this question
About these practice questions
This SOA-C02 question is part of Courseiva's 247-question bank — original exam-style content with full explanations and wrong-answer analysis, never real exam questions or exam dumps. Learn why practice questions differ from exam dumps →
JA
Written by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
This SOA-C02 practice question is part of Courseiva's free Amazon Web Services certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the SOA-C02 exam.