Courseiva

CCNA Db Design Questions

75 of 444 questions · Page 5/6 · Db Design topic · Answers revealed

Practice these questionsExam hubAll questions
301
Multi-Selecteasy

Which TWO Amazon RDS features can be used to increase the availability of a production database?

Select 2 answers
A.Enhanced Monitoring and Performance Insights.
B.Cross-Region read replicas with automatic promotion.
C.Manual DB snapshot taken every hour.
D.Multi-AZ deployment with automatic failover.
E.Automated backups with a retention period of 35 days.
AnswersB, D

Read replicas can be promoted to primary if the source fails.

Why this answer

Option B is correct because cross-Region read replicas provide a secondary copy of the database in a different AWS Region, which can be manually promoted to a standalone primary instance in the event of a regional outage. This feature increases availability by enabling a disaster recovery strategy that goes beyond a single AWS Region, ensuring business continuity even if the entire primary Region becomes unavailable.

Exam trap

The trap here is that candidates often confuse monitoring features (Enhanced Monitoring, Performance Insights) or backup mechanisms (snapshots, automated backups) with high-availability features, failing to recognize that only Multi-AZ deployments and cross-Region read replicas (with promotion) provide actual failover capabilities to increase availability.

Practice this question →
302
MCQmedium

A database administrator runs the above command. The database is currently in a healthy state. Which statement is true about this database?

A.The database engine is Amazon Aurora
B.The database uses a burstable instance class
C.The database is deployed in a Multi-AZ configuration
D.The database has a read replica in another region
AnswerC

MultiAZ is true, so it has a standby in another AZ.

Why this answer

Option C is correct because the command output shows the database is in the 'creating' state with 'multi-az': True. This explicitly indicates that the database is being deployed in a Multi-AZ configuration, which provides high availability by synchronously replicating data to a standby instance in a different Availability Zone.

Exam trap

AWS often tests the distinction between Multi-AZ and read replicas, where candidates mistakenly think 'multi-az': True implies a read replica or cross-region setup, but Multi-AZ is solely for high availability within a single region, not for read scaling or disaster recovery across regions.

How to eliminate wrong answers

Option A is wrong because the command output does not specify the engine name; it only shows 'engine': 'mysql', which could be Amazon RDS for MySQL or Aurora MySQL, but without 'aurora' in the engine field or a cluster identifier, it is not confirmed as Aurora. Option B is wrong because the instance class 'db.t3.medium' is a burstable instance class, but the question asks for a true statement about the database state, and the command output shows 'multi-az': True, not the instance class type; the burstable nature is not directly indicated in the output. Option D is wrong because the output shows 'multi-az': True and 'read_replica': False, with no 'source_region' or 'replica_of' field; a cross-region read replica would require a different configuration and would not be indicated by the Multi-AZ setting.

Practice this question →
303
Multi-Selectmedium

A company is designing a global e-commerce platform using Amazon DynamoDB. The platform must support strong consistency for inventory updates and eventual consistency for product catalog reads. Which TWO design patterns should the company implement to meet these consistency requirements?

Select 2 answers
A.Configure DynamoDB Accelerator (DAX) for product catalog queries with eventual consistency.
B.Use Amazon ElastiCache for Redis to cache inventory data with strong consistency.
C.Use DynamoDB transactions for all inventory operations.
D.Use DynamoDB Streams to replicate inventory changes to a separate table for reads.
E.Enable DynamoDB global tables and use strongly consistent reads for inventory queries.
AnswersA, E

DAX provides low-latency eventually consistent reads for the catalog.

Why this answer

Option A is correct because DynamoDB Accelerator (DAX) is an in-memory cache that can be configured to return eventually consistent results for read-heavy workloads like product catalog queries, reducing read latency and cost while meeting the eventual consistency requirement. Option E is correct because DynamoDB global tables replicate data across regions, and using strongly consistent reads for inventory queries ensures that the most recent write is returned, which is critical for inventory accuracy.

Exam trap

The trap here is that candidates often assume DynamoDB transactions or Streams can provide strong consistency for reads, but transactions only guarantee atomic writes, and Streams are asynchronous, so neither meets the requirement for strongly consistent inventory reads.

Practice this question →
304
MCQmedium

A company runs a financial application that requires ACID transactions on a relational database. The workload has a high volume of writes and reads, and the team wants to minimize operational overhead. Which AWS database service should they choose?

A.Amazon RDS for Oracle
B.Amazon DynamoDB with transactions enabled
C.Amazon ElastiCache for Memcached
D.Amazon Aurora (MySQL-compatible)
AnswerD

Aurora offers ACID transactions, high performance, and managed service.

Why this answer

Option C is correct because Amazon Aurora provides MySQL/PostgreSQL compatibility with ACID transactions and higher throughput than standard RDS, reducing overhead. Option A is wrong because DynamoDB is NoSQL and does not support ACID across multiple items by default. Option B is wrong because ElastiCache is in-memory and not ACID-compliant.

Option D is wrong because RDS for Oracle requires licensing and more operational overhead compared to Aurora.

Practice this question →
305
Multi-Selectmedium

A company is designing a database for an analytics workload that requires storing 5 TB of data and running complex SQL queries with joins. The workload is read-heavy and requires high concurrency. Which TWO services are suitable for this workload? (Choose two.)

Select 2 answers
A.Amazon RDS for MySQL with read replicas
B.Amazon Redshift
C.Amazon ElastiCache for Redis
D.Amazon DynamoDB
E.Amazon S3
AnswersA, B

Supports joins and read replicas for concurrency.

Why this answer

Amazon RDS for MySQL with read replicas is suitable because the workload is read-heavy and requires high concurrency. Read replicas offload SELECT traffic from the primary instance, allowing complex SQL queries with joins to scale horizontally while maintaining ACID compliance for the 5 TB dataset.

Exam trap

The trap here is that candidates often confuse read-heavy OLTP workloads with analytical workloads, assuming ElastiCache or DynamoDB can handle complex SQL joins, when in fact they lack relational query capabilities and are designed for different access patterns.

Practice this question →
306
MCQmedium

A company is migrating an on-premises Oracle data warehouse to AWS. The warehouse contains 50 TB of data and runs complex queries that involve joins and aggregations. The team wants to minimize migration effort and cost while maintaining query performance. Which AWS service should they use?

A.Amazon RDS for Oracle
B.Amazon ElastiCache for Redis
C.Amazon Redshift
D.Amazon DynamoDB
AnswerC

Redshift is purpose-built for large-scale data warehousing and analytics.

Why this answer

Option C is correct because Amazon Redshift is a fully managed petabyte-scale data warehouse optimized for complex queries. Option A is wrong because RDS is for OLTP, not OLAP. Option B is wrong because ElastiCache is in-memory caching, not a data warehouse.

Option D is wrong because DynamoDB is NoSQL and not suited for complex joins.

Practice this question →
307
MCQmedium

A company runs an OLTP application on Amazon RDS for PostgreSQL. The database stores customer orders. The application frequently queries orders by customer_id and order_date. The orders table has 100 million rows. The query performance has degraded over time. The database has a single index on customer_id. The company needs to improve query performance without changing the application code. Which design change should be made?

A.Partition the table by order_date using PostgreSQL declarative partitioning.
B.Upgrade to a larger RDS instance type.
C.Enable RDS Performance Insights to identify bottlenecks.
D.Create a composite index on (customer_id, order_date).
AnswerD

A composite index supports queries filtering by both columns efficiently.

Why this answer

The query performance has degraded because the existing single-column index on customer_id can filter by customer but still requires a full sort or scan within that customer's rows to satisfy the order_date condition. Creating a composite index on (customer_id, order_date) allows the database to use a single index seek to locate the exact rows matching both columns, eliminating the need for an additional sort or filter pass. This directly addresses the query pattern without any application code changes.

Exam trap

The trap here is that candidates often choose partitioning (Option A) because they think it automatically speeds up queries, but without changing the query to leverage partition pruning, partitioning alone does not improve index-based lookups; the correct solution is to add a covering composite index that matches the query filter order.

How to eliminate wrong answers

Option A is wrong because partitioning by order_date would require rewriting queries to include partition pruning hints or rely on the query planner to eliminate partitions, which does not change the application code requirement and would not improve performance for queries filtering by customer_id without also including order_date in the index. Option B is wrong because upgrading to a larger instance type only adds more CPU and memory, which may mask the symptom but does not fix the root cause of missing index coverage for the query pattern. Option C is wrong because enabling Performance Insights only helps identify bottlenecks after they occur; it does not make any design change to improve query performance.

Practice this question →
308
MCQmedium

A company is designing a database for a global e-commerce application with millions of users. The workload requires single-digit millisecond read latency, high availability across multiple AWS Regions, and strong consistency. Which database service should the company use?

A.Amazon ElastiCache for Redis
B.Amazon Aurora Global Database
C.Amazon Neptune
D.Amazon DynamoDB with global tables
AnswerD

DynamoDB offers single-digit millisecond latency, global tables for multi-region replication, and strong consistency.

Why this answer

Amazon DynamoDB with global tables is the correct choice because it provides single-digit millisecond read latency at any scale, supports multi-Region active-active replication for high availability, and offers strongly consistent reads (when using the ConsistentRead parameter) across regions via its distributed, multi-leader architecture. This combination uniquely satisfies all three requirements—low latency, global HA, and strong consistency—for a high-traffic e-commerce workload.

Exam trap

The trap here is that candidates often confuse Amazon Aurora Global Database’s cross-Region replication with strong consistency, but Aurora Global Database only provides eventual consistency for reads from secondary regions, making it unsuitable when strong consistency is required across all regions.

How to eliminate wrong answers

Option A is wrong because Amazon ElastiCache for Redis is an in-memory cache that does not provide strong consistency (it is eventually consistent by default) and is not designed as a primary database for durable, strongly consistent reads across multiple AWS Regions. Option B is wrong because Amazon Aurora Global Database supports cross-Region replication but offers only eventual consistency for reads from secondary regions; it cannot provide strong consistency across regions, which is a strict requirement. Option C is wrong because Amazon Neptune is a graph database optimized for highly connected data (e.g., social networks, fraud detection) and does not offer multi-Region active-active replication or single-digit millisecond read latency for general-purpose e-commerce workloads.

Practice this question →
309
MCQmedium

A company is designing a database for a ride-sharing application that needs to store real-time driver locations and trip history. The application requires low-latency updates to driver locations (every few seconds) and the ability to query nearby drivers within a radius. The company expects millions of drivers and trips. Which AWS database service should the database specialist recommend for storing real-time driver locations and supporting proximity queries?

A.Amazon RDS for PostgreSQL with PostGIS extension
B.Amazon ElastiCache for Redis with geospatial data types
C.Amazon DynamoDB with a Geohash-based partition key and a Global Secondary Index
D.Amazon Timestream
AnswerC

DynamoDB can handle high throughput and geospatial queries via Geohash.

Why this answer

Amazon DynamoDB with a Geohash-based partition key and a Global Secondary Index is the correct choice because it provides the low-latency writes (single-digit milliseconds) required for updating driver locations every few seconds, while the Geohash-based key enables efficient proximity queries by grouping nearby drivers into the same partition. The Global Secondary Index allows querying by geohash prefix to find drivers within a radius, scaling to millions of drivers and trips with DynamoDB's auto-scaling and fully managed infrastructure.

Exam trap

The trap here is that candidates often choose Amazon ElastiCache for Redis because of its built-in geospatial commands (GEOADD/GEORADIUS), overlooking the requirement for durable trip history storage and the scalability limits of Redis when handling millions of concurrent updates and queries.

How to eliminate wrong answers

Option A is wrong because Amazon RDS for PostgreSQL with PostGIS, while capable of geospatial queries, cannot achieve the required low-latency writes at millions of updates per second due to its single-master architecture and ACID transaction overhead, making it unsuitable for real-time location updates every few seconds at scale. Option B is wrong because Amazon ElastiCache for Redis with geospatial data types is an in-memory cache, not a durable database; it lacks built-in persistence and durability guarantees for trip history, and its geospatial commands (GEOADD, GEORADIUS) are designed for smaller datasets and cannot reliably handle millions of drivers with consistent query performance. Option D is wrong because Amazon Timestream is a time-series database optimized for analyzing sequential data over time, not for low-latency point updates or geospatial proximity queries, and it does not support indexing or querying by geographic coordinates.

Practice this question →
310
MCQhard

A social media application stores user posts in an Amazon RDS for PostgreSQL instance. The application experiences a sudden spike in read traffic during peak hours, causing database bottlenecks. The team needs to improve read scalability without changing the application code. Which solution is MOST cost-effective?

A.Migrate to Amazon DynamoDB with DAX
B.Enable Multi-AZ on the RDS instance
C.Use Amazon RDS for PostgreSQL Read Replicas
D.Use Amazon ElastiCache to cache query results
AnswerC

Read Replicas offload read traffic; requires minor configuration but no application code changes.

Why this answer

Option C is correct because Amazon RDS for PostgreSQL Read Replicas allow you to offload read traffic from the primary DB instance to one or more read-only replicas, improving read scalability without any application code changes. This is the most cost-effective solution as it leverages the existing PostgreSQL engine and requires only minimal additional compute and storage costs for the replicas.

Exam trap

The trap here is that candidates often confuse Multi-AZ with read scalability, but Multi-AZ only provides failover redundancy and does not allow the standby to serve read traffic, whereas Read Replicas are specifically designed for read offloading.

How to eliminate wrong answers

Option A is wrong because migrating to Amazon DynamoDB with DAX would require significant application code changes to switch from a relational to a NoSQL data model, which violates the requirement of not changing the application code. Option B is wrong because enabling Multi-AZ on the RDS instance provides high availability and automatic failover, but it does not improve read scalability; the standby replica is not used for read traffic. Option D is wrong because using Amazon ElastiCache to cache query results would require application code modifications to implement caching logic, which contradicts the requirement of no application code changes.

Practice this question →
311
MCQhard

A company runs an online auction platform on AWS. The application uses Amazon DynamoDB as the primary database, with a table 'Auctions' that has a partition key 'auction_id' (String) and sort key 'end_time' (Number). The table also has a global secondary index (GSI) on 'status' (String) and 'current_bid' (Number). The application frequently queries for active auctions sorted by current bid. Recently, the team noticed that queries on the GSI for active auctions with a high current_bid are returning results slowly. The DynamoDB table has 10,000 write capacity units (WCU) and 30,000 read capacity units (RCU) provisioned. The GSI has 5,000 RCU provisioned. The team suspects throttling on the GSI. What is the most likely cause of the slow queries?

A.The GSI's provisioned RCU is insufficient due to hot partitions.
B.The GSI key schema is inefficient for the query pattern.
C.The table's WCU is too low, causing throttling on writes that affects reads.
D.The table's RCU is too low for the application's read load.
AnswerA

Hot partitions can throttle even if total RCU is not fully used.

Why this answer

Option C is correct because if the index key (status, current_bid) leads to hot partitions (e.g., many active auctions with similar current_bid), those partitions may be throttled even if overall provisioned RCU is not fully utilized. Option A is wrong because the table RCU is high, but index RCU is separate. Option B is wrong because there's no indication of WCU throttling for reads.

Option D is wrong because the index key design is not necessarily wrong; hot partitions cause throttling.

Practice this question →
312
MCQmedium

A developer sees the above key schema for the ProductCatalog table. Which query will be most efficient for retrieving a single item?

A.Query with Category = 'Books'
B.GetItem with ProductId = '123'
C.Scan the table and filter by ProductId
D.GetItem with ProductId = '123' and Category = 'Books'
AnswerD

Providing both keys uniquely identifies the item.

Why this answer

Option D is correct because the ProductCatalog table's primary key is a composite key of Category (partition key) and ProductId (sort key). A GetItem operation with both the partition key and sort key provides the most efficient direct access to a single item, as it uses the primary key to retrieve the item with exactly one read operation, without any filtering or scanning.

Exam trap

The trap here is that candidates often assume GetItem only needs the partition key, forgetting that for tables with a composite primary key (partition key and sort key), both are required to uniquely identify and retrieve a single item.

How to eliminate wrong answers

Option A is wrong because a Query with only Category='Books' would retrieve all items in that partition, requiring additional filtering to find a single item, and is less efficient than a direct GetItem. Option B is wrong because GetItem with only ProductId='123' is invalid without the partition key (Category); DynamoDB requires the full primary key (partition key and sort key) for a GetItem operation on a table with a composite key. Option C is wrong because scanning the entire table and filtering by ProductId is the least efficient approach, as it reads every item in the table and incurs high read capacity consumption, especially on large tables.

Practice this question →
313
MCQhard

A financial services company runs a critical PostgreSQL database on Amazon RDS. The database stores transaction records and requires point-in-time recovery (PITR) with a recovery window of 35 days. The database size is 500 GB and grows at 10 GB per day. The team wants to minimize storage costs while meeting the recovery SLA. Which backup strategy should they use?

A.Take manual snapshots every hour and retain for 35 days
B.Enable automated backups with a retention period of 35 days
C.Disable automated backups and use pg_dump to S3 daily
D.Use AWS Backup to copy snapshots to another region daily
AnswerB

Automated backups provide PITR and are cost-effective; RDS manages log storage.

Why this answer

Amazon RDS automated backups provide PITR within the retention period (up to 35 days). They store transaction logs continuously, allowing recovery to any second within the window. Option B is wrong because manual snapshots every hour would be expensive and cumbersome.

Option C is wrong because cross-region snapshots do not provide PITR and are for disaster recovery. Option D is wrong because disabling automated backups and using pg_dump would lose ability to recover to a specific point in time.

Practice this question →
314
Multi-Selecthard

A company is migrating a 3 TB Oracle database to Amazon Aurora PostgreSQL. The database has a heavy OLTP workload with many small transactions. The migration must have minimal downtime. Which TWO strategies should the company use? (Choose two.)

Select 2 answers
A.Convert the database to Amazon Aurora MySQL instead.
B.Create an Aurora read replica from the Oracle database.
C.Use AWS DMS with ongoing replication to capture and apply changes.
D.Use AWS Schema Conversion Tool (SCT) to convert the schema.
E.Set the target database to Amazon Aurora PostgreSQL.
AnswersC, E

Provides minimal downtime by replicating changes continuously.

Why this answer

Options A and D are correct. AWS DMS with ongoing replication allows minimal downtime by replicating changes from Oracle to Aurora. Using Aurora PostgreSQL provides better compatibility with Oracle via the Babelfish feature? Actually, Babelfish is for SQL Server, not Oracle.

But Aurora PostgreSQL supports many Oracle features. Option B is wrong because SCT helps assess but doesn't handle ongoing replication. Option C is wrong because converting to Aurora MySQL would require additional compatibility changes.

Option E is wrong because a read replica cannot be created from Oracle.

Practice this question →
315
Multi-Selecthard

A company runs an e-commerce platform on Amazon Aurora MySQL. The platform experiences high traffic during flash sales. To handle the load, they want to offload read traffic to read replicas. However, they are concerned about replication lag causing stale data for inventory checks. Which three strategies can reduce replication lag? (Choose three.)

Select 3 answers
A.Enable binary log replication with parallel apply on replicas.
B.Use a lower transaction isolation level (e.g., READ COMMITTED) on replicas.
C.Implement synchronous replication between writer and replicas.
D.Use Aurora Auto Scaling to add read replicas during peak traffic.
E.Increase the instance size of the writer instance.
AnswersA, B, D

Parallel apply speeds up replication.

Why this answer

Option A (Use Aurora Auto Scaling) is correct because it adds replicas to distribute load. Option B (Use Binary Log Replication with parallel apply) is correct because it improves replication throughput. Option D (Use lower isolation levels on replicas) is correct because it reduces locking and improves apply speed.

Option C is wrong because increasing instance size of replicas helps, but not of the writer; the bottleneck is replica apply. Option E is wrong because synchronous replication would impact write performance.

Practice this question →
316
MCQeasy

A company is using Amazon DynamoDB to store session data for a web application. The session data expires after 24 hours. Which DynamoDB feature should the company use to automatically delete expired items?

A.A retention policy on the DynamoDB table
B.DynamoDB Time to Live (TTL)
C.DynamoDB Streams
D.A scheduled AWS Lambda function that scans and deletes expired items
AnswerB

TTL automatically deletes expired items based on a timestamp attribute.

Why this answer

DynamoDB Time to Live (TTL) is the correct choice because it provides a cost-effective, fully managed mechanism to automatically delete expired items based on a timestamp attribute in the table. TTL works by comparing the current time to the epoch time value stored in the designated TTL attribute; when the value is in the past, DynamoDB marks the item for deletion, typically within 48 hours. This eliminates the need for custom code or additional AWS services, directly addressing the requirement to remove session data after 24 hours.

Exam trap

The trap here is that candidates may overcomplicate the solution by choosing a custom Lambda-based approach (Option D) or misidentifying Streams (Option C) as a deletion mechanism, when DynamoDB's native TTL feature is the simplest, most cost-effective, and fully managed answer.

How to eliminate wrong answers

Option A is wrong because DynamoDB does not support a native 'retention policy' on tables; retention policies are a feature of services like Amazon S3 or CloudWatch Logs, not DynamoDB. Option C is wrong because DynamoDB Streams capture item-level changes (inserts, updates, deletes) in near-real-time but do not themselves delete items; they are a notification mechanism, not a data lifecycle management feature. Option D is wrong because while a scheduled Lambda function that scans and deletes expired items could technically work, it is an inefficient, custom solution that consumes read/write capacity and incurs additional cost and complexity, whereas TTL provides the same functionality natively and at no extra cost.

Practice this question →
317
MCQhard

A company is designing a multi-tenant SaaS application using Amazon Aurora PostgreSQL. Each tenant's data must be isolated for security and compliance. The application has a few large tenants and many small tenants. Queries must be able to access data across tenants for reporting, but with strict access controls. Which design best meets these requirements?

A.Use a single Aurora cluster with a separate schema per tenant and implement row-level security policies.
B.Create a separate database per tenant in the same Aurora cluster.
C.Create a separate Aurora cluster per tenant.
D.Use a single Aurora cluster with a single schema but add a tenant_id column to every table.
AnswerA

Schemas provide logical isolation and RLS enforces access controls per tenant.

Why this answer

Option A is correct because it uses a single Aurora cluster with a separate schema per tenant and row-level security (RLS) policies. This design provides strong tenant isolation at the schema level while allowing cross-tenant reporting queries with strict access controls enforced by RLS policies, which automatically filter rows based on the current session's tenant context. It balances security, compliance, and operational efficiency for a mix of large and small tenants.

Exam trap

The trap here is that candidates often assume that physical separation (separate clusters or databases) is always required for compliance, but Aurora PostgreSQL's row-level security can provide logical isolation that meets security requirements while enabling efficient cross-tenant reporting.

How to eliminate wrong answers

Option B is wrong because creating a separate database per tenant in the same Aurora cluster does not provide sufficient isolation for security and compliance; databases in the same cluster share the same underlying storage and can be accessed by any user with appropriate privileges, and cross-database queries are cumbersome and less secure. Option C is wrong because creating a separate Aurora cluster per tenant introduces significant operational overhead, cost, and complexity, especially for many small tenants, and makes cross-tenant reporting queries extremely difficult without complex federated query mechanisms. Option D is wrong because using a single schema with a tenant_id column on every table lacks native isolation; it requires application-level filtering that can be bypassed, does not enforce strict access controls at the database level, and makes it harder to manage tenant-specific data lifecycle and compliance requirements.

Practice this question →
318
MCQhard

A company uses Amazon RDS for MySQL with Multi-AZ and read replicas. The database has a table storing user sessions with 50 million rows. The application team reports that queries using 'SELECT * FROM sessions WHERE user_id = ? ORDER BY login_time DESC LIMIT 10' are slow. The EXPLAIN plan shows a full table scan. Which design change would BEST improve query performance?

A.Implement an application-level cache using ElastiCache
B.Create a composite index on (user_id, login_time)
C.Partition the table by user_id
D.Upgrade to a larger instance type with more memory
AnswerB

This index covers both the WHERE and ORDER BY clauses.

Why this answer

Option A is correct because a composite index on (user_id, login_time) allows the database to find rows by user and order by time without scanning. Option B is wrong because increasing instance size does not address the missing index. Option C is wrong because caching may help but does not fix the root cause.

Option D is wrong because partitioning by user_id may help, but a composite index is more effective for this specific query.

Practice this question →
319
MCQhard

A gaming company uses Amazon DynamoDB to store player scores. The table has a partition key of 'game_id' and a sort key of 'player_id'. They notice that during peak hours, write requests for a popular game 'g123' are throttled, while other games are unaffected. What is the most likely cause and solution?

A.Enable DynamoDB Accelerator (DAX) to cache writes.
B.The write capacity is too low; increase the table's write capacity units.
C.Use a composite partition key with a random suffix to distribute writes.
D.Enable auto-scaling on the table to handle burst write traffic.
AnswerC

Write sharding spreads writes across partitions, avoiding a hot key.

Why this answer

Option D is correct because the partition key 'game_id' causes a hot partition for game 'g123'. Using a write shard pattern distributes writes across multiple partitions. Option A (increase WCUs) may not help if the partition is hot.

Option B (DAX) is for reads, not writes. Option C (auto-scaling) won't solve hot partition issue.

Practice this question →
320
Multi-Selecthard

Which TWO are best practices for designing a DynamoDB table for high-traffic e-commerce application? (Select TWO.)

Select 2 answers
A.Create Global Secondary Indexes to support different access patterns.
B.Use a constantly increasing value (e.g., timestamp) as the partition key.
C.Design the table to use scan operations for most queries.
D.Use a composite primary key (partition key and sort key) to organize data.
E.Use a single attribute as the partition key with low cardinality.
AnswersA, D

GSIs allow querying on non-key attributes.

Why this answer

Option A is correct because Global Secondary Indexes (GSIs) allow you to support multiple query patterns without duplicating data or redesigning the base table. In a high-traffic e-commerce application, you might need to query orders by customer ID, by status, or by date; GSIs provide alternative access patterns with their own partition and sort keys, enabling efficient queries without full table scans.

Exam trap

The trap here is that candidates often think a monotonically increasing partition key (like a timestamp) is acceptable for time-series data, but in DynamoDB it creates a hot partition, whereas in other databases it might be fine; Cisco tests your understanding of DynamoDB's partitioning model and the importance of high-cardinality, evenly distributed partition keys.

Practice this question →
321
Multi-Selecteasy

Which TWO use cases are best suited for Amazon RDS Multi-AZ deployments? (Choose 2.)

Select 1 answer
A.Offloading read traffic from the primary database
B.Disaster recovery across AWS Regions
C.Improving write performance for a write-intensive workload
D.Scaling read capacity for a read-heavy application
E.Ensuring database availability during an Availability Zone outage
AnswersE

Multi-AZ provides automatic failover to a standby in another AZ.

Why this answer

Option E is correct because Amazon RDS Multi-AZ deployments automatically provision and maintain a synchronous standby replica in a different Availability Zone (AZ). If the primary DB instance fails or the AZ becomes unavailable, Amazon RDS automatically fails over to the standby replica, ensuring database availability with minimal downtime. This is the primary purpose of Multi-AZ: high availability and automatic failover, not performance scaling.

Exam trap

The trap here is that candidates confuse Multi-AZ (synchronous replication for high availability) with Read Replicas (asynchronous replication for read scaling), leading them to incorrectly select options about offloading reads or scaling read capacity.

Practice this question →
322
Multi-Selecthard

Which TWO techniques can reduce read latency for frequently accessed data in Amazon DynamoDB? (Choose 2.)

Select 2 answers
A.Use strongly consistent reads
B.Increase write capacity units
C.Decrease read capacity units
D.Add Global Secondary Indexes (GSI) for common query patterns
E.Enable DynamoDB Accelerator (DAX)
AnswersD, E

GSIs can provide efficient access to data.

Why this answer

Adding Global Secondary Indexes (GSI) allows you to pre-materialize alternative query patterns, enabling efficient lookups on non-key attributes without scanning the entire table. This reduces read latency for frequently accessed data by providing a pre-sorted and partitioned index that DynamoDB can query directly, avoiding expensive full-table scans.

Exam trap

The trap here is that candidates often confuse strongly consistent reads with performance optimization, not realizing that consistency guarantees come at the cost of higher latency, not lower.

Practice this question →
323
MCQeasy

A company is migrating an on-premises MySQL database to Amazon RDS. The database is used for a critical e-commerce application that requires high availability with automatic failover. Which RDS deployment option should the company choose to meet these requirements?

A.Multi-Region deployment with Read Replicas
B.Single-AZ instance with a standby in the same AZ
C.Multi-AZ deployment with a standby in a different AZ
D.Single-AZ instance with a Read Replica
AnswerC

Multi-AZ provides automatic failover to a standby in a different AZ.

Why this answer

Option C is correct because a Multi-AZ deployment for Amazon RDS MySQL automatically provisions and maintains a synchronous standby replica in a different Availability Zone (AZ). In the event of an AZ failure or primary instance failure, Amazon RDS automatically fails over to the standby, providing high availability with minimal downtime. This meets the requirement for automatic failover without manual intervention.

Exam trap

The trap here is that candidates often confuse Multi-AZ with Read Replicas, assuming that a Read Replica can provide automatic failover, but in RDS MySQL, Read Replicas require manual promotion and do not offer synchronous replication or automatic failover.

How to eliminate wrong answers

Option A is wrong because Multi-Region deployment with Read Replicas is designed for disaster recovery across regions and does not provide automatic failover within a single region; failover would require manual promotion of a read replica. Option B is wrong because a Single-AZ instance with a standby in the same AZ is not supported by RDS; Multi-AZ requires the standby to be in a different AZ to protect against AZ-level failures. Option D is wrong because a Single-AZ instance with a Read Replica provides read scaling and can be manually promoted for disaster recovery, but it does not offer automatic failover or synchronous replication, which are required for high availability.

Practice this question →
324
MCQeasy

A company is designing a new application that requires a relational database with strong consistency and support for transactions. The application will be accessed by users worldwide, and the database must provide low-latency reads in multiple regions. The company expects the workload to be unpredictable, with periods of very low activity followed by sudden spikes. They want to minimize operational overhead and only pay for the resources they use. Which AWS database solution should they choose?

A.Amazon Redshift with cross-Region snapshots.
B.Amazon Aurora Serverless v2 with Aurora Global Database.
C.Amazon RDS for PostgreSQL with read replicas in multiple regions.
D.Amazon DynamoDB with Global Tables.
AnswerB

Aurora Serverless v2 automatically scales capacity, supports ACID transactions, and Global Database provides low-latency multi-region reads.

Why this answer

Amazon Aurora Serverless v2 is a good choice for unpredictable workloads because it auto-scales capacity based on demand and you pay only for what you use. It also supports Aurora Global Database for low-latency reads in multiple regions. RDS does not have serverless capability.

DynamoDB is serverless but not relational. Redshift is for analytics. So the best is Aurora Serverless v2 with Global Database.

Practice this question →
325
MCQhard

An IAM policy is attached to a user to restrict access to a DynamoDB table. What does this policy allow the user to do?

A.Read and write items only where the partition key equals 'customer_123'
B.Read and write any item in the Orders table
C.Scan the entire Orders table
D.Perform all DynamoDB actions on the Orders table
AnswerA

The condition restricts operations to items with LeadingKeys 'customer_123'.

Why this answer

The IAM policy uses a condition key `dynamodb:LeadingKeys` with a condition operator `ForAllValues:StringEquals` to restrict access to items where the partition key equals 'customer_123'. This allows the user to perform read and write operations only on items matching that specific partition key value, enforcing fine-grained access control at the item level.

Exam trap

The trap here is that candidates often assume a policy restricting access to a specific partition key still allows a full table Scan, but DynamoDB's fine-grained access control with `dynamodb:LeadingKeys` explicitly denies any operation that does not specify the allowed partition key, including Scans.

How to eliminate wrong answers

Option B is wrong because the policy explicitly restricts access to items with partition key 'customer_123', not any item in the table. Option C is wrong because a Scan operation would access all items in the table, which violates the partition key restriction; the policy does not allow scanning the entire table. Option D is wrong because the policy does not allow all DynamoDB actions; it only allows specific actions (like GetItem, PutItem, UpdateItem, DeleteItem, Query) conditioned on the partition key value, and actions like CreateTable or DeleteTable are not permitted.

Practice this question →
326
MCQhard

A company runs a multi-tenant SaaS application on Amazon RDS for PostgreSQL. Each tenant has an isolated database. Recently, the application experienced a sudden increase in connection errors and slow query performance. Amazon RDS instance metrics show high CPU utilization and a high number of database connections. The application uses connection pooling with PgBouncer running on an EC2 instance. The team suspects the issue is due to a few noisy tenants opening too many connections. The current architecture uses one RDS instance per tenant. The company wants to optimize for workload-specific database design to handle noisy tenants without affecting other tenants. Which design should be implemented to isolate noisy tenants and reduce costs?

A.Use RDS for PostgreSQL with pg_partman to partition data by tenant and implement connection limits per tenant using PostgreSQL advisory locks.
B.Replace RDS with Amazon Aurora PostgreSQL and use Aurora Auto Scaling to handle connection spikes.
C.Move all tenants to a single RDS instance with separate schemas and use RDS Proxy to manage connections.
D.Create separate RDS instances for large tenants and use a single RDS instance for small tenants, with PgBouncer connection pooling per instance.
AnswerD

This isolates noisy tenants on dedicated instances while consolidating small tenants, balancing isolation and cost.

Why this answer

Option D is correct because it directly addresses the need to isolate noisy tenants by creating separate RDS instances for large (noisy) tenants while consolidating small tenants onto a single instance, each fronted by its own PgBouncer connection pool. This design prevents a single tenant's connection surge from affecting others, optimizes costs by avoiding over-provisioning for all tenants, and aligns with workload-specific database design principles for multi-tenant SaaS on RDS for PostgreSQL.

Exam trap

The trap here is that candidates may assume a single shared database with connection pooling (Option C) or a fully managed scaling solution (Option B) can solve noisy neighbor problems, but the DBS-C01 exam tests the understanding that workload isolation requires separate database instances or dedicated resources, not just connection management or auto-scaling of a shared cluster.

How to eliminate wrong answers

Option A is wrong because pg_partman is for table partitioning, not connection isolation, and advisory locks do not enforce per-tenant connection limits at the database level—they are application-level coordination mechanisms, not a substitute for connection pooling or instance isolation. Option B is wrong because Aurora Auto Scaling scales the entire cluster, not per-tenant, so a noisy tenant would still consume shared resources and cause contention; it also does not inherently isolate tenants or reduce costs compared to the targeted instance-per-tenant-group approach. Option C is wrong because moving all tenants to a single RDS instance with separate schemas and using RDS Proxy still shares CPU, memory, and I/O across all tenants, so a noisy tenant can degrade performance for others; RDS Proxy manages connections but does not provide workload isolation.

Practice this question →
327
MCQmedium

A company is designing a database for an IoT application that ingests millions of small sensor readings per second. The data is append-only and queries are primarily time-based aggregations with low latency requirements (under 10 ms). Which AWS database service is most suitable for this workload?

A.Amazon DynamoDB
B.Amazon ElastiCache
C.Amazon Aurora
D.Amazon Timestream
AnswerD

Timestream is purpose-built for time-series data with fast ingestion and aggregation.

Why this answer

Option C is correct because Amazon Timestream is a time-series database optimized for IoT data with fast ingestion and low-latency aggregations. Option A (Aurora) is relational and not optimized for high-velocity time-series. Option B (DynamoDB) is key-value, not designed for time-series aggregations efficiently.

Option D (ElastiCache) is an in-memory cache, not designed for persistent time-series storage.

Practice this question →
328
Multi-Selecteasy

Which TWO AWS services can be used to implement a serverless database architecture for variable workloads?

Select 2 answers
A.Amazon Redshift
B.Amazon Aurora Serverless v2
C.Amazon RDS Proxy
D.Amazon ElastiCache
E.Amazon DynamoDB
AnswersB, E

Aurora Serverless automatically scales capacity.

Why this answer

Amazon Aurora Serverless v2 is correct because it automatically scales database capacity up or down based on application demand, providing a serverless architecture for variable workloads without the need to manage database instances. Amazon DynamoDB is correct because it is a fully managed NoSQL serverless database that automatically scales throughput and storage to handle variable workloads, requiring no server provisioning or management.

Exam trap

The trap here is that candidates often confuse Amazon RDS Proxy (a connection management service) with a serverless database, or assume Amazon Redshift can function as a serverless transactional database, when in fact it is a data warehouse requiring cluster provisioning.

Practice this question →
329
MCQeasy

A startup is building a mobile application that requires a database to store user preferences and session data. The data is accessed by user ID and requires single-digit millisecond latency. The workload is read-heavy with occasional writes. Which database service is MOST cost-effective?

A.Amazon Aurora Serverless
B.Amazon ElastiCache for Memcached
C.Amazon DynamoDB with on-demand capacity
D.Amazon RDS for MySQL with provisioned IOPS
AnswerC

DynamoDB provides single-digit millisecond latency and is cost-effective for variable read-heavy workloads.

Why this answer

Amazon DynamoDB with on-demand capacity is the most cost-effective choice because it provides single-digit millisecond latency for key-value lookups by user ID, scales automatically to handle read-heavy workloads with occasional writes, and charges only for the reads and writes consumed, avoiding the cost of provisioning for peak capacity. The on-demand mode eliminates the need for capacity planning, making it ideal for unpredictable or variable traffic patterns typical of a startup's mobile application.

Exam trap

The trap here is that candidates often choose Amazon ElastiCache for Memcached (Option B) because of its low latency, but they overlook the requirement for a durable database that persists session data, whereas Memcached is a volatile cache with no built-in persistence or replication for data durability.

How to eliminate wrong answers

Option A is wrong because Amazon Aurora Serverless is a relational database designed for transactional workloads with ACID compliance, not optimized for simple key-value lookups with single-digit millisecond latency, and its cold-start latency and higher per-request cost make it less cost-effective for a read-heavy, occasional-write workload. Option B is wrong because Amazon ElastiCache for Memcached is an in-memory cache, not a durable database; it lacks persistence and data durability, making it unsuitable for storing user preferences and session data that must survive restarts. Option D is wrong because Amazon RDS for MySQL with provisioned IOPS incurs fixed costs for provisioned IOPS and instance hours, which is wasteful for a read-heavy workload with occasional writes, and its relational overhead adds unnecessary latency compared to a NoSQL key-value store.

Practice this question →
330
Multi-Selecteasy

Which TWO database design considerations are critical when migrating a high-traffic e-commerce website from Oracle to Amazon Aurora MySQL? (Choose 2.)

Select 2 answers
A.Enable eventual consistency for read replicas to reduce latency
B.Review and adapt application SQL queries for MySQL compatibility
C.Evaluate the impact of Aurora's storage engine on query performance
D.Use Aurora Multi-Master to distribute write load
E.Compress all tables to reduce storage costs
AnswersB, C

Oracle and MySQL differ in SQL syntax.

Why this answer

Options A and D are correct: Aurora MySQL may have different SQL syntax, requiring code changes, and Aurora's storage engine differs from Oracle's, affecting performance. Option B is wrong because there is no eventual consistency mode in Aurora; it provides strong consistency. Option C is wrong because Aurora does not use read replicas for writes.

Option E is wrong because Aurora does not have native compression; table compression must be considered.

Practice this question →
331
MCQeasy

A company is running a MySQL database on Amazon RDS for a web application. The application experiences read-heavy traffic, and the company wants to improve read performance without changing the application code. Which design should the database specialist recommend?

A.Implement an Amazon ElastiCache Redis cluster in front of the database.
B.Create one or more read replicas of the RDS DB instance.
C.Increase the instance size of the RDS DB instance.
D.Enable DynamoDB Accelerator (DAX) for the RDS instance.
AnswerB

Read replicas offload read traffic from the primary instance, improving read performance without application changes.

Why this answer

Option B is correct because Amazon RDS read replicas allow you to offload read traffic from the primary DB instance without any application code changes. The application simply connects to the read replica endpoint(s) for SELECT queries, while writes continue to the primary instance. This directly addresses the read-heavy workload by distributing read requests across multiple copies of the database.

Exam trap

The trap here is that candidates may confuse read replicas with caching solutions like ElastiCache, but the key constraint is 'without changing the application code' — read replicas require only a connection string change, whereas caching requires code modifications to implement cache logic.

How to eliminate wrong answers

Option A is wrong because while ElastiCache Redis can improve read performance for cached data, it requires application code changes to implement cache-aside or other caching patterns, and it does not serve as a direct database read endpoint for existing queries. Option C is wrong because scaling up the instance size (vertical scaling) improves both read and write performance but does not specifically address read-heavy traffic in a cost-effective manner; it also does not distribute the read load across multiple nodes. Option D is wrong because DynamoDB Accelerator (DAX) is an in-memory cache for Amazon DynamoDB, not for Amazon RDS MySQL; it is incompatible with RDS and cannot be used to accelerate MySQL queries.

Practice this question →
332
MCQhard

A company uses Amazon Aurora MySQL for a SaaS application. Each tenant has a separate database. The company wants to implement a centralized monitoring solution that collects performance metrics from all tenant databases. The solution should be cost-effective and require minimal overhead. Which approach should be used?

A.Use AWS DMS to continuously replicate metrics to a central RDS instance.
B.Consolidate all tenants into a single RDS MySQL instance and use separate schemas.
C.Run an AWS Lambda function that queries each database's performance_schema every minute and stores results in S3.
D.Use Amazon CloudWatch Agent to collect custom metrics from each Aurora instance and aggregate in CloudWatch.
AnswerD

CloudWatch Agent collects metrics with low overhead.

Why this answer

Option C is correct because Amazon CloudWatch Agent installed on each Aurora instance can collect custom metrics, but more efficiently, Aurora publishes Performance Insights metrics to CloudWatch. Option A is wrong because a single RDS instance cannot host multiple databases for isolation. Option B is wrong because DMS is for data migration, not monitoring.

Option D is wrong because a Lambda function querying each database would create overhead.

Practice this question →
333
Multi-Selectmedium

A company runs a MySQL database on Amazon RDS for a financial application that requires point-in-time recovery (PITR) with a recovery window of at least 35 days. The database is 500 GB in size. Which TWO actions should be taken to meet these requirements?

Select 2 answers
A.Create manual snapshots every day.
B.Set the backup retention period to 35 days.
C.Enable deletion protection on the RDS instance.
D.Enable Multi-AZ deployment for high availability.
E.Enable automated backups with a retention period of 35 days.
AnswersB, E

Automated backups with retention up to 35 days enable PITR.

Why this answer

Amazon RDS for MySQL supports point-in-time recovery (PITR) only through automated backups. The backup retention period controls how far back you can perform PITR. Setting the retention period to 35 days ensures that automated backups are retained for that duration, meeting the 35-day recovery window requirement.

Manual snapshots do not support PITR, so option B is correct.

Exam trap

The trap here is that candidates often confuse manual snapshots with automated backups, assuming manual snapshots support PITR, but only automated backups (with transaction logs) enable point-in-time recovery to any second within the retention window.

Practice this question →
334
MCQhard

A social media analytics company uses Amazon DynamoDB as the primary data store for user session data. Each session record has a partition key of user_id (String) and a sort key of session_start_time (Number, epoch). The application often queries the most recent 10 sessions for a given user. The traffic pattern shows that 90% of reads are for the last 10 sessions, while 10% are for historical sessions. The table has a provisioned read capacity of 5000 RCU and consistently experiences throttled read requests during peak hours. The company wants to optimize read performance without changing the provisioned capacity. Which design change will MOST improve read performance for this workload?

A.Create a Global Secondary Index (GSI) with the same partition key and a sort key of session_start_time, but query with ScanIndexForward=false and Limit=10.
B.Increase the provisioned read capacity to 10000 RCU to handle the peak load.
C.Enable DynamoDB Accelerator (DAX) with default settings to cache the most recent sessions.
D.Configure Amazon ElastiCache for Redis as a read-through cache for session data.
AnswerA

A GSI with the sort key reversed allows efficient retrieval of recent sessions using a single Query with ScanIndexForward=false and Limit=10.

Why this answer

Option A is correct because creating a GSI with the same partition key (user_id) and sort key (session_start_time) allows you to query with ScanIndexForward=false and Limit=10 to efficiently retrieve only the most recent 10 sessions per user. This avoids scanning all sessions for a user, reducing consumed read capacity and eliminating throttling without increasing provisioned RCU. The GSI also supports the 90% workload pattern by providing a targeted index that minimizes read unit consumption.

Exam trap

The trap here is that candidates often assume caching (DAX or ElastiCache) is the best solution for read-heavy workloads, but in this scenario the inefficiency is due to querying the base table without an index that supports efficient retrieval of the last N items, so a GSI with reversed sort order directly reduces read consumption without adding cache management overhead.

How to eliminate wrong answers

Option B is wrong because increasing provisioned read capacity to 10000 RCU does not optimize read performance; it only increases capacity, which contradicts the requirement to not change provisioned capacity and does not address the root cause of inefficient queries. Option C is wrong because enabling DAX with default settings caches hot items but does not reduce the read capacity consumed per query; the underlying table still uses the same number of read units for each query, and DAX does not change the query pattern to avoid full scans. Option D is wrong because configuring ElastiCache for Redis as a read-through cache adds complexity and latency for cache misses, and does not reduce the read capacity consumption on DynamoDB for the frequent last-10-sessions queries; it also does not address the inefficient scan pattern on the base table.

Practice this question →
335
MCQeasy

A developer runs the command shown and gets the output. Which conclusion can be drawn about the database configuration?

A.The database is a Multi-AZ read replica
B.The database engine is Aurora MySQL
C.The database is a primary instance in a Multi-AZ deployment
D.The database is a read replica of another instance
AnswerD

ReadReplicaSourceDBInstanceIdentifier indicates it is a replica.

Why this answer

Option B is correct: the ReadReplicaSourceDBInstanceIdentifier field shows that this instance is a read replica of 'mydb-read-replica', meaning it is not the primary. Option A is wrong because the MultiAZ field is true for this instance, but it is a replica. Option C is wrong because the replica is in Multi-AZ, but it is still a read replica.

Option D is wrong because the engine is mysql.

Practice this question →
336
MCQmedium

A media company stores video metadata in Amazon DynamoDB. Each record has a partition key of video_id and a sort key of uploaded_timestamp. The application frequently queries videos by genre and upload date. The access pattern is read-heavy with occasional writes. The table is provisioned with 3000 RCUs and 1000 WCUs. The company notices that queries by genre are slow and consume many RCUs. Which design change should be made to optimize for this workload?

A.Use DynamoDB Accelerator (DAX) to cache query results.
B.Create a local secondary index (LSI) with genre as sort key and uploaded_timestamp as partition key.
C.Increase the provisioned RCUs to 6000.
D.Create a global secondary index (GSI) with genre as partition key and uploaded_timestamp as sort key.
AnswerD

A GSI with genre as partition key allows efficient queries by genre and date.

Why this answer

Option D is correct because creating a Global Secondary Index (GSI) with genre as the partition key and uploaded_timestamp as the sort key allows efficient querying by genre and date without scanning the entire table. This directly supports the access pattern, reducing RCU consumption by using index key lookups instead of full table scans. The GSI is ideal for read-heavy workloads with occasional writes, as it offloads query traffic from the main table.

Exam trap

The trap here is that candidates may confuse LSIs and GSIs, incorrectly assuming an LSI can change the partition key, when in fact LSIs must share the main table's partition key, making them unsuitable for querying by a different attribute like genre.

How to eliminate wrong answers

Option A is wrong because DAX caches query results to reduce latency and RCU consumption, but it does not address the root cause of slow queries by genre—the lack of an appropriate index for that access pattern; DAX would still require expensive scans on cache misses. Option B is wrong because a Local Secondary Index (LSI) must have the same partition key as the main table (video_id), so it cannot support queries by genre as the partition key; using genre as sort key with video_id as partition key would not enable efficient genre-based queries. Option C is wrong because increasing RCUs to 6000 only adds more read capacity without fixing the inefficient query pattern; it would increase cost without resolving the underlying design issue of scanning the entire table for genre queries.

Practice this question →
337
Multi-Selecteasy

A company wants to store session state for a web application that runs on Amazon EC2 instances behind an Application Load Balancer. The session data is ephemeral and must be highly available. Which two AWS services are suitable for this use case? (Choose two.)

Select 2 answers
A.Amazon DynamoDB
B.Amazon ElastiCache for Redis with replication
C.Amazon Redshift
D.Amazon S3
E.Amazon RDS for MySQL
AnswersA, B

Fast, scalable, and highly available key-value store.

Why this answer

Option A (ElastiCache for Redis) is correct because it provides low-latency in-memory storage with replication for HA. Option C (DynamoDB) is correct because it is a highly available, fast key-value store. Option B is wrong because RDS is relational and not optimized for session state.

Option D is wrong because S3 is not low-latency. Option E is wrong because Redshift is a data warehouse.

Practice this question →
338
MCQmedium

A company needs to store and manage user sessions for a web application. The application runs on multiple EC2 instances, and sessions must be accessible from any instance. The team wants a fully managed, highly available, and low-latency solution. Which AWS service should they use?

A.Amazon RDS for MySQL
B.Amazon ElastiCache for Redis
C.Amazon DynamoDB
D.Amazon S3
AnswerB

Redis is ideal for session storage with low latency and high availability.

Why this answer

Amazon ElastiCache for Redis is the correct choice because it provides a fully managed, in-memory data store with sub-millisecond latency, making it ideal for storing user session data that must be accessed from any EC2 instance. Redis supports atomic operations and data structures (e.g., TTL-based key expiration) that are well-suited for session management, and its replication and Multi-AZ failover ensure high availability. This meets the requirement for a fully managed, highly available, and low-latency solution without the overhead of managing a database cluster.

Exam trap

The trap here is that candidates often choose Amazon DynamoDB because it is fully managed and highly available, but they overlook the specific requirement for 'low-latency' (sub-millisecond) that only an in-memory cache like ElastiCache for Redis can provide, and they miss that DynamoDB's latency is higher due to disk I/O and consistency models.

How to eliminate wrong answers

Option A is wrong because Amazon RDS for MySQL is a relational database with disk-based storage, which introduces higher latency for session lookups compared to an in-memory store, and it requires more operational overhead for scaling and failover. Option C is wrong because Amazon DynamoDB is a NoSQL database that, while fully managed and highly available, has higher read/write latency (typically single-digit milliseconds) compared to ElastiCache for Redis (sub-millisecond), and it is not optimized for ephemeral session data with automatic TTL expiration as efficiently as Redis. Option D is wrong because Amazon S3 is an object storage service with high latency (often tens to hundreds of milliseconds) and is not designed for frequent, low-latency read/write operations required for user sessions; it also lacks native session management features like atomic operations or TTL.

Practice this question →
339
MCQmedium

A company is migrating an on-premises PostgreSQL database to Amazon RDS for PostgreSQL. The database currently uses a custom extension that is not supported by RDS. The application relies heavily on this extension for advanced statistical analysis. Which design approach should the company take to minimize application changes?

A.Migrate to PostgreSQL on Amazon EC2 and install the custom extension.
B.Migrate to Amazon DynamoDB and implement statistical analysis using DynamoDB streams and Lambda.
C.Migrate to Amazon RDS for PostgreSQL and install the custom extension on the RDS instance.
D.Migrate to Amazon RDS for PostgreSQL and implement the extension's functionality using AWS Lambda functions called via triggers.
AnswerD

Lambda can replicate the extension's behavior without modifying the application.

Why this answer

Option D is correct because it allows the company to offload the unsupported custom extension's statistical analysis logic to AWS Lambda functions, which can be invoked via RDS PostgreSQL triggers. This approach minimizes application changes by keeping the database schema and query patterns largely intact, while the Lambda functions handle the advanced computations externally. RDS does not allow custom extensions, so this pattern leverages RDS for PostgreSQL's native trigger support to integrate with Lambda without modifying the application's core database interactions.

Exam trap

The trap here is that candidates assume RDS for PostgreSQL supports all PostgreSQL extensions, but AWS explicitly restricts custom extensions, making Option C a common distractor that seems plausible but is technically impossible.

How to eliminate wrong answers

Option A is wrong because migrating to PostgreSQL on Amazon EC2, while allowing custom extensions, requires significant operational overhead for patching, backups, and high availability, and does not minimize application changes more than the trigger-based approach. Option B is wrong because migrating to Amazon DynamoDB would require a complete rewrite of the application's data access layer and statistical analysis logic, as DynamoDB is a NoSQL key-value and document database with a different query model and no native support for PostgreSQL extensions. Option C is wrong because Amazon RDS for PostgreSQL does not allow installation of custom extensions; only AWS-provided extensions are supported, so this option is technically infeasible.

Practice this question →
340
Multi-Selecthard

A company is moving a large-scale time-series application from Cassandra to a managed AWS service. The workload involves high-frequency writes (millions per second) and queries that aggregate data over time windows. Which THREE AWS services are suitable for this time-series workload?

Select 3 answers
A.Amazon OpenSearch Service
B.Amazon Aurora
C.Amazon DynamoDB
D.Amazon Timestream
E.Amazon Redshift
AnswersA, C, D

Supports time-series ingestion and aggregation.

Why this answer

Amazon Timestream is purpose-built for time-series data. Amazon DynamoDB with time-series partitioning (using partition key as entity ID and sort key as timestamp) can handle high-volume writes and support time-based queries. Amazon OpenSearch Service can ingest time-series data and provide aggregation queries.

Option D (Redshift) is wrong because it is optimized for OLAP on structured data, not high-frequency writes. Option E (Aurora) is wrong because it is not designed for time-series ingestion at millions of writes per second.

Practice this question →
341
Multi-Selecthard

Which THREE design patterns can improve the performance of a write-heavy application using Amazon DynamoDB?

Select 3 answers
A.Write sharding by using a composite key with a random suffix to distribute writes across partitions.
B.Enable DynamoDB adaptive capacity to allow a single partition to use more throughput.
C.Create local secondary indexes (LSIs) for all query patterns.
D.Use DynamoDB Accelerator (DAX) to offload read traffic.
E.Increase provisioned write capacity units (WCUs) to the maximum allowed.
AnswersA, B, D

Prevents hot partitions by evenly distributing write traffic.

Why this answer

Option A is correct because write sharding with a random suffix on the partition key distributes writes evenly across multiple partitions, preventing hot partitions. This pattern avoids throttling by ensuring no single partition exceeds its write capacity limit, which is critical for write-heavy workloads in DynamoDB.

Exam trap

The trap here is that candidates may confuse local secondary indexes (LSIs) with global secondary indexes (GSIs) or assume that increasing WCUs alone resolves hot partitions, ignoring DynamoDB's per-partition throughput limits.

Practice this question →
342
MCQhard

An IAM policy is attached to a user to allow read access to the Orders table in DynamoDB. The user reports that a GetItem call for an order returns an 'AccessDeniedException'. What is the likely cause?

A.The user must specify a projection expression in the GetItem request to include only 'order_id' and 'status' attributes.
B.The user does not have permissions to perform GetItem on the Orders table.
C.The resource ARN is incorrect; it should include the wildcard for the table.
D.The condition key 'dynamodb:Attributes' restricts access to only two attributes, but the user can still get all attributes.
AnswerA

The condition requires that only these attributes be returned, so the request must explicitly project them.

Why this answer

Option A is correct because when an IAM policy uses the `dynamodb:Attributes` condition key to restrict access to specific attributes (e.g., `order_id` and `status`), the user must include a `ProjectionExpression` in the `GetItem` request that explicitly lists only those allowed attributes. Without the projection expression, DynamoDB attempts to return all attributes, which triggers an `AccessDeniedException` because the policy denies access to attributes not listed in the condition.

Exam trap

AWS often tests the misconception that a table-level permission error is the cause, when in reality the issue is a missing `ProjectionExpression` due to attribute-level restrictions in the IAM policy.

How to eliminate wrong answers

Option B is wrong because the user does have permissions to perform GetItem on the Orders table; the error is caused by attribute-level restrictions, not a lack of table-level permission. Option C is wrong because the resource ARN in the policy is correct; including a wildcard for the table would not resolve the attribute-level restriction issue. Option D is wrong because the condition key `dynamodb:Attributes` does restrict access to only two attributes, and the user cannot get all attributes; the GetItem call must use a projection expression to limit the returned attributes to those allowed.

Practice this question →
343
MCQhard

A company runs a global e-commerce platform with a relational database. They need to reduce read latency for users in Europe and Asia. The primary database is in us-west-2. Which solution provides the LOWEST read latency for global users while maintaining data consistency?

A.Deploy Amazon ElastiCache clusters in each region and cache database queries
B.Use Amazon Aurora Global Database with reader instances in Europe and Asia
C.Migrate to Amazon DynamoDB global tables
D.Configure Amazon RDS cross-region read replicas
AnswerB

Aurora Global Database provides cross-region read replicas with <1 second latency, enabling low-latency local reads.

Why this answer

Amazon Aurora Global Database is designed for low-latency global reads by replicating data to up to five secondary regions with dedicated reader instances. It uses storage-based replication that typically adds less than one second of lag, ensuring strong consistency while providing local read access for users in Europe and Asia. This architecture directly addresses the requirement for the lowest read latency without compromising data consistency.

Exam trap

The trap here is that candidates often choose ElastiCache (Option A) thinking caching always provides the lowest latency, but they overlook the requirement for data consistency and the fact that caching does not replicate the full database state across regions.

How to eliminate wrong answers

Option A is wrong because ElastiCache caches database queries but does not replicate the underlying relational data; it introduces eventual consistency and cache staleness, and does not provide the same consistency guarantees as Aurora Global Database. Option C is wrong because DynamoDB global tables are a NoSQL solution, not a relational database, and the company specifically requires a relational database for its e-commerce platform. Option D is wrong because Amazon RDS cross-region read replicas use asynchronous replication with potentially higher lag than Aurora Global Database, and they do not offer the same low-latency global read architecture with dedicated reader instances in each region.

Practice this question →
344
Multi-Selectmedium

A company is using Amazon DynamoDB for a shopping cart application. The table has a partition key of `user_id` and a sort key of `item_id`. The application performs frequent updates to the `quantity` attribute. The company notices that write requests are being throttled during peak hours. Which TWO actions would help reduce throttling? (Choose two.)

Select 2 answers
A.Increase the provisioned write capacity for the table.
B.Use conditional writes to prevent overwrites.
C.Implement a write sharding pattern using a random suffix on the partition key.
D.Enable DynamoDB Streams to process writes asynchronously.
E.Enable DynamoDB Accelerator (DAX) for the table.
AnswersA, C

Increasing write capacity directly reduces throttling.

Why this answer

Option A is correct because increasing the provisioned write capacity directly raises the number of write capacity units (WCUs) available per second, allowing more write requests to succeed without being throttled. Since the application performs frequent updates to the `quantity` attribute, which consumes write capacity, adding more capacity alleviates throttling during peak hours.

Exam trap

The trap here is that candidates often confuse read-side solutions (like DAX or Streams) with write-side throttling, or they mistakenly think conditional writes reduce capacity consumption, when in fact they do not address the root cause of insufficient write capacity or hot partitions.

Practice this question →
345
MCQeasy

A gaming company wants to store player profiles and game state data with low-latency access for millions of concurrent users. The data is accessed via a REST API and requires high scalability with minimal operational overhead. Which database service is MOST suitable?

A.Amazon RDS for MySQL with read replicas
B.Amazon DynamoDB
C.Amazon Neptune
D.Amazon ElastiCache for Redis
AnswerB

DynamoDB is serverless, scales automatically, and provides low-latency access.

Why this answer

Option C is correct because DynamoDB is a fully managed NoSQL database that provides single-digit millisecond latency at any scale, ideal for gaming profiles. Option A is wrong because RDS is relational and may not scale as easily. Option B is wrong because ElastiCache is a cache, not a primary database.

Option D is wrong because Neptune is for graph data.

Practice this question →
346
MCQhard

A company is building a real-time leaderboard for a gaming application. The leaderboard must update scores within seconds and support queries for top players and individual ranks. Which database design is most appropriate?

A.Amazon S3 with Range GET requests
B.Amazon ElastiCache for Redis with sorted sets
C.Amazon DynamoDB with a global secondary index on score
D.Amazon RDS for PostgreSQL with ORDER BY and LIMIT
AnswerC

DynamoDB GSI enables efficient querying of top scores and rank lookups.

Why this answer

Amazon DynamoDB with a global secondary index (GSI) on score can efficiently query top players and individual ranks. Option A (Amazon RDS with ORDER BY) becomes slow at scale. Option C (Amazon ElastiCache sorted sets) is good for leaderboards but not durable.

Option D (Amazon S3) is not suitable for real-time updates.

Practice this question →
347
MCQhard

A company uses Amazon DynamoDB to store IoT sensor data. Each sensor sends data every second, and the application needs to query the latest reading from each sensor. The sensor ID is the partition key, and the timestamp is the sort key. The table has millions of sensors. Which query pattern is most efficient to get the latest reading for a specific sensor?

A.Use BatchGetItem with the sensor ID and multiple timestamps
B.Use Scan with FilterExpression on sensor ID
C.Use GetItem with the sensor ID and the current timestamp
D.Use Query with KeyConditionExpression on sensor ID, ScanIndexForward=false, Limit=1
AnswerD

This retrieves the most recent item for that sensor efficiently.

Why this answer

Using a Query with ScanIndexForward set to false and a limit of 1 returns the most recent item for a given partition key efficiently. Option A (GetItem) requires knowing the exact sort key. Option C (Scan) is inefficient.

Option D (BatchGetItem) is for multiple items with known keys.

Practice this question →
348
MCQmedium

A healthcare application stores patient records in Amazon DynamoDB. Each record has a unique patient ID and contains sensitive health information. The application must encrypt data at rest and ensure that only authorized services can access the data. Which combination of design choices meets these requirements?

A.Implement client-side encryption and use Lambda to validate access.
B.Enable S3 server-side encryption with AWS KMS and use bucket policies.
C.Enable DynamoDB encryption at rest using AWS KMS and use IAM policies to restrict access.
D.Use AWS CloudHSM for key storage and VPC endpoints for access control.
AnswerC

DynamoDB integrates with KMS for encryption and IAM for access control.

Why this answer

Option C is correct because DynamoDB encryption at rest using AWS KMS provides server-side encryption for sensitive patient data, while IAM policies allow fine-grained access control to ensure only authorized services can access the table. This combination directly meets both the encryption and access control requirements without unnecessary complexity or service mismatches.

Exam trap

The trap here is that candidates may confuse encryption mechanisms across services (e.g., applying S3 encryption to DynamoDB) or assume that network controls like VPC endpoints replace the need for IAM-based authorization.

How to eliminate wrong answers

Option A is wrong because client-side encryption does not protect data at rest within DynamoDB (the application must manage keys and encryption logic), and Lambda validation is not a native access control mechanism for DynamoDB—IAM policies are required. Option B is wrong because S3 server-side encryption and bucket policies apply to Amazon S3, not DynamoDB; DynamoDB does not use S3 for primary storage or bucket policies for access control. Option D is wrong because AWS CloudHSM is a hardware security module for key storage but does not directly integrate with DynamoDB encryption at rest (DynamoDB uses AWS KMS, not CloudHSM), and VPC endpoints control network access but not authorization—IAM policies are still needed.

Practice this question →
349
MCQmedium

A financial services company uses Amazon Redshift for analytics. The workload consists of a mix of short-running queries from dashboards and long-running ETL jobs. The company notices that during peak hours, short queries experience high latency due to queueing behind ETL jobs. How can the company reduce the impact of ETL jobs on dashboard queries?

A.Configure workload management (WLM) queues to separate ETL and dashboard queries, and assign different concurrency levels.
B.Enable concurrency scaling to handle bursts of queries.
C.Enable short query acceleration (SQA) to prioritize queries that run under a certain time threshold.
D.Increase the number of nodes in the Redshift cluster.
AnswerA

WLM allows resource allocation per queue, ensuring dashboard queries have dedicated resources.

Why this answer

Option B is correct because WLM queues can isolate workloads, assigning concurrency and priority. Option A is wrong because concurrency scaling adds cost and doesn't prioritize. Option C is wrong because increasing node count scales all workloads.

Option D is wrong because short query acceleration (SQA) is for short queries but doesn't isolate ETL.

Practice this question →
350
MCQmedium

A company needs to implement a database solution for a global e-commerce platform that requires strongly consistent reads and writes with automatic failover across AWS Regions. Which service should be used?

A.Amazon DynamoDB global tables.
B.Amazon RDS for MySQL with Multi-AZ and cross-Region read replicas.
C.Amazon ElastiCache for Redis with Global Datastore.
D.Amazon Aurora Global Database.
AnswerD

Provides cross-Region replication and failover with strong consistency.

Why this answer

Amazon Aurora Global Database is the correct choice because it provides strongly consistent reads and writes across multiple AWS Regions with automatic failover. It uses a primary cluster in one Region and up to five secondary read-only clusters in other Regions, with replication typically under one second. Failover to a secondary Region can be promoted in as little as one minute, meeting the requirements for a global e-commerce platform.

Exam trap

The trap here is that candidates often confuse DynamoDB global tables' eventual consistency with strong consistency, or assume Multi-AZ RDS provides cross-Region failover, when in fact Multi-AZ is limited to a single Region and cross-Region replicas require manual intervention.

How to eliminate wrong answers

Option A is wrong because Amazon DynamoDB global tables offer multi-Region replication but provide eventual consistency for reads by default, not strong consistency, and writes are only strongly consistent within a single Region. Option B is wrong because Amazon RDS for MySQL with Multi-AZ and cross-Region read replicas does not support automatic failover across Regions; Multi-AZ failover is within a single Region, and cross-Region replicas require manual promotion. Option C is wrong because Amazon ElastiCache for Redis with Global Datastore is an in-memory cache, not a durable database, and it does not guarantee strong consistency for writes across Regions.

Practice this question →
351
Multi-Selecteasy

Which TWO AWS services can be used to cache database query results to improve read performance? (Select TWO.)

Select 2 answers
A.Amazon DynamoDB Accelerator (DAX)
B.Amazon ElastiCache for Redis
C.Amazon CloudFront
D.Amazon ElastiCache for Memcached
E.Amazon RDS read replica
AnswersB, D

In-memory cache for query results.

Why this answer

Amazon ElastiCache for Redis and Amazon ElastiCache for Memcached are in-memory caching services. DAX is for DynamoDB only. RDS does not cache.

CloudFront is CDN.

Practice this question →
352
MCQeasy

A company needs to migrate an on-premises PostgreSQL database to Amazon Aurora PostgreSQL. The database is 2 TB in size and has a 24/7 uptime requirement. Which AWS service should be used to perform the migration with minimal downtime?

A.AWS Schema Conversion Tool (SCT)
B.AWS S3
C.pg_dump and pg_restore
D.AWS Database Migration Service (DMS)
AnswerD

DMS supports live migration with CDC.

Why this answer

Option B is correct because AWS Database Migration Service (DMS) supports minimal-downtime migrations using change data capture (CDC). Option A is wrong because S3 is for storage, not database migration. Option C is wrong because the AWS Schema Conversion Tool (SCT) converts schemas but does not perform data migration.

Option D is wrong because pg_dump requires downtime for consistent export.

Practice this question →
353
MCQhard

A gaming company uses Amazon RDS for PostgreSQL to store player profiles and game state. They report slow queries during peak hours. The DB instance is a db.r5.2xlarge with 500 GB gp2 storage. Which design change would MOST improve read performance for the most frequently accessed player profiles?

A.Implement application-level sharding by player ID
B.Increase provisioned IOPS on the existing volume
C.Upgrade to a db.r5.4xlarge instance
D.Add a read replica in the same AZ
AnswerD

Read replicas offload read traffic from the primary, improving performance for read-heavy workloads.

Why this answer

Adding a read replica in the same Availability Zone (AZ) offloads read traffic from the primary RDS for PostgreSQL instance, directly improving read performance for frequently accessed player profiles during peak hours. Read replicas asynchronously replicate data using PostgreSQL's streaming replication and can serve SELECT queries without impacting the primary instance's write workload or connection limits.

Exam trap

The trap here is that candidates confuse increasing instance size (Option C) or IOPS (Option B) as the only way to fix slow queries, when the real solution is to offload read traffic to a read replica, which is a common AWS exam pattern for read-heavy workloads on RDS.

How to eliminate wrong answers

Option A is wrong because application-level sharding by player ID distributes write and read load across multiple databases, but it requires significant application changes and does not directly address read performance on the existing single RDS instance; it is an architectural redesign, not a quick design change. Option B is wrong because increasing provisioned IOPS on the existing gp2 volume improves I/O throughput for write-heavy or latency-sensitive operations, but the bottleneck described is read performance during peak hours, and gp2 already provides baseline IOPS proportional to size (1500 IOPS for 500 GB) with burst credits; the issue is likely CPU or connection saturation, not storage I/O. Option C is wrong because upgrading to a db.r5.4xlarge instance doubles the compute and memory resources, which can improve overall performance, but it does not isolate read traffic from write traffic; the primary instance still handles all reads and writes, so read performance gains are limited by the same contention and replication lag is not addressed.

Practice this question →
354
MCQeasy

A company is migrating a MySQL database to Amazon Aurora MySQL. The current database uses multi-statement transactions with read committed isolation level. The application frequently encounters deadlocks on the source database. Which Aurora MySQL feature can help reduce deadlocks without application changes?

A.Use Amazon Aurora Auto Scaling to automatically adjust the number of replicas.
B.Use Amazon Aurora Global Database to replicate data to multiple regions.
C.Use Amazon RDS Proxy to pool and share database connections.
D.Use Amazon Aurora Backtrack to quickly revert transactions.
AnswerC

RDS Proxy reduces connection contention and can help reduce deadlocks.

Why this answer

RDS Proxy helps reduce deadlocks by pooling and reusing database connections, which minimizes the overhead of establishing new connections and reduces contention on database resources. In MySQL, deadlocks often occur when multiple transactions compete for the same resources under high connection churn; by maintaining a stable pool of connections, RDS Proxy lowers the probability of concurrent conflicting locks. Since the proxy is transparent to the application, no code changes are required to benefit from this behavior.

Exam trap

The trap here is that candidates confuse deadlock reduction with high-availability or disaster-recovery features, mistakenly thinking that scaling replicas (Auto Scaling) or global replication (Global Database) can resolve concurrency conflicts, when in fact the key is connection management and reducing lock contention.

How to eliminate wrong answers

Option A is wrong because Aurora Auto Scaling adjusts the number of read replicas based on load, which does not address deadlock reduction—deadlocks are a concurrency and locking issue, not a capacity issue. Option B is wrong because Aurora Global Database replicates data across regions for disaster recovery and low-latency reads, but it does not reduce deadlocks on the primary instance; in fact, it can introduce additional replication-related locks. Option D is wrong because Aurora Backtrack allows reverting transactions to a point in time, which is a recovery feature, not a prevention mechanism—it does not reduce the occurrence of deadlocks during normal operation.

Practice this question →
355
Multi-Selectmedium

A company is designing a database for a global e-commerce platform. The application requires single-digit millisecond read and write latency for user sessions, and must handle millions of requests per second. The data is key-value in nature. Which TWO AWS services should the company consider? (Choose two.)

Select 2 answers
A.Amazon DynamoDB
B.Amazon ElastiCache for Redis
C.Amazon Neptune
D.Amazon Redshift
E.Amazon RDS for MySQL
AnswersA, B

Key-value NoSQL database with single-digit millisecond latency.

Why this answer

Options A and D are correct. DynamoDB is a key-value and document database that provides single-digit millisecond latency at any scale. ElastiCache for Redis is an in-memory data store that can achieve sub-millisecond latency for key-value data.

Option B (RDS) is relational and not designed for single-digit millisecond at millions of requests per second without heavy caching. Option C (Redshift) is a data warehouse. Option E (Neptune) is a graph database.

Practice this question →
356
Multi-Selecthard

A company is designing a multi-tenant SaaS application on Amazon Aurora MySQL. Each tenant has its own database, but some tenants are very large and generate high write traffic. The company wants to isolate tenant workloads to prevent a noisy neighbor from affecting other tenants. Which TWO design strategies should the database specialist recommend?

Select 2 answers
A.Use Aurora Serverless for tenants with variable workloads
B.Use a single Aurora cluster with read replicas for each tenant
C.Migrate all tenants to Amazon DynamoDB and use DynamoDB Accelerator (DAX) for caching
D.Use Amazon RDS Proxy to pool connections and limit throughput per tenant
E.Use separate Aurora clusters for high-traffic tenants
AnswersA, E

Aurora Serverless automatically scales compute capacity based on workload, minimizing impact on other tenants.

Why this answer

Option A is correct because Aurora Serverless automatically scales compute capacity based on application demand, which is ideal for tenants with variable workloads. This prevents a noisy neighbor scenario by ensuring that a tenant's burst of write traffic does not consume shared resources that would degrade performance for other tenants.

Exam trap

The trap here is that candidates often confuse connection pooling (RDS Proxy) with resource isolation, not realizing that RDS Proxy only manages connections and does not prevent a noisy neighbor from exhausting the cluster's shared I/O or CPU capacity.

Practice this question →
357
MCQeasy

A retail company uses Amazon DynamoDB to store shopping cart data. The cart items are frequently updated as users add or remove products. The application reads the entire cart each time the user views it. The cart size averages 50 KB but can reach up to 400 KB. The company wants to reduce read costs and improve performance. Which design change would be most effective?

A.Switch to larger DynamoDB instance types to handle larger items.
B.Use DynamoDB Accelerator (DAX) to cache the cart data.
C.Compress the cart items before storing them in DynamoDB and decompress on read.
D.Normalize the cart data into separate tables for cart headers and line items.
AnswerC

Compression reduces the item size, lowering RCU consumption and cost.

Why this answer

Option A is correct because compressing large attributes reduces read capacity unit consumption. Option B is wrong because caching with DAX adds cost and complexity. Option C is wrong because normalization would increase read costs due to more items.

Option D is wrong because vertical scaling of DynamoDB is not applicable; it's serverless.

Practice this question →
358
MCQmedium

A company is designing a database for an e-commerce platform that requires ACID transactions for order processing, complex joins for inventory reporting, and the ability to scale read replicas across multiple AWS regions. Which database service best meets these requirements?

A.Amazon Aurora
B.Amazon DynamoDB
C.Amazon RDS for SQL Server
D.Amazon Redshift
AnswerA

Aurora offers ACID transactions, complex joins, and cross-region read replicas.

Why this answer

Option A is correct because Amazon Aurora provides ACID transactions, complex join support, and up to 15 cross-region read replicas. Option B (DynamoDB) is not ACID across multiple items. Option C (Redshift) is a data warehouse, not transactional.

Option D (RDS SQL Server) supports ACID but cross-region replicas are limited and more complex.

Practice this question →
359
Multi-Selecteasy

A company is designing a database for a global application that requires low-latency reads and writes across multiple AWS regions. The application data is key-value and does not require complex queries. The team needs strong consistency for critical data. Which TWO services should they consider? (Choose TWO.)

Select 2 answers
A.Amazon DynamoDB Global Tables
B.Amazon S3 with cross-region replication
C.Amazon ElastiCache for Redis with global datastore
D.Amazon Aurora Global Database
E.Amazon RDS for PostgreSQL with cross-region read replicas
AnswersA, D

DynamoDB Global Tables replicate data across regions and support strong consistency.

Why this answer

DynamoDB Global Tables provide multi-region replication with strong consistency option. Option A is wrong because RDS cross-region read replicas do not support writes in multiple regions. Option D is wrong because S3 is not a database for key-value low-latency.

Option E is wrong because ElastiCache is a cache, not a durable database.

Practice this question →
360
MCQeasy

A startup is building a social media application that stores user posts in Amazon DynamoDB. The access pattern is to retrieve posts by user_id (partition key) sorted by post_timestamp (sort key) in descending order. The table has a global secondary index (GSI) with the same key structure but with different projection. The application reads from the GSI. Recently, the team noticed that writes to the base table are throttled during peak hours. The write capacity is balanced across partitions. Which design change should be made to reduce write throttling?

A.Use DynamoDB Accelerator (DAX) for writes.
B.Increase the write capacity units (WCUs) on the base table.
C.Switch to on-demand capacity mode.
D.Add a write sharding pattern by appending a random suffix to the partition key.
AnswerD

Sharding distributes writes across partitions, reducing hot spots.

Why this answer

The correct answer is D because the write throttling is caused by a hot partition, where a single partition key (user_id) receives a disproportionate number of writes. By appending a random suffix to the partition key, the writes are distributed evenly across multiple partitions, eliminating the hot spot. This is a well-known sharding pattern for DynamoDB when access patterns create uneven write traffic, and it does not require changing the read logic because the GSI can be queried with a sort key condition on post_timestamp.

Exam trap

The trap here is that candidates often assume increasing capacity or switching to on-demand mode will solve all throttling issues, but they overlook the fundamental partition-level throughput limits that cause hot partition throttling.

How to eliminate wrong answers

Option A is wrong because DAX is an in-memory cache for reads, not writes; it does not increase write capacity or reduce write throttling. Option B is wrong because increasing WCUs on the base table would not resolve the underlying hot partition issue; throttling occurs at the partition level, and if one partition is overloaded, adding more capacity to the table does not help because the partition's throughput limit is fixed. Option C is wrong because switching to on-demand capacity mode would only handle unpredictable traffic patterns, but it does not solve the hot partition problem; on-demand still has per-partition throughput limits (3,000 RCU or 1,000 WCU per partition), and a single hot partition can still throttle writes.

Practice this question →
361
MCQeasy

A social media company stores user posts in a database. Each post has a unique ID, content, and timestamp. The application frequently queries posts by user ID and also needs to support a global feed sorted by timestamp. Which database design is most efficient?

A.Amazon DynamoDB with a single table and scan operation for the global feed
B.Amazon S3 with a metadata index in DynamoDB
C.Amazon DynamoDB with user_id as partition key and timestamp as sort key, plus a GSI on timestamp
D.Amazon RDS for PostgreSQL with indexes on user_id and timestamp
AnswerC

This design efficiently supports both query patterns.

Why this answer

Amazon DynamoDB with a composite primary key (partition key on user_id, sort key on timestamp) allows efficient querying of a user's posts, and a GSI on (timestamp) can support the global feed. Option A (RDS) may become slow with large datasets. Option C (single table scan) is inefficient.

Option D (S3) is not suitable for real-time queries.

Practice this question →
362
MCQhard

A gaming company uses Amazon DynamoDB as the primary data store for player profiles and game state. The application experiences sudden spikes in traffic during new game launches, causing throttling on write requests. The current table has on-demand capacity mode. The table's partition key is 'player_id' (high cardinality). The read/write patterns are evenly distributed. Despite on-demand mode, throttling occurs because the per-partition throughput limit is being reached. The company wants to eliminate throttling without changing the partition key. Which solution should be recommended?

A.Implement Amazon DynamoDB Accelerator (DAX) to offload read traffic.
B.Use DynamoDB auto scaling with provisioned capacity.
C.Enable DynamoDB adaptive capacity and implement write sharding using a random suffix.
D.Switch to provisioned capacity mode and increase write capacity units.
AnswerC

Adaptive capacity helps distribute load; write sharding further spreads writes across partitions.

Why this answer

Option D is correct. DynamoDB adaptive capacity automatically adjusts per-partition throughput based on traffic patterns. Enabling it (it is on by default) or ensuring it is active can help.

However, if throttling persists, using write sharding by appending a suffix to the partition key can further distribute writes across partitions. Option A (increase RCU/WCU in provisioned mode) will not solve per-partition limits. Option B (switch to provisioned with auto scaling) similar issue.

Option C (use DynamoDB Accelerator) only caches reads, not writes.

Practice this question →
363
MCQmedium

A company is running a critical application on Amazon RDS for Oracle. They need to ensure high availability with automatic failover in case of a database failure. The database size is 500 GB. Which solution should they implement?

A.Create a cross-Region read replica
B.Migrate to Amazon DynamoDB Global Tables
C.Take regular snapshots and restore in a different Availability Zone
D.Enable Multi-AZ deployment
AnswerD

Multi-AZ automatically fails over to a standby instance.

Why this answer

Multi-AZ for RDS Oracle provides automatic failover to a standby in a different Availability Zone. Option B (read replicas) are for read scaling, not automatic failover. Option C (manual snapshot restore) is not automatic.

Option D (DynamoDB) is a different database service.

Practice this question →
364
Multi-Selectmedium

Which TWO of the following are advantages of using Amazon Aurora over standard RDS for MySQL?

Select 2 answers
A.Aurora automatically fails over to a read replica in case of primary failure.
B.Aurora is compatible with PostgreSQL, so you can migrate from SQL Server easily.
C.Aurora can deliver up to 5x the throughput of standard MySQL on the same hardware.
D.Aurora supports up to 15 read replicas, while RDS for MySQL only supports 5.
E.Aurora provides higher durability with 6 copies of data across 3 AZs.
AnswersC, E

Aurora's architecture provides significant performance improvements.

Why this answer

Option C is correct because Amazon Aurora uses a distributed, SSD-backed storage subsystem that separates compute from storage, enabling it to deliver up to 5x the throughput of standard MySQL running on the same hardware. This performance gain comes from the Aurora storage engine's ability to reduce I/O operations and parallelize writes across multiple storage nodes.

Exam trap

The trap here is that candidates may confuse the number of read replicas supported by RDS for MySQL (which is 15, not 5) and assume Aurora's higher replica count is a unique advantage, while in fact both services support the same limit.

Practice this question →
365
MCQhard

A gaming company uses Amazon DynamoDB with global tables across two regions. They notice increased write latency and throttling during peak hours. The access pattern is mostly writes to a small set of hot partitions. Which design change would best address this?

A.Implement write sharding using a random suffix on the partition key
B.Enable DynamoDB Accelerator (DAX)
C.Switch to DynamoDB on-demand capacity mode
D.Increase write capacity using auto scaling
AnswerA

Write sharding distributes writes evenly across partitions.

Why this answer

The correct answer is A because the issue is hot partitions caused by a small set of partition keys receiving the majority of writes. By implementing write sharding with a random suffix on the partition key, you distribute writes across multiple partitions, reducing throttling and write latency. This directly addresses the root cause of uneven access patterns, unlike the other options that either cache reads, adjust capacity mode, or scale capacity without solving the partition-level bottleneck.

Exam trap

The trap here is that candidates often confuse throughput scaling (options C and D) with partition-level distribution, failing to recognize that hot partitions require a key design change, not just capacity adjustments.

How to eliminate wrong answers

Option B is wrong because DynamoDB Accelerator (DAX) is an in-memory cache that primarily improves read performance, not write latency or throttling on hot partitions. Option C is wrong because switching to on-demand capacity mode handles traffic spikes but does not resolve the underlying hot partition issue; throttling can still occur at the partition level if a single partition exceeds its throughput limit. Option D is wrong because increasing write capacity with auto scaling only raises the table-level throughput, but if writes are concentrated on a few partitions, those partitions will still hit their individual limits and cause throttling.

Practice this question →
366
MCQhard

An application using the above IAM policy is trying to perform a Scan operation on the 'Orders' table. What will happen?

A.The Scan operation will succeed because the Deny is on all resources but the Allow is specific to the table.
B.The Scan operation will succeed because the policy allows other operations on the table.
C.The Scan operation will fail because the policy does not explicitly allow Scan.
D.The Scan operation will fail because the explicit Deny on dynamodb:Scan overrides the Allow.
AnswerD

Explicit Deny always overrides Allow.

Why this answer

Option D is correct because the explicit Deny for dynamodb:Scan overrides any Allow. Option A is wrong because the Deny is explicit and not ambiguous. Option B is wrong because the policy explicitly denies Scan.

Option C is wrong because the policy does not allow Scan; the explicit Deny applies.

Practice this question →
367
MCQhard

A social media application uses Amazon DynamoDB with a table that has a partition key of 'user_id' and a sort key of 'post_timestamp'. The application frequently queries for the 10 most recent posts by a specific user. The query pattern uses a 'begins_with' condition on the sort key with a timestamp prefix. Recently, the query latency has increased significantly for users with many posts. Which design change would improve query performance?

A.Create a local secondary index (LSI) with 'user_id' as partition key and 'post_timestamp' as sort key, and query using reverse order with a limit of 10.
B.Enable DynamoDB Accelerator (DAX) to cache the query results.
C.Create a global secondary index (GSI) with 'post_timestamp' as partition key and 'user_id' as sort key.
D.Change the table's partition key to 'post_id' to distribute data more evenly.
AnswerA

LSI allows efficient query for most recent posts by user without scanning all posts.

Why this answer

Option D is correct because creating a secondary index with 'user_id' as partition key and 'post_timestamp' as sort key, and using a 'Query' with reverse order and limit 10, avoids scanning all posts. Option A is wrong because a global secondary index still requires scanning if not optimized. Option B is wrong because changing partition key to 'post_id' would break the query pattern.

Option C is wrong because DynamoDB Accelerator (DAX) caches results but doesn't reduce the read capacity consumed per query; the query still scans all items for a user.

Practice this question →
368
Multi-Selecteasy

Which TWO of the following are advantages of using Amazon DynamoDB over Amazon RDS for MySQL for a workload that requires high scalability and low maintenance? (Select TWO.)

Select 2 answers
A.Strong consistency by default
B.Support for complex joins and transactions
C.No need to manage database servers or patches
D.Built-in read replicas for scaling reads
E.Automatic scaling of read/write capacity
AnswersC, E

DynamoDB is serverless and fully managed.

Why this answer

DynamoDB automatically scales throughput and storage, and it is fully managed with no server administration. Option C is true for RDS, not DynamoDB. Option D is false because DynamoDB supports both consistency models.

Option E is true for RDS, not DynamoDB.

Practice this question →
369
Multi-Selectmedium

A company is designing a database for an e-commerce platform that needs to store product catalog data. The data is highly relational with many-to-many relationships between products, categories, and suppliers. The platform requires ACID transactions and complex joins. Which TWO AWS database solutions are suitable for this workload? (Choose TWO.)

Select 2 answers
A.Amazon Aurora MySQL
B.Amazon RDS for PostgreSQL
C.Amazon ElastiCache for Redis
D.Amazon Neptune
E.Amazon DynamoDB
AnswersA, B

Aurora is a relational database with ACID support and complex join capabilities.

Why this answer

Amazon Aurora MySQL is a fully ACID-compliant relational database that supports complex joins and many-to-many relationships through foreign keys and junction tables. It is optimized for high-throughput e-commerce workloads with features like auto-scaling storage and up to 15 low-latency read replicas, making it suitable for product catalog data that requires transactional consistency.

Exam trap

The trap here is that candidates often choose DynamoDB for its scalability, overlooking that it cannot handle complex joins and many-to-many relational structures, or they select Neptune thinking it is suitable for any connected data, but it lacks SQL-based ACID transactions and relational integrity needed for product catalogs.

Practice this question →
370
MCQhard

A company is designing a document management system using Amazon DocumentDB. Each document is up to 10 MB. The application needs to retrieve multiple documents by their IDs in a single request. The IDs are known at query time. Which query pattern is most efficient?

A.Use a find operation with the $or operator on the _id field.
B.Use a scan operation with a filter on the _id field.
C.Use a find operation with the $in operator on the _id field.
D.Issue multiple get operations in parallel.
AnswerC

Uses index on _id efficiently.

Why this answer

Option B is correct because $in operator allows a single query to fetch multiple documents by ID. Option A is wrong because scanning is inefficient. Option C is wrong because parallel queries increase overhead.

Option D is wrong because $or is less efficient than $in for the same field.

Practice this question →
371
MCQeasy

A startup needs a fully managed relational database with automated backups and scaling. They expect unpredictable workloads. Which AWS service meets these requirements?

A.Amazon DynamoDB
B.Amazon Redshift
C.Amazon Aurora Serverless
D.Amazon ElastiCache
AnswerC

Fully managed relational database with auto-scaling and backups.

Why this answer

Amazon Aurora Serverless is a fully managed relational database that automatically scales capacity up or down based on application demand, making it ideal for unpredictable workloads. It also provides automated backups, continuous backups to Amazon S3, and point-in-time recovery, meeting all stated requirements.

Exam trap

The trap here is that candidates often confuse DynamoDB's on-demand scaling with relational database requirements, overlooking that DynamoDB is NoSQL and not relational, or they mistakenly think Redshift's scaling capabilities apply to transactional workloads.

How to eliminate wrong answers

Option A is wrong because Amazon DynamoDB is a NoSQL key-value and document database, not a relational database, so it does not meet the requirement for a relational database. Option B is wrong because Amazon Redshift is a petabyte-scale data warehouse optimized for analytical workloads, not a transactional relational database, and it does not automatically scale for unpredictable transactional workloads. Option D is wrong because Amazon ElastiCache is an in-memory caching service (supporting Redis or Memcached), not a relational database, and it does not provide automated backups or scaling for persistent relational data.

Practice this question →
372
MCQmedium

A company uses Amazon DynamoDB to store session data for a web application. During peak hours, they experience occasional ProvisionedThroughputExceededException errors. The table has a read capacity of 1000 RCU and a write capacity of 500 WCU. The application uses strongly consistent reads. The traffic pattern shows short bursts of reads exceeding 1000 RCU. What is the MOST cost-effective way to handle these bursts without changing the application?

A.Enable DynamoDB Auto Scaling to adjust RCU dynamically
B.Increase RCU to 2000 and enable Auto Scaling
C.Switch to eventually consistent reads
D.Use DynamoDB Accelerator (DAX) for caching reads

Why this answer

DynamoDB supports burst capacity by accumulating unused capacity for up to 5 minutes (300 seconds). For short bursts, the existing burst capacity can absorb the spikes. Option B is wrong because doubling RCU would be expensive and unnecessary if bursts are short.

Option C is wrong because switching to eventually consistent reads would only double capacity but may not be acceptable for session data. Option D is wrong because DAX is an in-memory cache that adds cost and complexity.

Practice this question →
373
MCQeasy

A company uses Amazon DynamoDB for a session management store. The application writes and reads session data frequently. The team notices that write requests occasionally fail with ProvisionedThroughputExceededException. They want a cost-effective solution to handle these bursts. What should they do?

A.Increase the provisioned write capacity to a higher fixed value
B.Use DynamoDB Accelerator (DAX) to cache writes
C.Implement an Amazon SQS queue to buffer writes
D.Enable DynamoDB Auto Scaling for the table
AnswerD

Auto Scaling adjusts capacity based on actual usage, handling bursts cost-effectively.

Why this answer

DynamoDB Auto Scaling adjusts throughput capacity automatically based on traffic patterns, handling bursts without manual intervention. Option B (increase table) would waste capacity. Option C (DAX) does not help with write throughput.

Option D (SQS) adds complexity.

Practice this question →
374
Multi-Selecthard

Which TWO design patterns help meet ACID compliance requirements in a distributed database environment while maintaining high availability?

Select 2 answers
A.Use an eventually consistent read model to improve performance.
B.Implement Amazon Aurora Global Database for cross-Region ACID transactions.
C.Adopt a saga pattern to manage distributed transactions.
D.Use Amazon DynamoDB Transactions for multi-item ACID operations.
E.Implement DynamoDB Streams to capture changes for audit.
AnswersB, D

Aurora Global Database provides ACID within each region.

Why this answer

Options B and D are correct. Amazon Aurora Global Database allows cross-region replication with ACID compliance within each region. Using DynamoDB Transactions provides ACID guarantees across multiple items within a single AWS account and region.

Option A (eventual consistency) is not ACID. Option C (saga pattern) is for eventual consistency in microservices. Option E (DynamoDB Streams) enable change data capture but not ACID.

Practice this question →
375
MCQeasy

A gaming company uses Amazon DynamoDB as the database for user profiles and game state. The application requires strongly consistent reads for the user's own profile, but eventually consistent reads for leaderboard queries. How should the company design the table and queries?

A.Create two separate tables: one for strong consistency and one for eventual consistency.
B.Use the ConsistentRead parameter set to true for profile queries and false for leaderboard queries.
C.Enable DynamoDB Accelerator (DAX) for strong consistency on all reads.
D.Configure DynamoDB Streams to replicate data to a second table for strong consistency.
AnswerB

This allows per-request consistency control.

Why this answer

DynamoDB supports both strongly consistent reads and eventually consistent reads on the same table, controlled by the `ConsistentRead` parameter in the `GetItem`, `Query`, or `Scan` API calls. Setting `ConsistentRead=true` for profile queries ensures the most up-to-date data, while `ConsistentRead=false` (the default) for leaderboard queries provides lower latency and higher throughput, which is ideal for read-heavy, non-critical data. This design avoids the cost and complexity of multiple tables or additional services.

Exam trap

The trap here is that candidates often assume strong consistency requires a separate table or a caching layer like DAX, but DynamoDB natively supports both consistency models on the same table via a simple API parameter, making the other options over-engineered or incorrect.

How to eliminate wrong answers

Option A is wrong because creating two separate tables for consistency levels is unnecessary and wasteful; DynamoDB supports both consistency models on a single table via the `ConsistentRead` parameter. Option C is wrong because DAX is a caching layer that provides eventually consistent reads by default and does not guarantee strongly consistent reads; it is designed for read-heavy workloads with relaxed consistency, not for enforcing strong consistency. Option D is wrong because DynamoDB Streams is used for change data capture and replication, not for serving strongly consistent reads; replicating to a second table would introduce eventual consistency between tables and add latency and cost without solving the requirement.

Practice this question →
← PreviousPage 5 of 6 · 444 questions totalNext →

Ready to test yourself?

Try a timed practice session using only Db Design questions.

Start 20-question session