Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

The option Use RDS Proxy with tuned pool sizing and application connection reuse addresses a separate condition: a burst of Lambda invocations exhausts database connection limits. Proxy pools connections for bursty clients. The actual requirement is a database query becomes slow after adding missing index columns. Recommended corrective action: Analyze query plans and implement appropriate indexes on frequently filtered columns. Indexing can reduce scanned rows for selective queries.

Route consistency-critical reads to the writer would help if the read replica serves stale results when the application requires immediate read-after-write consistency. Asynchronous replicas can lag the primary. That is not the symptom described here: a database query becomes slow after adding missing index columns. The matching response is Analyze query plans and implement appropriate indexes on frequently filtered columns, because indexing can reduce scanned rows for selective queries.

For the alternative failure a reporting workload saturates the primary RDS database with SELECT queries, the control Add supported RDS read replicas and direct read-only traffic to them is relevant: read replicas offload reads from the writer. Here the evidence instead is a database query becomes slow after adding missing index columns. The selected technical mechanism is Analyze query plans and implement appropriate indexes on frequently filtered columns: indexing can reduce scanned rows for selective queries.

For the alternative failure a sparse secondary lookup must avoid scanning all primary records, the control Define a suitable sparse GSI with required projected attributes is relevant: sparse GSIs index only items that have the index key attributes. Here the evidence instead is most writes target one partition key and trigger hot-key throttling. The selected technical mechanism is Redesign partition-key distribution or apply write sharding where appropriate: distributing keys spreads work across partitions.

Choose a key schema or GSI supporting the customer access pattern solves a different operational problem where a query needs every item for a customer but data is only accessible by scan. Key-based queries avoid full table scans. It does not directly address most writes target one partition key and trigger hot-key throttling. The case calls for Redesign partition-key distribution or apply write sharding where appropriate, since distributing keys spreads work across partitions.

The competing option Use DynamoDB global tables with conflict handling expectations would be useful when a global service needs local-region DynamoDB reads and writes. Global tables provide multi-region replication and local access. The present issue is most writes target one partition key and trigger hot-key throttling; it is more directly addressed by Redesign partition-key distribution or apply write sharding where appropriate. Distributing keys spreads work across partitions.

For the alternative failure a global service needs local-region DynamoDB reads and writes, the control Use DynamoDB global tables with conflict handling expectations is relevant: global tables provide multi-region replication and local access. Here the evidence instead is a query needs every item for a customer but data is only accessible by scan. The selected technical mechanism is Choose a key schema or GSI supporting the customer access pattern: key-based queries avoid full table scans.

Define a suitable sparse GSI with required projected attributes solves a different operational problem where a sparse secondary lookup must avoid scanning all primary records. Sparse GSIs index only items that have the index key attributes. It does not directly address a query needs every item for a customer but data is only accessible by scan. The case calls for Choose a key schema or GSI supporting the customer access pattern, since key-based queries avoid full table scans.

The competing option Redesign partition-key distribution or apply write sharding where appropriate would be useful when most writes target one partition key and trigger hot-key throttling. Distributing keys spreads work across partitions. The present issue is a query needs every item for a customer but data is only accessible by scan; it is more directly addressed by Choose a key schema or GSI supporting the customer access pattern. Key-based queries avoid full table scans.

Redesign partition-key distribution or apply write sharding where appropriate solves a different operational problem where most writes target one partition key and trigger hot-key throttling. Distributing keys spreads work across partitions. It does not directly address an application needs predictable low latency for frequent key-value lookups. The case calls for Use DynamoDB with an appropriate partition and sort key design, since dynamoDB optimizes primary-key access at scale.

The competing option Define a suitable sparse GSI with required projected attributes would be useful when a sparse secondary lookup must avoid scanning all primary records. Sparse GSIs index only items that have the index key attributes. The present issue is an application needs predictable low latency for frequent key-value lookups; it is more directly addressed by Use DynamoDB with an appropriate partition and sort key design. DynamoDB optimizes primary-key access at scale.

Choose a key schema or GSI supporting the customer access pattern would help if a query needs every item for a customer but data is only accessible by scan. Key-based queries avoid full table scans. That is not the symptom described here: an application needs predictable low latency for frequent key-value lookups. The matching response is Use DynamoDB with an appropriate partition and sort key design, because dynamoDB optimizes primary-key access at scale.

The option Redesign partition-key distribution or apply write sharding where appropriate addresses a separate condition: most writes target one partition key and trigger hot-key throttling. Distributing keys spreads work across partitions. The actual requirement is a sparse secondary lookup must avoid scanning all primary records. Recommended corrective action: Define a suitable sparse GSI with required projected attributes. Sparse GSIs index only items that have the index key attributes.

Choose a key schema or GSI supporting the customer access pattern would help if a query needs every item for a customer but data is only accessible by scan. Key-based queries avoid full table scans. That is not the symptom described here: a sparse secondary lookup must avoid scanning all primary records. The matching response is Define a suitable sparse GSI with required projected attributes, because sparse GSIs index only items that have the index key attributes.

For the alternative failure an application needs predictable low latency for frequent key-value lookups, the control Use DynamoDB with an appropriate partition and sort key design is relevant: dynamoDB optimizes primary-key access at scale. Here the evidence instead is a sparse secondary lookup must avoid scanning all primary records. The selected technical mechanism is Define a suitable sparse GSI with required projected attributes: sparse GSIs index only items that have the index key attributes.

Redesign partition-key distribution or apply write sharding where appropriate would help if most writes target one partition key and trigger hot-key throttling. Distributing keys spreads work across partitions. That is not the symptom described here: a global service needs local-region DynamoDB reads and writes. The matching response is Use DynamoDB global tables with conflict handling expectations, because global tables provide multi-region replication and local access.

For the alternative failure a sparse secondary lookup must avoid scanning all primary records, the control Define a suitable sparse GSI with required projected attributes is relevant: sparse GSIs index only items that have the index key attributes. Here the evidence instead is a global service needs local-region DynamoDB reads and writes. The selected technical mechanism is Use DynamoDB global tables with conflict handling expectations: global tables provide multi-region replication and local access.

Choose a key schema or GSI supporting the customer access pattern solves a different operational problem where a query needs every item for a customer but data is only accessible by scan. Key-based queries avoid full table scans. It does not directly address a global service needs local-region DynamoDB reads and writes. The case calls for Use DynamoDB global tables with conflict handling expectations, since global tables provide multi-region replication and local access.

For the alternative failure application code requires an in-memory Redis-compatible data structure, the control Choose Amazon ElastiCache for Redis-compatible engines or MemoryDB as durability requires is relevant: managed Redis-compatible engines support structured in-memory access. Here the evidence instead is a product catalog repeatedly runs the same read queries with no near-term updates. The selected technical mechanism is Cache query results in ElastiCache with a bounded TTL: hot cache hits avoid repeated database work.

Invalidate or update cache entries on price mutations solves a different operational problem where product prices change and cached responses stay stale for hours. Cache consistency depends on update policy. It does not directly address a product catalog repeatedly runs the same read queries with no near-term updates. The case calls for Cache query results in ElastiCache with a bounded TTL, since hot cache hits avoid repeated database work.

The competing option Add request coalescing and cache warming with bounded origin calls would be useful when a surge of cache misses overwhelms Aurora. Thundering herd mitigation protects underlying databases. The present issue is a product catalog repeatedly runs the same read queries with no near-term updates; it is more directly addressed by Cache query results in ElastiCache with a bounded TTL. Hot cache hits avoid repeated database work.

For the alternative failure an authoritative transaction record must survive cache node loss, the control Persist transaction data in a database rather than treating cache as authoritative is relevant: caching infrastructure is not a transactional system of record. Here the evidence instead is product prices change and cached responses stay stale for hours. The selected technical mechanism is Invalidate or update cache entries on price mutations: cache consistency depends on update policy.

Cache query results in ElastiCache with a bounded TTL solves a different operational problem where a product catalog repeatedly runs the same read queries with no near-term updates. Hot cache hits avoid repeated database work. It does not directly address product prices change and cached responses stay stale for hours. The case calls for Invalidate or update cache entries on price mutations, since cache consistency depends on update policy.

The competing option Choose Amazon ElastiCache for Redis-compatible engines or MemoryDB as durability requires would be useful when application code requires an in-memory Redis-compatible data structure. Managed Redis-compatible engines support structured in-memory access. The present issue is product prices change and cached responses stay stale for hours; it is more directly addressed by Invalidate or update cache entries on price mutations. Cache consistency depends on update policy.

Add request coalescing and cache warming with bounded origin calls solves a different operational problem where a surge of cache misses overwhelms Aurora. Thundering herd mitigation protects underlying databases. It does not directly address application code requires an in-memory Redis-compatible data structure. The case calls for Choose Amazon ElastiCache for Redis-compatible engines or MemoryDB as durability requires, since managed Redis-compatible engines support structured in-memory access.

The competing option Invalidate or update cache entries on price mutations would be useful when product prices change and cached responses stay stale for hours. Cache consistency depends on update policy. The present issue is application code requires an in-memory Redis-compatible data structure; it is more directly addressed by Choose Amazon ElastiCache for Redis-compatible engines or MemoryDB as durability requires. Managed Redis-compatible engines support structured in-memory access.

Persist transaction data in a database rather than treating cache as authoritative would help if an authoritative transaction record must survive cache node loss. Caching infrastructure is not a transactional system of record. That is not the symptom described here: application code requires an in-memory Redis-compatible data structure. The matching response is Choose Amazon ElastiCache for Redis-compatible engines or MemoryDB as durability requires, because managed Redis-compatible engines support structured in-memory access.

The competing option Choose Amazon ElastiCache for Redis-compatible engines or MemoryDB as durability requires would be useful when application code requires an in-memory Redis-compatible data structure. Managed Redis-compatible engines support structured in-memory access. The present issue is an authoritative transaction record must survive cache node loss; it is more directly addressed by Persist transaction data in a database rather than treating cache as authoritative. Caching infrastructure is not a transactional system of record.

The option Cache query results in ElastiCache with a bounded TTL addresses a separate condition: a product catalog repeatedly runs the same read queries with no near-term updates. Hot cache hits avoid repeated database work. The actual requirement is an authoritative transaction record must survive cache node loss. Recommended corrective action: Persist transaction data in a database rather than treating cache as authoritative. Caching infrastructure is not a transactional system of record.

Invalidate or update cache entries on price mutations would help if product prices change and cached responses stay stale for hours. Cache consistency depends on update policy. That is not the symptom described here: an authoritative transaction record must survive cache node loss. The matching response is Persist transaction data in a database rather than treating cache as authoritative, because caching infrastructure is not a transactional system of record.

Choose Amazon ElastiCache for Redis-compatible engines or MemoryDB as durability requires would help if application code requires an in-memory Redis-compatible data structure. Managed Redis-compatible engines support structured in-memory access. That is not the symptom described here: a surge of cache misses overwhelms Aurora. The matching response is Add request coalescing and cache warming with bounded origin calls, because thundering herd mitigation protects underlying databases.

For the alternative failure a product catalog repeatedly runs the same read queries with no near-term updates, the control Cache query results in ElastiCache with a bounded TTL is relevant: hot cache hits avoid repeated database work. Here the evidence instead is a surge of cache misses overwhelms Aurora. The selected technical mechanism is Add request coalescing and cache warming with bounded origin calls: thundering herd mitigation protects underlying databases.

Invalidate or update cache entries on price mutations solves a different operational problem where product prices change and cached responses stay stale for hours. Cache consistency depends on update policy. It does not directly address a surge of cache misses overwhelms Aurora. The case calls for Add request coalescing and cache warming with bounded origin calls, since thundering herd mitigation protects underlying databases.