DOP-C02 domain - 15% of the exam

Resilient Cloud Solutions

Resilient Cloud Solutions is 15% of the DOP-C02 exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

43
Practice questions
5
Objectives
32
Medium
11
Hard

Where people go wrong

  • Absorbing a burst without a durable buffer

    The wrong answers absorb load without holding it. SNS pushes messages at the rate they arrive, so a slow consumer is overwhelmed and an absent one misses them. More threads, longer timeouts and a RequestResponse Lambda invocation keep the caller waiting on the processor. API Gateway throttling rejects the excess, and a load balancer only distributes connections. An Amazon SQS queue holds each message durably until the consumer polls it at its own rate, and a dead-letter queue sets aside messages that keep failing.

    See it in a sample question
  • Choosing a disaster recovery tier on cost or speed alone

    The wrong answers fix on one attribute of a strategy. Backup and restore is the cheapest, but a rebuild from copies is slow and the recovery point follows the snapshot interval. Pilot light keeps the database replicating with compute switched off, so launching the application tier adds recovery time. Multi-site active/active recovers fastest but runs a full second stack. Warm standby sits between them: an always-on, scaled-down copy that scales up on failover.

    See it in a sample question
  • Confusing backup isolation with backup immutability

    Isolation and immutability are separate guarantees, and the wrong answers supply the wrong one. A permission boundary, Vault Lock or a restricted KMS key leaves the recovery points inside the production account, so only a cross-account copy to a separate backup vault isolates them. For tamper-proof retention, a vault access policy, governance mode or an SCP can all be changed by a privileged user. Vault Lock in compliance mode cannot be weakened after its cooling-off period.

    See it in a sample question
  • Building custom code where AWS Backup already provides the control

    The wrong answers keep the team maintaining its own logic: Lambda functions, EventBridge triggers, Systems Manager runbooks or a custom evaluator. Data Lifecycle Manager is offered as covering RDS and DynamoDB, but it automates only EBS snapshots and EBS-backed AMIs. AWS Backup plans cover several services, copy recovery points to another Region through a copy action in the plan rule, and deploy across accounts through AWS Organizations backup policies. AWS Backup Audit Manager reports resources without a recent recovery point, with no bespoke monitoring code.

    See it in a sample question
  • Expecting a routing policy or port check to detect an unhealthy stack

    The wrong answers rely on mechanisms that never see application failure. A Network Load Balancer or TCP check treats an instance returning HTTP 500 as healthy. Weighted routing keeps sending a share to a failed Region, and latency-based routing does the same without health checks. A low time-to-live changes nothing when no failover record exists. Route 53 failover records tied to health checks, and HTTP health checks against an application endpoint, react to real state.

    See it in a sample question

Objectives in this domain

What to study

The official documents this domain's practice questions cite most.

Sample questions from this domain

Free sampleResilient Cloud Solutionsmedium

A monolithic application calls an image-processing routine synchronously inside each web request. When the image routine slows down under load, request threads block waiting for it and the whole web tier becomes unresponsive, causing cascading failures. The team wants to decouple image processing so a slow or failing processor cannot stall the web tier, while ensuring no submitted image is lost if the processor is temporarily down. Which design best achieves this?

  • AHave the web tier publish each image job to an Amazon SNS topic that pushes the job directly to the processor over an HTTP subscription so processing happens out of the request path.
  • BHave the web tier publish each image job to an Amazon SQS queue and run the processor as a separate consumer fleet that polls the queue and scales on its depth. Correct
  • CIncrease the web tier request timeout and add more threads so the application can hold many concurrent requests open while the image routine catches up under heavy load.
  • DMove the image routine into an AWS Lambda function and have the web tier invoke it synchronously with the RequestResponse invocation type for every incoming request.
Insert an Amazon SQS queue to loosely couple a producer from a slow consumer so backpressure is absorbed durably instead of cascading. Placing an SQS queue between the web tier and the processor turns a synchronous call into asynchronous message passing; the web tier enqueues and returns immediately, messages persist until consumed, and the consumer fleet scales on queue depth so a slow or unavailable processor cannot block or lose work.

Why A is wrong: SNS is fire-and-forget push without durable buffering, so if the processor is down the delivery fails and the image is lost, which violates the no-lost-jobs requirement even though it does move work off the request path.

Why B is correct: An SQS queue buffers jobs durably so the web tier returns immediately and a slow or down processor only lengthens the queue, removing the synchronous blocking and preventing job loss while the consumer catches up.

Why C is wrong: More threads and longer timeouts keep the synchronous coupling in place, so a slow processor still exhausts resources and stalls the web tier; this masks the symptom rather than decoupling the components.

Why D is wrong: A synchronous RequestResponse Lambda invocation still blocks the web request until processing finishes, so it reproduces the same cascading stall when the function is slow and provides no durable buffer.

Free sampleResilient Cloud Solutionshard

A media company runs a stateful web application on Amazon EC2 behind an Application Load Balancer in eu-west-1, with an Amazon RDS for PostgreSQL primary database. Disaster recovery today is backup and restore: nightly snapshots are copied to eu-central-1, and a full restore plus stack build takes several hours. The business has tightened the recovery time objective to roughly thirty minutes and the recovery point objective to a few minutes, while refusing to pay for a full duplicate of the production fleet running idle. The team wants to move to a pilot light strategy in eu-central-1. Which TWO actions together establish the pilot light so it meets the new objectives? (Select TWO.)

  • ACreate an RDS for PostgreSQL cross-Region read replica in eu-central-1 so the database core is always running and continuously replicating, ready to be promoted to a standalone primary during failover. Correct
  • BStore the application and load balancer configuration as AWS CloudFormation templates in eu-central-1 and run them through an AWS Systems Manager Automation runbook that scales the application tier up on failover. Correct
  • CKeep the full production-sized EC2 Auto Scaling group and Application Load Balancer running in eu-central-1 at all times so traffic can shift instantly when the primary Region fails.
  • DContinue copying nightly RDS snapshots to eu-central-1 and rely on restoring the most recent snapshot into a new instance when a disaster is declared.
Pilot light keeps a continuously replicating data core live while holding the application tier as code that automation provisions and scales on failover. Pilot light meets a tight recovery point objective by keeping the database replicating continuously, and meets a moderate recovery time objective by provisioning and scaling the dormant application tier from infrastructure as code only when failover is declared, avoiding the cost of an always-on duplicate.

Why A is correct: A continuously replicating cross-Region read replica keeps the data core alive and within minutes of the primary, which is the defining element of a pilot light and what satisfies the few-minute recovery point objective.

Why B is correct: Holding the compute tier as templates that an automated runbook provisions and scales up on failover is exactly how pilot light keeps standing cost low while still hitting a thirty-minute recovery time objective.

Why C is wrong: Running the full fleet always-on is warm standby or active/active, not pilot light, and it is exactly the idle duplicate cost the business refused, so it does not fit the stated constraint.

Why D is wrong: Nightly snapshot copy is the existing backup and restore approach, which leaves up to a day of data loss and a multi-hour restore, so it breaches both the new recovery point and recovery time objectives.

Free sampleResilient Cloud Solutionsmedium

A security team is concerned that if an attacker compromises the production account, they could delete both the live data and the AWS Backup recovery points stored alongside it. The team wants backups isolated in a separate account so that a compromise of production cannot reach or delete them, while keeping the existing AWS Backup plans running in production. What is the MOST appropriate way to achieve this isolation?

  • AAdd a copy action to each backup plan rule that copies recovery points to a backup vault in a dedicated, separately governed backup account, so the protected copies reside outside the production account entirely. Correct
  • BKeep the recovery points in the production backup vault but apply an IAM permission boundary to every production role so that no production principal is allowed to call the delete recovery point action.
  • CEnable AWS Backup Vault Lock in compliance mode on the production backup vault so that recovery points cannot be deleted before their retention expires, even by an administrator.
  • DMove the production backup vault encryption to a customer managed AWS KMS key and remove production roles from the key policy so they can no longer decrypt the stored recovery points.
Use a cross-account AWS Backup copy to a vault in a separate backup account to keep recovery points outside the production blast radius. AWS Backup copy actions can target a backup vault in another account that the organisation governs separately; because the protected copies then live outside the production account, a compromise confined to production cannot delete them, which IAM controls or in-account locks alone cannot guarantee.

Why A is correct: Copying recovery points to a vault in a separate backup account places the protected copies under different governance and outside the production blast radius, so a compromise of production cannot reach or delete the cross-account copies.

Why B is wrong: A permission boundary narrows what production roles can do, but the recovery points still live in the production account, so an attacker with sufficient access or a new role could still reach them, failing the isolation goal.

Why C is wrong: Vault Lock prevents early deletion of recovery points, but the vault is still in the production account, so this addresses tampering rather than the account-level isolation the requirement asks for.

Why D is wrong: Restricting the KMS key controls who can decrypt restores, but the recovery point objects remain in the production account and can still be deleted, so confidentiality is improved while deletion isolation is not.

Free sampleResilient Cloud Solutionshard

An organisation protects dozens of Amazon EBS volumes, Amazon RDS databases and Amazon EFS file systems across several accounts in AWS Organizations. The team currently maintains a fleet of per-service Lambda functions that take snapshots and copy them to a second Region, and wants to retire that bespoke code for a managed, policy-driven approach that handles scheduling, cross-Region copy and retention centrally. Which approach best meets this requirement?

  • AKeep the Lambda functions but consolidate them behind Amazon EventBridge scheduled rules so a single rule set triggers every snapshot and copy job on a uniform timetable across the accounts.
  • BUse Amazon Data Lifecycle Manager policies on each account to schedule EBS snapshots and cross-Region copies, accepting that RDS and EFS will continue to rely on their existing custom scripts.
  • CReplace the Lambda functions with AWS Systems Manager Automation runbooks invoked on a maintenance window schedule to create and copy snapshots for each service across the member accounts.
  • DAdopt AWS Backup with backup plans for the resource types, enable cross-Region copy in the plan rules, and govern the plans centrally across the accounts with AWS Backup policies in AWS Organizations. Correct
Use AWS Backup with organisation-wide backup policies and cross-Region copy to replace bespoke per-service snapshot automation across accounts. AWS Backup centralises backup scheduling, retention and cross-Region or cross-account copy across services such as EBS, RDS and EFS through backup plans, and AWS Organizations backup policies enforce those plans across member accounts, so it provides the managed, policy-driven protection that replaces hand-written snapshot Lambdas.

Why A is wrong: Centralising the triggers in EventBridge tidies the scheduling, but the team still owns and maintains all the snapshot and copy logic in Lambda, so it does not retire the bespoke code as required.

Why B is wrong: Data Lifecycle Manager handles EBS snapshot lifecycles well, but it does not cover RDS or EFS, so the team would still maintain custom code for those services rather than a single managed solution.

Why C is wrong: Systems Manager Automation can orchestrate snapshot steps, but the team must still author and maintain runbook logic per service, so it swaps one self-managed mechanism for another rather than using a purpose-built backup service.

Why D is correct: AWS Backup applies one policy-driven plan covering EBS, RDS and EFS, performs scheduling, cross-Region copy and retention as managed features, and is governed organisation-wide through AWS Organizations backup policies, which retires the bespoke Lambda fleet.

Free sampleResilient Cloud Solutionsmedium

A company serves a public API from identical Application Load Balancer stacks in two AWS Regions for resilience. They need user traffic to go to the primary Region while it is healthy and to switch to the secondary Region automatically within minutes if the primary stack stops responding, without an operator editing DNS during an incident. Which Amazon Route 53 configuration meets this requirement?

  • ACreate failover records with the primary load balancer as the primary record and the secondary as the secondary, each associated with a Route 53 health check that monitors the regional endpoint. Correct
  • BCreate weighted records that send ninety percent of traffic to the primary load balancer and ten percent to the secondary, then adjust the weights by hand when the primary Region is reported down.
  • CCreate latency-based records for both Regions so Route 53 directs each user to the load balancer that gives them the lowest network latency from their location.
  • DCreate multivalue answer records returning both load balancer addresses with health checks, so resolvers receive up to eight healthy values and pick one at random per query.
Use Route 53 failover routing with health checks for automatic active-passive Regional failover that needs no manual DNS change during an incident. Route 53 failover routing pairs a primary and a secondary record with health checks; while the primary health check passes Route 53 answers with the primary endpoint, and on health check failure it automatically serves the secondary endpoint, achieving hands-off active-passive failover within DNS time-to-live windows.

Why A is correct: Failover routing with health checks keeps answering with the primary record while it is healthy and automatically returns the secondary record when the health check fails, switching traffic with no manual DNS edit.

Why B is wrong: Weighted routing splits traffic by ratio rather than reacting to health, and changing the weights during an incident is the manual operator action the requirement explicitly rules out.

Why C is wrong: Latency-based routing optimises performance, not availability, and without health checks it can keep sending users to a low-latency primary Region even after that stack has failed.

Why D is wrong: Multivalue answer routing returns several healthy endpoints for client-side balancing rather than enforcing a primary-then-secondary order, so it does not give the controlled active-passive failover the company wants.

Other domains in this exam

See also the DOP-C02 cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by Amazon Web Services. Original, blueprint-aligned practice material only.