SAP-C02 domain - 29% of the exam

Design for New Solutions

Design for New Solutions is 29% of the SAP-C02 exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

79
Practice questions
9
Objectives
18
Medium
61
Hard

Where people go wrong

  • Giving SNS, SQS and Kinesis each other's roles

    The wrong answers reach for the wrong messaging service. SNS pushes with no durable per-consumer buffer, so a spike or a slow subscriber loses messages. A single shared SQS queue delivers each message to one consumer that deletes it, so independent teams compete for events. Kinesis Data Streams adds shard capacity planning and checkpoint handling that simple task buffering does not need. An SQS queue buffers and paces one worker fleet, and SNS fan-out to a separate SQS queue per subscriber serves consumers that each need every event.

    See it in a sample question
  • Using NAT or interface endpoints where gateway endpoints fit

    The wrong answers send same-Region traffic to Amazon S3 and Amazon DynamoDB through a NAT gateway, a NAT instance or interface endpoints. A NAT gateway reaches the public service endpoints and adds data-processing charges. Interface endpoints bill an hourly charge per Availability Zone plus a per-gigabyte fee. Gateway VPC endpoints, added to the route tables, keep this traffic private at no per-gigabyte charge, and endpoint policies can restrict them to one table and one bucket.

    See it in a sample question
  • Swapping security group and network ACL abilities

    The wrong answers give each control the other's job. Network ACLs are stateless, match only CIDR ranges and cannot reference a security group as a source, so they cannot follow tier membership as instances scale. Security groups are stateful, hold allow rules only with no explicit deny, and apply at the instance rather than the subnet boundary. Tier-to-tier rules belong in security groups that name the source group. A subnet-wide block of malicious ranges belongs in a network ACL deny rule.

    See it in a sample question
  • Matching CloudFormation safeguards to the wrong job

    The wrong answers pick a CloudFormation safeguard built for a different job. Termination protection only blocks stack deletion, and drift detection reports differences after the fact. A change set previews which resources will be modified or replaced, but observes no runtime behaviour. A rollback configuration with a CloudWatch alarm reverts the stack after resources change. A stack policy refuses updates to one resource. DeletionPolicy and UpdateReplacePolicy of Retain keep the database when it is replaced or removed, without stopping the update.

    See it in a sample question
  • Reading a permissions boundary or SCP as a grant

    The wrong answers treat a permissions boundary or a service control policy as though it could give access. A permissions boundary only caps what an identity-based policy can grant, never confers access itself, and cannot authorise access to a resource owned by another account. A service control policy only filters permissions an identity policy already grants. Cross-account access needs a grant on each side: an identity-based policy on the role, plus a bucket policy naming that role or a role to assume in the owning account.

    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 sampleDesign for New Solutionsmedium

An online ticketing platform accepts order submissions through a web tier that writes directly to a relational database. When a popular event opens, a flood of submissions arrives in a few minutes, the database reaches its connection limit, and customers receive errors even though orders could be processed slightly later. The team wants the front end to keep accepting every submission during the spike and to let the order processing drain at a steady rate the database can sustain, with minimal change to processing logic. Which design BEST smooths the demand against the database?

  • AHave the web tier place each submission on an Amazon SQS queue and run worker compute that polls the queue and writes to the database at a steady controlled rate, decoupling intake from processing. Correct
  • BIncrease the database instance to a much larger class and enable storage auto scaling so that the relational engine can absorb the entire surge of concurrent connections when the popular event opens.
  • CPublish each submission to an Amazon SNS topic so the messages fan out to subscribers, which lets the web tier hand off submissions instead of writing to the database synchronously during the surge.
  • DStream every submission into Amazon Kinesis Data Streams and process records with a consumer, sizing the stream shards to the peak so the platform can ingest the surge of orders as it arrives.
Insert an SQS queue between a bursty producer and a rate-limited consumer to buffer demand and protect a downstream database. Placing an SQS queue between the web tier and the workers decouples the rate of intake from the rate of processing. The front end enqueues every submission instantly so no order is rejected, and workers poll and write to the database at a pace its connection limit can sustain, letting the backlog drain after the spike. SNS delivers immediately without a durable backlog and Kinesis is heavier streaming infrastructure than simple buffering requires.

Why A is correct: An SQS queue buffers the burst so the web tier accepts every submission immediately, while workers pull messages and write to the database at a sustainable rate, absorbing the spike without overwhelming the connection limit and needing little change to the write logic itself.

Why B is wrong: A bigger instance raises the connection ceiling somewhat but is sized and paid for the peak the whole time, and a large enough spike still exhausts connections, so it treats the symptom rather than decoupling intake from processing.

Why C is wrong: SNS pushes messages to subscribers immediately and does not retain a backlog for paced consumption, so a slow database subscriber cannot drain at its own rate and undelivered messages are lost rather than buffered.

Why D is wrong: Kinesis can ingest the surge but is built for ordered high-throughput streaming analytics with shard capacity to provision and manage, which is heavier than needed for simple order buffering and adds operational overhead the team did not ask for.

Free sampleDesign for New Solutionshard

A data engineering team is designing a new analytics pipeline in a single private subnet. Fleets of EC2 worker instances in that subnet will pull tens of terabytes of objects from Amazon S3 buckets in the same Region every day, and will also call Amazon DynamoDB. The current draft architecture routes all of that traffic through a NAT gateway to reach the AWS service public endpoints, and the finance team has flagged the projected NAT gateway data-processing charges as the single largest line item. The solution must keep the workers in private subnets with no public IP addresses. Which change MOST reduces the data transfer and processing cost while preserving that private posture?

  • ACreate gateway VPC endpoints for Amazon S3 and Amazon DynamoDB and add their prefix lists to the subnet route table, so same-Region traffic to those services bypasses the NAT gateway and incurs no endpoint or NAT data-processing charge. Correct
  • BReplace the NAT gateway with a NAT instance sized for the throughput, so the team controls the host and pays a flat EC2 hourly rate instead of the managed NAT gateway per-gigabyte data-processing charge for the S3 and DynamoDB traffic.
  • CProvision interface VPC endpoints powered by AWS PrivateLink for Amazon S3 and Amazon DynamoDB in the subnet, accepting the hourly endpoint and per-gigabyte processing charge as the cheapest way to keep the workers private.
  • DMove the EC2 workers into a public subnet with auto-assigned public IP addresses and a tightened security group, so traffic to S3 and DynamoDB leaves directly through the internet gateway without any NAT data-processing fee.
Use free S3 and DynamoDB gateway VPC endpoints to remove NAT gateway data-processing charges for same-Region traffic from private subnets. Amazon S3 and DynamoDB are reachable through gateway VPC endpoints, which add prefix-list routes so same-Region traffic flows over the AWS backbone without traversing a NAT gateway. Gateway endpoints carry no hourly or per-gigabyte fee, so they delete the NAT data-processing line item entirely while the workers remain in private subnets, whereas NAT instances, interface endpoints and public subnets each either keep a cost or break the private requirement.

Why A is correct: Gateway VPC endpoints for S3 and DynamoDB route same-Region traffic privately over the AWS network at no per-gigabyte endpoint charge and with no NAT data-processing fee, which directly eliminates the dominant cost while the workers stay in private subnets with no public addresses.

Why B is wrong: A self-managed NAT instance removes the managed per-gigabyte fee but still funnels every byte through a single bandwidth-bound host that you must scale and patch, and large S3 pulls would saturate it, so it trades managed cost for an operational bottleneck rather than removing the transfer path entirely.

Why C is wrong: Interface endpoints do keep traffic private, but they bill an hourly charge per endpoint per Availability Zone plus a per-gigabyte processing fee, so for tens of terabytes a day they cost far more than the free gateway endpoints that S3 and DynamoDB both support.

Why D is wrong: An internet gateway carries no data-processing charge, but placing the workers in a public subnet with public IP addresses breaks the explicit requirement that they stay private with no public addressing, so it fails the stated constraint.

Free sampleDesign for New Solutionshard

An engineering team is designing the network controls for a new three-tier web application in a single VPC. A web tier in public subnets must accept HTTPS from the internet and forward only to an application tier in private subnets, and the application tier must reach a database tier in separate private subnets on the database port. The security team requires that the rules be stateful, follow least privilege, and reference the source tier rather than fixed IP ranges so they keep working as instances scale in and out. Which control design BEST enforces these tier-to-tier restrictions?

  • AUse network ACLs on each subnet that allow HTTPS inbound to the public subnets, the application port between the application and web subnets, and the database port to the database subnets, listing each tier's subnet CIDR ranges as the allowed sources and destinations.
  • BCreate one security group per tier and write rules that reference the other tiers' security groups as the source, allowing HTTPS from the internet to the web group, the application port from the web group to the application group, and the database port from the application group to the database group. Correct
  • CApply a single shared security group to all three tiers that allows HTTPS, the application port and the database port among any members of the group, claiming this simplifies management by letting every instance that belongs to the application reuse one consistent and self-referencing set of inbound rules.
  • DConfigure network ACLs to reference each tier's security group as the allowed source and destination for the relevant ports, so the stateless subnet rules inherit security-group membership and automatically follow instances as the tiers scale in and out over time.
Use per-tier security groups that reference each other as sources for stateful, identity-based, least-privilege tier-to-tier segmentation that survives scaling. Security groups are stateful, so allowing an inbound flow automatically permits its return traffic, and they can name another security group as the source. Giving each tier its own security group and referencing the calling tier's group as the source means the rule follows tier membership instead of IP ranges, so it keeps working as instances scale and grants only the single port each tier needs. Network ACLs are stateless and match only CIDR ranges, and a single shared group cannot segment tiers from one another.

Why A is wrong: Subnet network ACLs can broadly segment the tiers, but they are stateless so return traffic needs explicit rules and ephemeral-port ranges, and they match on CIDR rather than tier identity, so they neither stay least-privilege as hosts scale nor meet the stateful requirement.

Why B is correct: Security groups are stateful so return traffic is allowed automatically, and referencing another tier's security group as the source means rules track tier membership rather than IPs, so they stay correct as instances scale and grant each tier only the one port it needs from the one tier permitted to call it.

Why C is wrong: A single shared security group is stateful and scales with membership, but allowing all three ports among every member lets any tier reach any other tier on any of those ports, which breaks the tier-to-tier least-privilege segmentation the requirement demands.

Why D is wrong: This option sounds appealing, but network ACLs cannot reference security groups as a source or destination at all, they only match IP CIDR ranges and are stateless, so the described behaviour is not something network ACLs can provide.

Free sampleDesign for New Solutionshard

A financial services company defines its production environment with a single large AWS CloudFormation stack that includes an Amazon RDS database, security groups, and an Auto Scaling group. A release engineer must apply a template change that updates the database instance class and an IAM role, but a previous release caused an unexpected replacement of the database and a long outage. Leadership now requires that before any production update is executed, the team must see exactly which resources will be modified, replaced, or deleted, and obtain a sign-off, without applying anything. Which approach BEST gives the team that pre-execution visibility?

  • ACreate a CloudFormation change set from the revised template, review the action and replacement column for each resource to confirm whether the database is modified or replaced, gain sign-off, and only then execute the change set. Correct
  • BRun the stack update directly with rollback triggers configured on CloudWatch alarms, so that if the database is replaced and the alarm fires the stack automatically rolls back to the prior state before users are affected.
  • CEnable termination protection on the stack and turn on drift detection before the release, then run the update and rely on the drift report to highlight any resource that the change unexpectedly replaced or deleted during deployment.
  • DValidate the template with the CloudFormation linter and the validate-template action in the pipeline, capture the output for the approvers, and proceed with the update once the template is confirmed to be syntactically valid.
Use a CloudFormation change set to preview the exact resource actions and replacements of a stack update before executing it. A change set is a preview that CloudFormation generates by comparing the current stack state to the proposed template, returning each resource with its planned action and a flag for whether the update forces a replacement. This lets the team see a database replacement coming and gate the release on approval, which rollback triggers, drift detection, and template validation cannot do because they act during or after execution or only check syntax.

Why A is correct: A change set computes the difference between the running stack and the proposed template and lists every resource with its action and whether a replacement is required, so the team can confirm the database will not be replaced and obtain sign-off before executing anything.

Why B is wrong: Rollback triggers act only after the update has already started executing and a resource may have been replaced, so the change is applied first rather than previewed, which fails the requirement to see the impact before anything runs.

Why C is wrong: Termination protection only blocks stack deletion and drift detection compares deployed resources to the template after the fact, so neither previews the pending update or shows planned replacements before execution.

Why D is wrong: Template validation checks only syntax and structure and never compares against the deployed stack, so it cannot reveal that the instance-class change would force a replacement of the live database.

Free sampleDesign for New Solutionshard

A media company is designing a new analytics workload in a processing account that must read objects from an Amazon S3 bucket owned by a separate data account in the same AWS Organization. The security team mandates least privilege on both sides: the processing role must be permitted to read only the one bucket, the bucket must accept reads only from that single named role and refuse every other principal, and the design must use temporary credentials with no long-lived keys. They want the access enforced by policy on both the identity and the resource so that removing either side severs access. Which TWO policy configurations together deliver this cross-account least-privilege read? (Select TWO.)

  • AAttach an identity-based policy to the processing account's IAM role that allows s3:GetObject and s3:ListBucket on only the specific bucket and its objects, granting the role the minimum read actions it needs against that one resource. Correct
  • BAttach a bucket policy in the data account that allows the read actions only when the principal is the processing account's specific role ARN and denies all other principals, so the bucket accepts reads from that one role alone. Correct
  • CCreate an IAM user in the data account with read access to the bucket, generate an access key pair, and have the processing workload use those keys so the read happens with credentials issued by the bucket-owning account.
  • DAttach a permissions boundary to the processing role that lists the bucket as the only allowed resource, relying on the boundary alone to grant the cross-account read without any policy in the data account.
  • EEnable an AWS Organizations service control policy on the processing account that allows S3 read actions only against the data account's bucket, treating the SCP as the grant that opens the cross-account path.
Grant cross-account S3 access by pairing a scoped identity-based policy on the reading role with a bucket policy that trusts only that role, using temporary credentials. Cross-account S3 access requires permission on both sides: an identity-based policy on the processing role scoped to the read actions on the one bucket, and a bucket policy in the owning account that allows only that named role and denies all others. Because both must permit the call, removing either side severs access, and the role uses temporary credentials so no long-lived keys exist. An IAM user with access keys breaks the temporary-credential rule, while permissions boundaries and service control policies only cap or filter permissions and never grant cross-account access.

Why A is correct: An identity-based policy scoped to s3:GetObject and s3:ListBucket on just that bucket grants the role only the read actions it needs on the single resource, satisfying the identity side of least privilege with temporary role credentials.

Why B is correct: A bucket policy that allows the read actions only for the named processing role and denies everyone else enforces the resource side, so the bucket trusts exactly one principal and cross-account access requires both policies to permit it.

Why C is wrong: An access key pair is a long-lived credential the requirement forbids, and using a data-account IAM user removes the dual identity-and-resource enforcement, so this fails both the temporary-credential and least-privilege constraints.

Why D is wrong: A permissions boundary only caps what an identity policy can grant and never itself confers access, and it cannot authorise access to a resource owned by another account, so it cannot deliver the cross-account read on its own.

Why E is wrong: A service control policy can only filter or deny permissions that an identity policy already grants and never itself grants access, so an SCP cannot create the cross-account read and is the wrong control type for this grant.

Other domains in this exam

See also the SAP-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.