Amazon AWS Certified Solutions Architect - Associate SAA-C03 Bundle

The option Use AWS Schema Conversion Tool with AWS DMS as appropriate addresses a separate condition: a proprietary database must move to PostgreSQL with schema conversion. Heterogeneous migration requires schema translation and data movement. The actual requirement is large ongoing DMS replication traffic unexpectedly costs more than planned. Recommended corrective action: Scope replication tasks and stop resources after cutover. Continuous replication should end when no longer required.

Use AWS DMS for compatible homogeneous data movement would help if a managed MySQL database is migrated to RDS MySQL without changing schema. DMS supports database migration with ongoing replication options. That is not the symptom described here: large ongoing DMS replication traffic unexpectedly costs more than planned. The matching response is Scope replication tasks and stop resources after cutover, because continuous replication should end when no longer required.

For the alternative failure a one-time small SQL database transfer is planned but teams provision a permanent DMS fleet, the control Compare snapshot/backup restore or native migration tools for small one-off moves is relevant: one-time migrations may not justify ongoing infrastructure. Here the evidence instead is large ongoing DMS replication traffic unexpectedly costs more than planned. The selected technical mechanism is Scope replication tasks and stop resources after cutover: continuous replication should end when no longer required.

Store compressed columnar Parquet data and query with Athena or Redshift Spectrum as appropriate would help if most reports scan only a few columns of historical data kept as CSV. Columnar formats avoid scanning unused columns. That is not the symptom described here: a warehouse sits mostly idle but uses dedicated nodes 24/7. The matching response is Evaluate Redshift Serverless if usage is intermittent and cost-effective, because demand-driven warehouse capacity can reduce idle node expense.

Configure snapshot lifecycle and delete permitted obsolete copies solves a different operational problem where retained Redshift snapshots exceed recovery policy by many months. Snapshot storage grows without governance. It does not directly address a warehouse sits mostly idle but uses dedicated nodes 24/7. The case calls for Evaluate Redshift Serverless if usage is intermittent and cost-effective, since demand-driven warehouse capacity can reduce idle node expense.

The competing option Optimize table sort/distribution keys based on query patterns would be useful when a loaded table has no useful sort/distribution layout and queries scan enormous data. Good physical layout reduces processing resource use. The present issue is a warehouse sits mostly idle but uses dedicated nodes 24/7; it is more directly addressed by Evaluate Redshift Serverless if usage is intermittent and cost-effective. Demand-driven warehouse capacity can reduce idle node expense.

For the alternative failure most reports scan only a few columns of historical data kept as CSV, the control Store compressed columnar Parquet data and query with Athena or Redshift Spectrum as appropriate is relevant: columnar formats avoid scanning unused columns. Here the evidence instead is a loaded table has no useful sort/distribution layout and queries scan enormous data. The selected technical mechanism is Optimize table sort/distribution keys based on query patterns: good physical layout reduces processing resource use.

Configure snapshot lifecycle and delete permitted obsolete copies solves a different operational problem where retained Redshift snapshots exceed recovery policy by many months. Snapshot storage grows without governance. It does not directly address a loaded table has no useful sort/distribution layout and queries scan enormous data. The case calls for Optimize table sort/distribution keys based on query patterns, since good physical layout reduces processing resource use.

The option Evaluate Redshift Serverless if usage is intermittent and cost-effective addresses a separate condition: a warehouse sits mostly idle but uses dedicated nodes 24/7. Demand-driven warehouse capacity can reduce idle node expense. The actual requirement is a loaded table has no useful sort/distribution layout and queries scan enormous data. Recommended corrective action: Optimize table sort/distribution keys based on query patterns. Good physical layout reduces processing resource use.

Optimize table sort/distribution keys based on query patterns solves a different operational problem where a loaded table has no useful sort/distribution layout and queries scan enormous data. Good physical layout reduces processing resource use. It does not directly address most reports scan only a few columns of historical data kept as CSV. The case calls for Store compressed columnar Parquet data and query with Athena or Redshift Spectrum as appropriate, since columnar formats avoid scanning unused columns.

The competing option Evaluate Redshift Serverless if usage is intermittent and cost-effective would be useful when a warehouse sits mostly idle but uses dedicated nodes 24/7. Demand-driven warehouse capacity can reduce idle node expense. The present issue is most reports scan only a few columns of historical data kept as CSV; it is more directly addressed by Store compressed columnar Parquet data and query with Athena or Redshift Spectrum as appropriate. Columnar formats avoid scanning unused columns.

The option Move transactional writes to an appropriate relational/NoSQL database addresses a separate condition: an OLTP app uses Redshift for each small per-item update. Warehouses are inefficient as general OLTP engines. The actual requirement is most reports scan only a few columns of historical data kept as CSV. Recommended corrective action: Store compressed columnar Parquet data and query with Athena or Redshift Spectrum as appropriate. Columnar formats avoid scanning unused columns.

The competing option Evaluate Redshift Serverless if usage is intermittent and cost-effective would be useful when a warehouse sits mostly idle but uses dedicated nodes 24/7. Demand-driven warehouse capacity can reduce idle node expense. The present issue is an OLTP app uses Redshift for each small per-item update; it is more directly addressed by Move transactional writes to an appropriate relational/NoSQL database. Warehouses are inefficient as general OLTP engines.

The option Store compressed columnar Parquet data and query with Athena or Redshift Spectrum as appropriate addresses a separate condition: most reports scan only a few columns of historical data kept as CSV. Columnar formats avoid scanning unused columns. The actual requirement is an OLTP app uses Redshift for each small per-item update. Recommended corrective action: Move transactional writes to an appropriate relational/NoSQL database. Warehouses are inefficient as general OLTP engines.

Optimize table sort/distribution keys based on query patterns would help if a loaded table has no useful sort/distribution layout and queries scan enormous data. Good physical layout reduces processing resource use. That is not the symptom described here: an OLTP app uses Redshift for each small per-item update. The matching response is Move transactional writes to an appropriate relational/NoSQL database, because warehouses are inefficient as general OLTP engines.

Store compressed columnar Parquet data and query with Athena or Redshift Spectrum as appropriate would help if most reports scan only a few columns of historical data kept as CSV. Columnar formats avoid scanning unused columns. That is not the symptom described here: retained Redshift snapshots exceed recovery policy by many months. The matching response is Configure snapshot lifecycle and delete permitted obsolete copies, because snapshot storage grows without governance.

For the alternative failure a loaded table has no useful sort/distribution layout and queries scan enormous data, the control Optimize table sort/distribution keys based on query patterns is relevant: good physical layout reduces processing resource use. Here the evidence instead is retained Redshift snapshots exceed recovery policy by many months. The selected technical mechanism is Configure snapshot lifecycle and delete permitted obsolete copies: snapshot storage grows without governance.

Move transactional writes to an appropriate relational/NoSQL database solves a different operational problem where an OLTP app uses Redshift for each small per-item update. Warehouses are inefficient as general OLTP engines. It does not directly address retained Redshift snapshots exceed recovery policy by many months. The case calls for Configure snapshot lifecycle and delete permitted obsolete copies, since snapshot storage grows without governance.

Use DynamoDB TTL and bounded retention workflows would help if unused old events remain in DynamoDB tables forever. TTL removes eligible expired items. That is not the symptom described here: high-frequency identical reads of catalog items consume most DynamoDB RCUs. The matching response is Evaluate DAX or application ElastiCache where staleness is acceptable, because cached reads reduce origin read requests.

For the alternative failure provisioned throughput remains high overnight despite low traffic, the control Set DynamoDB target-tracking auto scaling or use on-demand based on patterns is relevant: adaptive capacity mode reduces idle provisioned spend. Here the evidence instead is high-frequency identical reads of catalog items consume most DynamoDB RCUs. The selected technical mechanism is Evaluate DAX or application ElastiCache where staleness is acceptable: cached reads reduce origin read requests.

The competing option Store large objects in S3 and retain references in DynamoDB would be useful when every item includes huge rarely used blobs and bloats read capacity. Splitting large blobs can reduce item size and read cost. The present issue is high-frequency identical reads of catalog items consume most DynamoDB RCUs; it is more directly addressed by Evaluate DAX or application ElastiCache where staleness is acceptable. Cached reads reduce origin read requests.

For the alternative failure unused old events remain in DynamoDB tables forever, the control Use DynamoDB TTL and bounded retention workflows is relevant: tTL removes eligible expired items. Here the evidence instead is the app needs strongly consistent reads after every write. The selected technical mechanism is Use DynamoDB consistent reads where required instead of relying on stale caches: strong consistency may be needed for immediate correctness.

The competing option Evaluate DAX or application ElastiCache where staleness is acceptable would be useful when high-frequency identical reads of catalog items consume most DynamoDB RCUs. Cached reads reduce origin read requests. The present issue is the app needs strongly consistent reads after every write; it is more directly addressed by Use DynamoDB consistent reads where required instead of relying on stale caches. Strong consistency may be needed for immediate correctness.

The option Store large objects in S3 and retain references in DynamoDB addresses a separate condition: every item includes huge rarely used blobs and bloats read capacity. Splitting large blobs can reduce item size and read cost. The actual requirement is the app needs strongly consistent reads after every write. Recommended corrective action: Use DynamoDB consistent reads where required instead of relying on stale caches. Strong consistency may be needed for immediate correctness.

Evaluate DAX or application ElastiCache where staleness is acceptable solves a different operational problem where high-frequency identical reads of catalog items consume most DynamoDB RCUs. Cached reads reduce origin read requests. It does not directly address every item includes huge rarely used blobs and bloats read capacity. The case calls for Store large objects in S3 and retain references in DynamoDB, since splitting large blobs can reduce item size and read cost.

The option Set DynamoDB target-tracking auto scaling or use on-demand based on patterns addresses a separate condition: provisioned throughput remains high overnight despite low traffic. Adaptive capacity mode reduces idle provisioned spend. The actual requirement is every item includes huge rarely used blobs and bloats read capacity. Recommended corrective action: Store large objects in S3 and retain references in DynamoDB. Splitting large blobs can reduce item size and read cost.

Use DynamoDB consistent reads where required instead of relying on stale caches would help if the app needs strongly consistent reads after every write. Strong consistency may be needed for immediate correctness. That is not the symptom described here: every item includes huge rarely used blobs and bloats read capacity. The matching response is Store large objects in S3 and retain references in DynamoDB, because splitting large blobs can reduce item size and read cost.

The competing option Evaluate DAX or application ElastiCache where staleness is acceptable would be useful when high-frequency identical reads of catalog items consume most DynamoDB RCUs. Cached reads reduce origin read requests. The present issue is unused old events remain in DynamoDB tables forever; it is more directly addressed by Use DynamoDB TTL and bounded retention workflows. TTL removes eligible expired items.

The option Set DynamoDB target-tracking auto scaling or use on-demand based on patterns addresses a separate condition: provisioned throughput remains high overnight despite low traffic. Adaptive capacity mode reduces idle provisioned spend. The actual requirement is unused old events remain in DynamoDB tables forever. Recommended corrective action: Use DynamoDB TTL and bounded retention workflows. TTL removes eligible expired items.

Use DynamoDB consistent reads where required instead of relying on stale caches would help if the app needs strongly consistent reads after every write. Strong consistency may be needed for immediate correctness. That is not the symptom described here: unused old events remain in DynamoDB tables forever. The matching response is Use DynamoDB TTL and bounded retention workflows, because tTL removes eligible expired items.

Store large objects in S3 and retain references in DynamoDB would help if every item includes huge rarely used blobs and bloats read capacity. Splitting large blobs can reduce item size and read cost. That is not the symptom described here: provisioned throughput remains high overnight despite low traffic. The matching response is Set DynamoDB target-tracking auto scaling or use on-demand based on patterns, because adaptive capacity mode reduces idle provisioned spend.

For the alternative failure the app needs strongly consistent reads after every write, the control Use DynamoDB consistent reads where required instead of relying on stale caches is relevant: strong consistency may be needed for immediate correctness. Here the evidence instead is provisioned throughput remains high overnight despite low traffic. The selected technical mechanism is Set DynamoDB target-tracking auto scaling or use on-demand based on patterns: adaptive capacity mode reduces idle provisioned spend.

Use DynamoDB TTL and bounded retention workflows solves a different operational problem where unused old events remain in DynamoDB tables forever. TTL removes eligible expired items. It does not directly address provisioned throughput remains high overnight despite low traffic. The case calls for Set DynamoDB target-tracking auto scaling or use on-demand based on patterns, since adaptive capacity mode reduces idle provisioned spend.