Courseiva

CCNA Workload-Specific Database Design Questions

75 of 444 questions · Page 1/6 · Workload-Specific Database Design · Answers revealed

Practice these questionsDomain overviewAll questions
1
Multi-Selectmedium

A company is migrating an on-premises Oracle database to Amazon Aurora PostgreSQL. The database contains a large table that is partitioned by date. The company wants to minimize downtime during migration and ensure compatibility. Which TWO actions should the company take?

Select 2 answers
A.Use AWS Database Migration Service (DMS) with ongoing replication to migrate the data.
B.Migrate the database using a full load only and accept downtime.
C.Use AWS Schema Conversion Tool (SCT) to convert the schema automatically without any manual adjustments.
D.Replace the Oracle database with Amazon RDS for MySQL.
E.Convert Oracle partitions to PostgreSQL table inheritance or declarative partitioning.
AnswersA, E

DMS enables minimal downtime by replicating changes continuously.

Why this answer

AWS DMS with ongoing replication (change data capture) allows continuous synchronization from the source Oracle database to the target Aurora PostgreSQL, minimizing downtime by keeping the target nearly up-to-date until the final cutover. This approach supports large partitioned tables and reduces the migration window compared to a full load only.

Exam trap

The trap here is that candidates may think a full load only is sufficient for minimizing downtime, or that SCT can automatically convert all Oracle features without manual adjustments, but the exam requires understanding that ongoing replication and proper partition conversion are both necessary for a low-downtime, compatible migration.

Practice this question →
2
MCQmedium

The application uses the IAM role to access the 'orders' DynamoDB table. What is the intended effect of this policy?

A.The role can perform any DynamoDB action on the 'orders' table
B.The role can only access items where the partition key matches the principal's identifier
C.The role can access all items in the table but only during specific times
D.The role is denied access to the 'orders' table
AnswerB

The condition restricts access to items with LeadingKeys equal to the aws:userid.

Why this answer

The policy uses a condition key like `dynamodb:LeadingKeys` with a value referencing the principal's identifier (e.g., `${aws:userid}`). This restricts access to only those items in the 'orders' table whose partition key matches the IAM role's unique identifier, enforcing row-level security. The intended effect is fine-grained access control, not full table access or time-based restrictions.

Exam trap

The trap here is that candidates assume a policy with `Allow` on DynamoDB actions grants full table access, overlooking the `Condition` block that restricts access to specific items based on the partition key.

How to eliminate wrong answers

Option A is wrong because the policy includes a condition that limits DynamoDB actions to items with a specific partition key, so it does not grant unrestricted access to all items. Option C is wrong because the policy does not reference any time-based conditions (e.g., `aws:CurrentTime`); it only filters by partition key. Option D is wrong because the policy grants access (via `Allow` effect) to specific actions, not an explicit deny.

Practice this question →
3
Multi-Selecthard

A company is designing a document database for a content management system using Amazon DocumentDB. The application requires high availability and low-latency reads across multiple AWS Regions. Which TWO design choices meet these requirements?

Select 2 answers
A.Configure read replicas in each region to offload read traffic.
B.Use a single instance in each region with Multi-AZ disabled.
C.Use local secondary indexes to improve query performance in each region.
D.Deploy a global cluster with a primary region and secondary regions for read workloads.
E.Shard the data across multiple clusters in different regions.
AnswersA, D

Read replicas provide additional read capacity with low latency.

Why this answer

Option A (global cluster) provides multi-region replication with low-latency reads. Option D (read replicas) enhances read capacity. Option B is wrong because one instance per region doesn't provide high availability.

Option C is wrong because sharding is not native in DocumentDB. Option E is wrong because local secondary indexes don't help cross-region.

Practice this question →
4
Multi-Selectmedium

Which TWO factors should be considered when choosing between Amazon DynamoDB and Amazon RDS for MySQL for a new e-commerce application with variable traffic patterns?

Select 2 answers
A.Ability to perform complex joins and aggregations: DynamoDB supports SQL-like queries.
B.Operational overhead: DynamoDB is serverless, RDS requires patching and provisioning.
C.Support for ACID transactions in both databases.
D.Encryption at rest is only available for RDS.
E.Automatic scaling of throughput with DynamoDB on-demand vs. manual scaling of RDS.
AnswersB, E

DynamoDB is fully managed with no server management; RDS still requires some management.

Why this answer

Option B is correct because DynamoDB is a fully managed serverless service that eliminates the need for patching, provisioning, or managing servers, whereas Amazon RDS for MySQL requires manual patching, scaling, and instance provisioning. This operational overhead difference is critical for variable traffic patterns, as DynamoDB automatically handles infrastructure management, reducing administrative burden.

Exam trap

The trap here is that candidates may assume ACID transactions are exclusive to relational databases, but DynamoDB supports ACID transactions within a single table, leading them to incorrectly select option C as a distinguishing factor.

Practice this question →
5
Multi-Selectmedium

A company runs a PostgreSQL database on Amazon RDS for a CRM application. The database is 500 GB and experiences high read traffic. The company wants to improve read scalability and reduce latency. Which TWO actions should the company take? (Choose two.)

Select 2 answers
A.Implement Amazon ElastiCache for Redis to cache common queries.
B.Store large objects in Amazon S3 and reference them.
C.Enable Multi-AZ for automatic failover.
D.Create one or more read replicas in the same region.
E.Migrate data to Amazon DynamoDB with Global Tables.
AnswersA, D

Caching reduces database load.

Why this answer

Option A is correct because Amazon ElastiCache for Redis can cache the results of frequently executed read queries, offloading read traffic from the RDS PostgreSQL instance and reducing latency for repeated queries. This is especially effective for read-heavy workloads where the same data is requested many times, as Redis provides sub-millisecond response times and reduces the load on the database.

Exam trap

The trap here is that candidates often confuse Multi-AZ (which is for high availability) with read replicas (which are for read scaling), and may incorrectly think that enabling Multi-AZ also distributes read traffic, when in fact the standby instance is not accessible for reads.

Practice this question →
6
Multi-Selectmedium

An e-commerce company uses Amazon RDS for MySQL to store order data. They need to run complex analytical queries on the data without impacting the performance of the transactional workload. Which TWO solutions should they implement? (Choose TWO.)

Select 2 answers
A.Migrate the transaction table to Amazon DynamoDB
B.Use Amazon Redshift for analytics and load data via AWS DMS
C.Store order data in Amazon S3 and query with Amazon Athena
D.Enable Multi-AZ to use the standby for queries
E.Create an Amazon RDS read replica for analytical queries
AnswersB, E

Redshift is purpose-built for analytics; DMS can replicate data from RDS.

Why this answer

Creating a read replica offloads read queries from the primary database. Amazon Redshift is a data warehouse optimized for analytics; data can be loaded from RDS. Option B is wrong because enabling Multi-AZ does not provide a separate read-only endpoint.

Option C is wrong because DynamoDB is not suitable for complex analytical queries. Option D is wrong because S3 alone cannot run analytical queries.

Practice this question →
7
MCQmedium

A company is migrating an on-premises MongoDB database to Amazon DocumentDB. The application uses secondary indexes extensively and requires low-latency reads. Which database design consideration is MOST important for this workload?

A.Convert secondary indexes to the DocumentDB-compatible format
B.Provision EBS-optimized instances with increased IOPS
C.Use a larger instance type to avoid indexing issues
D.Enable DynamoDB Accelerator (DAX) for caching
AnswerA

DocumentDB requires indexes to be created in its own format; otherwise queries may not use them.

Why this answer

Option B is correct because Amazon DocumentDB does not support the same range of secondary indexes as MongoDB; converting indexes ensures performance. Option A is wrong because DocumentDB uses its own storage, not EBS. Option C is wrong because DynamoDB Accelerator is for DynamoDB, not DocumentDB.

Option D is wrong because vertical scaling is often insufficient; proper indexing is key.

Practice this question →
8
MCQhard

A company runs a financial analytics platform on Amazon DynamoDB. The table stores transaction records with a partition key of account_id and a sort key of transaction_timestamp. Each account has thousands of transactions. The application frequently queries the most recent transactions for a given account_id, sorted by timestamp in descending order. Recently, as the number of accounts grew, the query latency increased significantly. The DynamoDB table has provisioned read capacity of 10,000 RCUs, and CloudWatch metrics show that consumed read capacity is at 60%. The database specialist suspects that the issue is due to the query pattern. Which action should the database specialist take to reduce query latency?

A.Migrate the table to Amazon Aurora PostgreSQL with a secondary index on account_id and transaction_timestamp.
B.Create a Global Secondary Index (GSI) with account_id as partition key and transaction_timestamp as sort key, and query the GSI with ScanIndexForward set to false.
C.Enable DynamoDB Accelerator (DAX) to cache query results.
D.Increase the provisioned read capacity to 20,000 RCUs to handle the load.
AnswerB

A GSI with the desired sort key allows efficient descending queries.

Why this answer

Option B is correct because creating a Global Secondary Index (GSI) with account_id as the partition key and transaction_timestamp as the sort key allows the application to query the most recent transactions for a given account_id efficiently. By setting ScanIndexForward to false in the query, DynamoDB returns items in descending order by sort key, which directly matches the query pattern. This avoids the need to scan all transactions for an account and then sort them, significantly reducing latency.

The existing table's sort key is transaction_timestamp, but the query pattern requires descending order; the GSI provides an optimized access path without changing the base table structure.

Exam trap

The trap here is that candidates may think increasing RCUs or adding caching (DAX) will solve latency issues, but the real problem is the inefficient query pattern that requires scanning and sorting all items for an account, which a properly designed GSI with ScanIndexForward=false directly addresses.

How to eliminate wrong answers

Option A is wrong because migrating to Amazon Aurora PostgreSQL would introduce unnecessary complexity and operational overhead, and it does not address the root cause of the query pattern inefficiency in DynamoDB; the issue is about optimizing the existing NoSQL access pattern, not switching database engines. Option C is wrong because enabling DynamoDB Accelerator (DAX) caches query results but does not reduce the latency of the initial query that must still scan and sort all transactions for an account; DAX helps with repeated queries but not with the underlying inefficient scan-and-sort pattern. Option D is wrong because increasing provisioned read capacity to 20,000 RCUs does not solve the latency problem caused by the query pattern; the consumed read capacity is only at 60%, indicating sufficient capacity, and the latency is due to the need to scan and sort thousands of items per account, not due to throttling.

Practice this question →
9
MCQeasy

A company is designing a database for an e-commerce application that needs to store product catalog data. The data is highly structured with relationships between products, categories, and suppliers. The application requires ACID transactions to maintain data integrity when updating inventory. The company expects moderate read and write traffic. Which AWS database service is MOST suitable for this workload?

A.Amazon ElastiCache for Redis
B.Amazon Neptune
C.Amazon RDS for MySQL
D.Amazon DynamoDB
AnswerC

RDS for MySQL provides full ACID compliance and supports relational data structures.

Why this answer

Amazon RDS for MySQL is the most suitable choice because it provides a fully managed relational database that supports ACID transactions, which are essential for maintaining data integrity during inventory updates. The highly structured nature of product catalog data with relationships between products, categories, and suppliers maps naturally to MySQL's relational model with foreign keys and joins. RDS for MySQL handles moderate read/write traffic efficiently and offers features like Multi-AZ for high availability and read replicas for scaling reads.

Exam trap

The trap here is that candidates often pick Amazon DynamoDB for its scalability and performance, but overlook the requirement for ACID transactions and relational joins, which DynamoDB handles poorly compared to a traditional RDBMS like MySQL.

How to eliminate wrong answers

Option A is wrong because Amazon ElastiCache for Redis is an in-memory key-value store that does not support ACID transactions or relational queries; it is designed for caching and session management, not as a primary database for structured relational data. Option B is wrong because Amazon Neptune is a graph database optimized for highly connected data like social networks or recommendation engines, but it is overkill and not designed for ACID-compliant transactional workloads with structured relational schemas. Option D is wrong because Amazon DynamoDB is a NoSQL key-value and document database that does not natively support complex joins, foreign keys, or ACID transactions across multiple items without using expensive transactions API features; it is better suited for unstructured or semi-structured data at scale.

Practice this question →
10
MCQeasy

A media company is storing large video files (up to 10 GB each) in Amazon S3 and needs to maintain metadata about each file, including title, duration, and upload timestamp. The workload involves frequent writes (1000+ per second) and occasional read queries by title. Which database is best suited for this metadata store?

A.Amazon Neptune
B.Amazon RDS for MySQL
C.Amazon DynamoDB
D.Amazon ElastiCache for Memcached
AnswerC

DynamoDB supports high write throughput and fast queries by partition key.

Why this answer

Amazon DynamoDB is the best choice because it supports single-digit millisecond latency at any scale, handles over 1000 writes per second with auto-scaling, and can efficiently serve occasional read queries by title using a global secondary index (GSI) on the title attribute. Its fully managed, serverless nature eliminates operational overhead for high-throughput metadata storage.

Exam trap

AWS often tests the misconception that a relational database (RDS) is always the default for metadata, but the high write throughput and simple query pattern here make DynamoDB the correct choice, not RDS.

How to eliminate wrong answers

Option A is wrong because Amazon Neptune is a graph database designed for highly connected data (e.g., social networks, recommendation engines), not for simple key-value or document metadata with high write throughput. Option B is wrong because Amazon RDS for MySQL, while capable of storing metadata, cannot scale to 1000+ writes per second without significant vertical scaling or complex sharding, and its relational overhead (schema, joins) is unnecessary for simple metadata lookups. Option D is wrong because Amazon ElastiCache for Memcached is an in-memory cache, not a persistent database; it would lose data on node failure and cannot serve as a durable metadata store.

Practice this question →
11
MCQhard

A company has a MySQL database that stores user profile data. The database is 1 TB and growing. The team wants to archive inactive user profiles that haven't been accessed in over 1 year. The archived data must be queryable but at a slower performance tier. Which approach is most cost-effective?

A.Create an RDS read replica and delete inactive records from the primary
B.Move inactive profiles to Amazon Aurora Serverless and stop the cluster when not in use
C.Export inactive profiles to Amazon S3 and use S3 Intelligent-Tiering for storage
D.Use Amazon DynamoDB with TTL to expire inactive profiles
AnswerC

S3 Intelligent-Tiering optimizes costs, and the data can be queried using Athena.

Why this answer

Amazon S3 Intelligent-Tiering automatically moves data between access tiers to optimize costs. Querying S3 data can be done using Amazon Athena or S3 Select. Option A (RDS read replica) keeps all data in RDS, costly.

Option B (DMS to S3) is a one-time load; S3 Intelligent-Tiering optimizes storage costs over time. Option D (DynamoDB TTL) deletes data, not archives.

Practice this question →
12
MCQhard

A company runs a MongoDB workload on Amazon EC2 and wants to migrate to Amazon DocumentDB. The database has a total size of 2 TB and experiences 10,000 writes per second during peak. Which migration strategy minimizes downtime?

A.Export data using mongodump and import with mongorestore.
B.Use AWS Glue to stream data to DocumentDB.
C.Use AWS DMS with continuous replication.
D.Copy data files to Amazon S3 and load into DocumentDB.
AnswerC

DMS supports live migration with minimal downtime.

Why this answer

AWS DMS with continuous replication (change data capture) is the correct strategy because it allows you to keep the source MongoDB and target DocumentDB synchronized in near-real time, minimizing downtime to a brief cutover window. For a 2 TB database with 10,000 writes per second, a full export/import would take hours and require significant downtime, while DMS handles the initial full load and then continuously applies ongoing changes until you switch over.

Exam trap

The trap here is that candidates often assume a simple export/import (mongodump/mongorestore) is sufficient, but they overlook the requirement for minimal downtime with a high-write workload, where only a CDC-capable tool like DMS can keep the target synchronized during migration.

How to eliminate wrong answers

Option A is wrong because mongodump/mongorestore performs a full logical backup and restore, which for a 2 TB database would take many hours and require the source to be quiesced or read-only during the dump, causing extended downtime; it also does not support continuous replication to reduce the cutover window. Option B is wrong because AWS Glue is an ETL service designed for batch processing and data transformation, not for real-time streaming or continuous replication of database writes; it lacks the change data capture (CDC) capability needed to keep a live database synchronized with minimal downtime. Option D is wrong because copying data files to S3 and loading into DocumentDB is not a supported migration method; DocumentDB does not accept raw data files from MongoDB, and there is no native mechanism to ingest from S3 directly into a DocumentDB cluster.

Practice this question →
13
MCQeasy

A gaming company wants to store player profiles and game state. The data is accessed via a REST API and must be highly available with single-digit millisecond latency. The schema is simple and may evolve over time. Which database should they use?

A.Amazon DynamoDB
B.Amazon S3
C.Amazon RDS for PostgreSQL
D.Amazon Redshift
AnswerA

DynamoDB provides low latency, high availability, and schema flexibility.

Why this answer

Option A is correct because DynamoDB is a fully managed NoSQL database with consistent single-digit millisecond latency and flexible schema. Option B is wrong because RDS is relational and adds latency for simple lookups. Option C is wrong because Redshift is for analytics.

Option D is wrong because S3 is object storage, not designed for low-latency updates.

Practice this question →
14
MCQeasy

A company is designing a database for a global e-commerce application that requires low-latency reads and writes with strong consistency. The application is expected to handle millions of requests per second and requires high availability. Which AWS database service is most suitable for this workload?

A.Amazon ElastiCache for Memcached
B.Amazon S3 with S3 Select
C.Amazon RDS for MySQL with Multi-AZ deployment
D.Amazon DynamoDB with DynamoDB Accelerator (DAX)
AnswerD

DynamoDB provides scalable, low-latency, strongly consistent performance suitable for high-request-rate applications.

Why this answer

Amazon DynamoDB with DAX can provide single-digit millisecond latency at scale, supports strongly consistent reads, and is designed for high availability across multiple AWS regions. Option A (Amazon RDS MySQL with Multi-AZ) does not provide the same scalability for millions of requests per second. Option C (Amazon ElastiCache for Memcached) is a caching layer, not a primary database.

Option D (Amazon S3) is object storage, not suitable for low-latency transactional workloads.

Practice this question →
15
MCQmedium

A company uses Amazon Aurora MySQL for its online transaction processing (OLTP) application. Recently, read traffic has increased significantly, causing performance issues. The company wants to offload read traffic with minimal application changes. Which solution should they implement?

A.Enable Multi-AZ deployment
B.Create one or more Aurora Replicas
C.Migrate to Amazon DynamoDB
D.Add an Amazon ElastiCache cluster in front of Aurora
AnswerB

Aurora Replicas are read-only copies that offload read traffic.

Why this answer

Aurora Replicas are asynchronous read replicas that can handle read traffic without application changes (just use different endpoint). Option A (Multi-AZ) is for high availability, not read scaling. Option C (ElastiCache) requires application changes.

Option D (DynamoDB) would require a full redesign.

Practice this question →
16
MCQhard

A company is migrating an on-premises Oracle data warehouse to AWS. The warehouse contains 20 TB of data and supports complex SQL queries with joins and aggregations. The migration should minimize downtime and require minimal changes to existing SQL queries. Which database service is MOST appropriate?

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

Redshift is purpose-built for data warehousing with complex query support.

Why this answer

Amazon Redshift is the most appropriate choice because it is a fully managed, petabyte-scale data warehouse service designed for complex SQL queries with joins and aggregations. It supports standard SQL with minimal changes to existing queries, and its columnar storage and massively parallel processing (MPP) architecture are optimized for analytical workloads. The 20 TB data size and requirement to minimize downtime align with Redshift's ability to perform online resizing and use features like RA3 nodes with managed storage for elastic scaling.

Exam trap

The trap here is that candidates may choose Amazon RDS for Oracle because they recognize Oracle as a familiar database, overlooking that RDS is optimized for OLTP, not for the analytical, large-scale data warehouse workload described in the question.

How to eliminate wrong answers

Option A is wrong because Amazon RDS for Oracle is a transactional (OLTP) database not optimized for complex analytical queries with joins and aggregations on 20 TB of data; it lacks the MPP architecture and columnar storage needed for data warehouse performance. Option B is wrong because Amazon DynamoDB is a NoSQL key-value and document database that does not support complex SQL joins or aggregations, and it is designed for high-throughput, low-latency transactional workloads, not analytical queries. Option C is wrong because Amazon ElastiCache for Redis is an in-memory cache, not a persistent data warehouse; it cannot handle 20 TB of data cost-effectively and does not support complex SQL queries with joins and aggregations.

Practice this question →
17
Multi-Selecthard

A company runs a customer relationship management (CRM) application on Amazon RDS for PostgreSQL. The application has a table 'customers' with columns: id (primary key), name, email, signup_date, and status. The table has 10 million rows. The application frequently queries by email address. The company also needs to run analytical queries that aggregate customers by signup_date and status. The DBA notices that the index on email is heavily used and causes high write latency. The company wants to improve write performance without sacrificing read performance for email queries. Which THREE actions should the database specialist take? (Choose THREE.)

Select 3 answers
A.Create a BRIN index on signup_date.
B.Change the index on email from B-tree to hash.
C.Partition the customers table by signup_date using range partitioning.
D.Remove the index on email to reduce write latency.
E.Create a GIN index on email.
AnswersA, B, C

BRIN indexes are lightweight and efficient for large tables with natural ordering, improving analytical queries with low write overhead.

Why this answer

Option A is correct because a BRIN (Block Range INdex) index on signup_date is ideal for large tables where data is naturally ordered by insertion time. BRIN indexes are much smaller and have lower write overhead than B-tree indexes, making them suitable for analytical queries on signup_date without significantly impacting write performance.

Exam trap

The trap here is that candidates may think removing the email index (Option D) is acceptable to reduce write latency, but the question explicitly states read performance for email queries must not be sacrificed, so the index must be retained and optimized instead.

Practice this question →
18
Multi-Selectmedium

A company is migrating a self-managed MongoDB database to Amazon DocumentDB. The database stores user profiles and activity logs. The activity logs are write-heavy and accessed infrequently. The company wants to optimize cost and performance for the workload. Which THREE design decisions should the company make?

Select 3 answers
A.Enable encryption at rest for both databases.
B.Use a t3.medium instance for the activity logs collection to reduce cost.
C.Use Amazon S3 for storing activity logs instead of DocumentDB.
D.Create separate DocumentDB clusters for user profiles and activity logs.
E.Use a single DocumentDB cluster for both workloads with appropriate read replicas.
AnswersA, B, D

Encryption at rest is a security best practice.

Why this answer

Option A is correct because enabling encryption at rest for Amazon DocumentDB is a security best practice that ensures data is encrypted using AWS Key Management Service (KMS) keys. This is a mandatory design consideration for compliance and data protection, and it does not significantly impact cost or performance for the workload described.

Exam trap

The trap here is that candidates may assume a single cluster with read replicas is sufficient for mixed workloads, but the exam tests the understanding that separate clusters are needed to isolate write-heavy and read-heavy workloads for cost and performance optimization.

Practice this question →
19
Multi-Selecthard

A company is moving a legacy on-premises Oracle database to AWS. The database has large tables with complex stored procedures and triggers. The company wants to minimize application changes. Which THREE AWS database services should the database specialist consider? (Choose THREE.)

Select 3 answers
A.Amazon Redshift
B.Amazon DynamoDB
C.Amazon RDS for Oracle
D.Amazon Aurora PostgreSQL with Babelfish
E.Amazon RDS Custom for Oracle
AnswersC, D, E

RDS for Oracle is a direct lift-and-shift with minimal changes.

Why this answer

Amazon RDS for Oracle (Option C) is correct because it provides native Oracle compatibility, allowing the company to migrate the legacy Oracle database with minimal application changes. It supports large tables, complex stored procedures, and triggers without requiring code modifications, as it uses the same Oracle Database engine.

Exam trap

The trap here is that candidates may overlook Amazon RDS Custom for Oracle, assuming managed RDS for Oracle is sufficient, but RDS Custom is necessary when legacy Oracle features require OS-level access or custom patches.

Practice this question →
20
Multi-Selectmedium

Which TWO are valid considerations when designing a global database with Amazon Aurora Global Database? (Select TWO.)

Select 2 answers
A.Secondary regions cannot have their own reader instances.
B.Failover requires promoting the secondary cluster to a standalone cluster.
C.Cross-region replication latency is typically under 100 milliseconds.
D.Secondary regions can forward write operations to the primary region.
E.Aurora Global Database supports up to 5 secondary AWS Regions.
AnswersD, E

Correct: Write forwarding is a feature of Aurora Global Database.

Why this answer

Option D is correct because Amazon Aurora Global Database uses a primary-region architecture where secondary regions are fully readable and can forward write operations to the primary region. This is achieved through a dedicated replication channel that allows secondary clusters to accept write requests and asynchronously forward them to the primary, ensuring low-latency local writes while maintaining global consistency.

Exam trap

The trap here is that candidates often assume secondary regions are read-only and cannot accept writes, but Aurora Global Database allows secondary regions to forward write operations to the primary, which is a key differentiator from traditional read replicas.

Practice this question →
21
MCQmedium

A company is migrating a large Oracle Data Warehouse (10 TB) to Amazon Redshift. The current system uses complex stored procedures, materialized views, and window functions. The company wants to minimize migration effort. Which approach is MOST suitable?

A.Migrate to Amazon Aurora MySQL and use its parallel query feature.
B.Migrate to Amazon Redshift and rewrite stored procedures as SQL scripts.
C.Migrate to Amazon DynamoDB and use DAX for caching.
D.Migrate to Amazon RDS for PostgreSQL and use its foreign data wrappers.
AnswerB

Redshift supports window functions, materialized views, and SQL scripting.

Why this answer

Option B is correct because Amazon Redshift is purpose-built for large-scale data warehousing and analytics, making it the natural target for a 10 TB Oracle Data Warehouse. While stored procedures would need to be rewritten as SQL scripts (since Redshift uses a different procedural language), materialized views and window functions are natively supported, minimizing migration effort compared to other options.

Exam trap

The trap here is that candidates may assume all cloud databases are equally suitable for data warehousing, overlooking that Redshift's columnar storage and MPP architecture are specifically designed for analytical workloads, while options like Aurora or DynamoDB are optimized for different use cases (OLTP or NoSQL).

How to eliminate wrong answers

Option A is wrong because Amazon Aurora MySQL is an OLTP-oriented database, not designed for the analytical workloads and large data volumes (10 TB) of a data warehouse; its parallel query feature is limited and cannot replace Oracle's data warehouse capabilities. Option C is wrong because Amazon DynamoDB is a NoSQL key-value store optimized for high-throughput, low-latency transactions, not for complex analytical queries, stored procedures, or materialized views required by a data warehouse. Option D is wrong because Amazon RDS for PostgreSQL, while supporting foreign data wrappers, lacks the columnar storage, massively parallel processing (MPP), and advanced analytics features (e.g., automatic compression, workload management) that Redshift provides for large-scale data warehousing.

Practice this question →
22
MCQmedium

A company is migrating an on-premises MySQL database to Amazon RDS for MySQL. The database has a large table with frequent inserts and updates. To minimize downtime during migration, which AWS service should be used?

A.Amazon RDS read replica
B.AWS Schema Conversion Tool (SCT)
C.AWS Glue
D.AWS Database Migration Service (DMS)
AnswerD

DMS supports minimal downtime with ongoing replication.

Why this answer

AWS Database Migration Service (DMS) is the correct choice because it supports ongoing replication (change data capture, CDC) from an on-premises MySQL source to Amazon RDS for MySQL, allowing the source database to remain fully operational during the migration. This minimizes downtime by continuously applying inserts and updates from the source to the target until you perform the final cutover, which can be a brief pause of seconds to minutes.

Exam trap

The trap here is that candidates confuse AWS DMS with AWS SCT, assuming SCT handles data migration, but SCT only converts schema/code for heterogeneous migrations, while DMS handles the actual data transfer and CDC for both homogeneous and heterogeneous migrations.

How to eliminate wrong answers

Option A is wrong because an Amazon RDS read replica is a feature for offloading read traffic or creating a standby within RDS, not for migrating data from an on-premises database; it cannot connect to an external MySQL instance. Option B is wrong because the AWS Schema Conversion Tool (SCT) is used to convert database schemas and code between different database engines (e.g., Oracle to Aurora), not for migrating data with minimal downtime from on-premises MySQL to RDS MySQL (which uses the same engine). Option C is wrong because AWS Glue is a serverless ETL service designed for batch data processing and transformation, not for real-time, low-downtime database migration with ongoing replication.

Practice this question →
23
MCQeasy

A company runs an online transaction processing (OLTP) workload on Amazon RDS for PostgreSQL. The database has grown to 2 TB and the company needs to run complex analytical queries that join multiple large tables. These analytical queries are slowing down the OLTP operations. What is the MOST cost-effective solution to separate the workloads?

A.Create an RDS for PostgreSQL read replica and route analytical queries to it.
B.Use Amazon ElastiCache for caching analytical query results.
C.Migrate the analytical queries to Amazon Redshift.
D.Migrate the OLTP workload to Amazon DynamoDB.
AnswerA

Read replica offloads read-only queries, cost-effective.

Why this answer

Option A is correct because creating a read replica offloads analytical queries from the primary instance, and it's cost-effective. Option B is wrong because Amazon Redshift is a data warehouse, more expensive and overkill for this use case. Option C is wrong because DynamoDB is NoSQL and not suitable for complex joins.

Option D is wrong because ElastiCache is an in-memory cache, not for analytical queries.

Practice this question →
24
MCQhard

A financial services company runs a core banking application on Amazon RDS for MySQL. They need to maintain a full audit trail of all changes to customer account balances for regulatory compliance. The audit trail must be immutable and queryable for up to 7 years. Which solution meets these requirements with minimal impact on the source database?

A.Use Amazon RDS Performance Insights to capture SQL queries and store them in Amazon S3
B.Use Amazon DynamoDB Streams with a Lambda function to capture changes from the MySQL database
C.Enable binary logging on the RDS instance and stream the binlog to Amazon S3 using AWS Database Migration Service (DMS)
D.Migrate to Amazon Aurora MySQL and enable database activity streams, streaming to Amazon Kinesis Data Streams and then to Amazon S3
AnswerD

Aurora database activity streams provide an immutable, near real-time feed of database activities that can be consumed via Kinesis.

Why this answer

Amazon Aurora MySQL with database activity streams captures a near real-time feed of database activity and can be streamed to Amazon Kinesis Data Streams for analysis. This provides an immutable audit log. Option A uses binary logs which are not immutable and have limited retention.

Option B is not immutable. Option D uses DynamoDB Streams but the source is RDS MySQL, not DynamoDB.

Practice this question →
25
Multi-Selecthard

A company is migrating a large Oracle data warehouse to Amazon Redshift. The source database has many complex stored procedures, views, and joins. Which THREE actions should the company take during the migration?

Select 3 answers
A.Migrate triggers as they are in Redshift.
B.Use the AWS Schema Conversion Tool (SCT) to convert stored procedures.
C.Recreate all indexes from Oracle in Redshift.
D.Denormalize the schema to reduce the number of joins.
E.Design the schema using a star schema with fact and dimension tables.
AnswersB, D, E

SCT converts database schema and code.

Why this answer

Option A is correct because Redshift is columnar and may require denormalization. Option B is correct because the AWS Schema Conversion Tool (SCT) can convert Oracle stored procedures to Redshift SQL. Option D is correct because Redshift is optimized for star schema (fact and dimension tables).

Option C is wrong because Redshift does not support indexes like Oracle. Option E is wrong because Redshift does not support triggers.

Practice this question →
26
MCQeasy

A company is running a MySQL database on Amazon RDS and needs to store JSON documents that are frequently queried by fields within the JSON. The company wants to reduce development complexity and improve query performance. Which RDS MySQL feature should the database specialist recommend?

A.Migrate the JSON data to Amazon DynamoDB and use DynamoDB's document model
B.Use the JSON data type in MySQL 8.0 and utilize JSON path expressions in queries
C.Store JSON documents in a VARCHAR(MAX) column and use LIKE operations for queries
D.Store JSON documents as BLOBs and parse them in application code
AnswerB

MySQL's JSON data type allows efficient storage and querying using JSON path expressions and indexes.

Why this answer

Option B is correct because MySQL 8.0's native JSON data type stores JSON documents in an optimized binary format, enabling efficient indexing and querying via JSON path expressions (e.g., `JSON_EXTRACT`, `->`, `->>`). This reduces development complexity by allowing direct SQL access to JSON fields without application-level parsing, and improves query performance through generated columns and virtual indexes.

Exam trap

The trap here is that candidates may assume DynamoDB (Option A) is the only way to handle JSON efficiently, overlooking MySQL 8.0's native JSON support which avoids cross-service complexity while providing comparable query capabilities.

How to eliminate wrong answers

Option A is wrong because migrating to DynamoDB introduces a separate NoSQL service, increasing architectural complexity and requiring application changes, whereas the requirement is to stay within RDS MySQL. Option C is wrong because storing JSON in VARCHAR(MAX) and using LIKE operations is inefficient—LIKE cannot leverage indexes for JSON field queries and requires full table scans, degrading performance. Option D is wrong because storing JSON as BLOBs and parsing in application code offloads query logic to the client, increasing development complexity and preventing server-side indexing or optimization of JSON fields.

Practice this question →
27
MCQmedium

A company is running a MongoDB-compatible database on Amazon DocumentDB. The application performs frequent updates to a small subset of fields in documents. The company notices that write latency is high. What should the database specialist recommend to reduce write latency?

A.Review and remove unnecessary indexes on the collection.
B.Increase the instance size of the DocumentDB cluster.
C.Enable multi-master writes to distribute write load.
D.Change the storage type from standard to provisioned IOPS.
AnswerA

Fewer indexes mean less work during writes, reducing latency.

Why this answer

Option A is correct because unnecessary indexes impose a write penalty on every insert, update, and delete operation. In Amazon DocumentDB, each write must update all indexes on the collection, so removing unused indexes reduces the per-document write overhead and directly lowers write latency for frequent updates to a small subset of fields.

Exam trap

The trap here is that candidates often assume scaling up hardware (Option B) or changing storage (Option D) is the default fix for high write latency, but the exam tests understanding that index overhead is the most common cause of write amplification in DocumentDB and MongoDB-compatible databases.

How to eliminate wrong answers

Option B is wrong because increasing instance size primarily improves throughput and reduces resource contention (CPU/memory), but it does not address the fundamental write amplification caused by indexing; the write penalty per document remains the same. Option C is wrong because DocumentDB does not support multi-master writes; it uses a single primary writer with replica readers, and enabling a non-existent feature would not reduce write latency. Option D is wrong because DocumentDB uses a shared storage volume with built-in SSD-backed storage; it does not offer separate provisioned IOPS as a configurable storage type, and changing storage type is not applicable.

Practice this question →
28
MCQmedium

A company is designing a database for a global e-commerce platform that requires sub-millisecond read latencies from multiple AWS regions. The data is mostly read, with occasional writes. Which database solution meets these requirements?

A.Amazon ElastiCache for Redis with global datastore.
B.Amazon DynamoDB with Global Tables.
C.Amazon Aurora MySQL with Aurora Global Database.
D.Amazon RDS for MySQL with Multi-AZ and read replicas.
AnswerB

DynamoDB Global Tables provide sub-millisecond latency and multi-region replication.

Why this answer

Amazon DynamoDB with Global Tables is the correct choice because it provides a fully managed, multi-Region, multi-master database that replicates data across AWS Regions with sub-second latency, enabling sub-millisecond read latencies for a globally distributed, mostly-read workload. The occasional writes are handled efficiently by the multi-master design, which automatically resolves conflicts using last-writer-wins semantics, ensuring strong eventual consistency.

Exam trap

The trap here is that candidates often confuse 'global read replicas' (like Aurora Global Database) with a true multi-Region, multi-master database that can provide sub-millisecond reads from any Region, leading them to choose Aurora MySQL despite its replication lag and single-writer limitation.

How to eliminate wrong answers

Option A is wrong because Amazon ElastiCache for Redis with global datastore is an in-memory cache, not a durable database; it does not provide the persistence and durability guarantees required for an e-commerce platform's core data, and its global datastore is designed for cross-Region replication of cached data, not as a primary database for occasional writes. Option C is wrong because Amazon Aurora MySQL with Aurora Global Database is designed for low-latency reads in secondary Regions (typically under 1 second), but it cannot achieve sub-millisecond read latencies from multiple Regions due to the replication lag inherent in its storage-based replication, and it is not a multi-master solution (only one primary Region accepts writes). Option D is wrong because Amazon RDS for MySQL with Multi-AZ and read replicas is limited to a single AWS Region; read replicas in other Regions would introduce latency of hundreds of milliseconds or more, and Multi-AZ only provides high availability within one Region, not global sub-millisecond reads.

Practice this question →
29
MCQeasy

A company runs a MySQL database on Amazon RDS and wants to capture data changes to replicate to a separate reporting database. Which AWS service should be used to capture these changes with minimal impact on the source database?

A.Use Amazon DynamoDB Streams to capture changes from the RDS instance.
B.Enable MySQL native replication from the RDS instance to the reporting database.
C.Use Amazon Kinesis Data Streams with a custom application to poll the binlog.
D.Use AWS Database Migration Service (DMS) with ongoing replication enabled.
AnswerD

DMS can capture changes from RDS MySQL binlog with minimal impact.

Why this answer

Option D is correct because AWS DMS with ongoing replication (change data capture) captures changes from the source RDS MySQL binlog with minimal impact. Option A is wrong because RDS does not support native MySQL replication to external targets easily. Option B is wrong because DynamoDB Streams is for DynamoDB, not RDS.

Option C is wrong because Kinesis Data Streams is not designed to directly capture RDS changes; requires additional configuration.

Practice this question →
30
MCQhard

A company recently migrated their PostgreSQL database to Amazon Aurora PostgreSQL. They notice that the average query latency has increased, especially for complex read queries. The DB instance size is adequate and CPU utilization is below 50%. What is the MOST likely cause of the increased latency?

A.The Auto Scaling policy for the Aurora cluster is set to scale down too aggressively.
B.The Aurora cluster volume uses a smaller buffer cache than the original RDS instance.
C.The Aurora cluster is using the parallel query feature which adds overhead for complex queries.
D.The application is sending all read queries to the primary instance instead of offloading them to Aurora Replicas.
AnswerD

Without using Aurora Replicas, the primary handles all read traffic, leading to contention and higher latency.

Why this answer

Aurora PostgreSQL uses a shared cluster volume, and by default, writes are sent to the primary instance. Read replicas (Aurora Replicas) can offload read traffic. If the application is not using read replicas for read queries, all queries hit the primary, which may become overloaded even if CPU is low due to other bottlenecks like memory or I/O.

However, the most typical cause for increased read latency after migration to Aurora is the lack of read replicas or incorrect query optimization. Option D (Aurora Replicas not used) is the most likely. Option A (buffer cache) is possible but less likely with adequate memory.

Option B (Auto Scaling) doesn't cause increased latency. Option C (parallel query) is a feature that can improve performance, not degrade it.

Practice this question →
31
Multi-Selectmedium

Which TWO of the following are recommended best practices for designing a relational database on Amazon RDS? (Select TWO.)

Select 2 answers
A.Use read replicas to scale read-heavy workloads
B.Use LOB data types to store large text fields
C.Use non-EBS-optimized instances to reduce costs
D.Enable Multi-AZ for high availability
E.Store large binary objects (BLOBs) in the database
AnswersA, D

Read replicas offload read traffic.

Why this answer

Amazon RDS read replicas offload read traffic from the primary DB instance, improving performance for read-heavy workloads by providing additional read-only endpoints. This is a core best practice for scaling read capacity without increasing load on the source instance.

Exam trap

The trap here is that candidates often confuse Multi-AZ (which provides high availability) with read replicas (which provide read scaling), or mistakenly believe that storing BLOBs in the database is acceptable for performance, ignoring the impact on backup and replication overhead.

Practice this question →
32
MCQmedium

A company is designing a global application that requires a database with multi-master writes across multiple AWS Regions with sub-second conflict resolution. Which AWS database service should they choose?

A.Amazon ElastiCache for Redis Global Datastore
B.Amazon RDS with Multi-AZ
C.Amazon DynamoDB Global Tables
D.Amazon Aurora Global Database
AnswerC

Multi-master writes across Regions.

Why this answer

Amazon DynamoDB Global Tables provides multi-Region, multi-master replication with eventual consistency and sub-second conflict resolution. Option A (Aurora Global Database) has a single primary. Option C (RDS Multi-AZ) is single-Region.

Option D (ElastiCache) is a cache.

Practice this question →
33
MCQeasy

A company needs to store and analyze JSON documents that contain nested fields. The data is used for real-time dashboards and ad-hoc queries. The team wants a fully managed solution that supports both key-value lookups and SQL-like queries. Which AWS service should they use?

A.Amazon DynamoDB
B.Amazon Redshift
C.Amazon RDS for PostgreSQL with JSONB
D.Amazon DocumentDB
AnswerA

DynamoDB supports JSON documents, key-value lookups, and PartiQL for SQL-like queries.

Why this answer

Amazon DynamoDB is correct because it is a fully managed NoSQL key-value and document database that supports single-digit millisecond latency for key-value lookups, and its PartiQL-compatible query language enables SQL-like queries on JSON documents with nested fields. DynamoDB also integrates with AWS services like Lambda and Kinesis for real-time dashboards, and its adaptive capacity handles ad-hoc query patterns without manual scaling.

Exam trap

The trap here is that candidates often choose Amazon DocumentDB because it is a document database, but they overlook DynamoDB's superior key-value lookup performance and PartiQL's SQL-like query capability, which are explicitly required for real-time dashboards and ad-hoc queries in a fully managed serverless environment.

How to eliminate wrong answers

Option B (Amazon Redshift) is wrong because it is a columnar data warehouse optimized for complex analytical queries on structured data, not for real-time key-value lookups or storing JSON documents with nested fields; its JSON support is limited and incurs higher latency for point lookups. Option C (Amazon RDS for PostgreSQL with JSONB) is wrong because while JSONB supports nested JSON and SQL queries, it is not fully managed in the sense of serverless scaling for unpredictable workloads, and it requires manual provisioning and maintenance of database instances, unlike DynamoDB's auto-scaling. Option D (Amazon DocumentDB) is wrong because it is a MongoDB-compatible document database that supports JSON-like documents and SQL-like queries via MongoDB's aggregation framework, but it is not optimized for single-digit millisecond key-value lookups and does not natively support PartiQL or DynamoDB's consistent low-latency access patterns for real-time dashboards.

Practice this question →
34
MCQeasy

A web application uses Amazon DynamoDB as its database. The application frequently queries items using a secondary index. The index's partition key has high cardinality, but the query latency is higher than expected. Which action would MOST likely improve query performance?

A.Use a Scan operation instead of Query to retrieve items from the index.
B.Add additional sort key attributes to the index to better distribute the data.
C.Convert the global secondary index to a local secondary index.
D.Increase the read capacity units (RCU) for the global secondary index.
AnswerD

Insufficient read capacity on the index can cause throttling and higher latency.

Why this answer

DynamoDB secondary indexes have their own provisioned throughput. If the index's read capacity is insufficient, queries will be throttled or have higher latency. Increasing the read capacity for the index directly addresses this.

Option A (adding more sort keys) doesn't apply to queries on a secondary index. Option C (changing to global secondary index) is not needed if it's already a GSI. Option D (switching to scan) is less efficient.

Practice this question →
35
MCQhard

A company is running an Oracle database on Amazon RDS. The database has a large table that is frequently accessed by multiple applications. The DBA notices that the table has a high number of index scans but the queries are still slow. Upon investigation, the buffer cache hit ratio is low. Which design change would BEST improve performance?

A.Convert the table to columnar storage using Amazon Redshift
B.Add a read replica to offload queries
C.Migrate the table to Amazon DynamoDB with DAX
D.Increase the instance size to provide more memory
AnswerD

More memory increases buffer cache capacity, reducing disk I/O.

Why this answer

Option B is correct because increasing the instance size provides more memory for the buffer cache, improving cache hit ratio. Option A is wrong because read replicas do not help with buffer cache on the primary. Option C is wrong because converting to columnar is for analytical workloads.

Option D is wrong because switching to DynamoDB would require application changes.

Practice this question →
36
MCQmedium

A company is designing a database for an IoT application that collects sensor data every second from millions of devices. The data is time-series and must be stored for 90 days, with occasional queries for recent data. Which AWS database solution is MOST cost-effective and performant?

A.Amazon Timestream
B.Amazon Redshift
C.Amazon DynamoDB with TTL to expire old data
D.Amazon RDS for MySQL with partitioning
AnswerA

Timestream is built for time-series data, cost-effective, and supports automatic retention.

Why this answer

Amazon Timestream is purpose-built for time-series data, offering automatic storage tiering (in-memory for recent data and magnetic for historical data) and serverless scaling, which makes it the most cost-effective and performant choice for ingesting sensor data every second from millions of devices and retaining it for 90 days with occasional queries on recent data.

Exam trap

The trap here is that candidates often choose DynamoDB with TTL because they associate it with high throughput and automatic expiration, but they overlook the lack of native time-series query support and the cost of provisioning for sustained high write capacity.

How to eliminate wrong answers

Option B (Amazon Redshift) is wrong because it is a columnar data warehouse optimized for complex analytical queries on large datasets, not for high-frequency time-series ingestion; its per-hour billing and compute overhead would be prohibitively expensive for this use case. Option C (Amazon DynamoDB with TTL) is wrong because while DynamoDB can handle high write throughput, it is a key-value and document database that lacks native time-series optimizations like automatic downsampling or time-based partitioning, and TTL only deletes expired items without providing efficient time-range queries. Option D (Amazon RDS for MySQL with partitioning) is wrong because a relational database with manual partitioning cannot scale to millions of writes per second without significant cost and operational overhead, and it lacks the serverless, auto-scaling ingestion and storage tiering that Timestream provides.

Practice this question →
37
MCQhard

A company is migrating an on-premises Oracle database to AWS. The database is 5 TB and supports a critical OLTP application with high transaction rates. The application requires stored procedures, triggers, and strong consistency. Which AWS database service is most appropriate with minimal application changes?

A.Amazon Aurora PostgreSQL
B.Amazon DynamoDB
C.Amazon RDS for Oracle
D.Amazon Redshift
AnswerC

Fully compatible with Oracle, minimal changes needed.

Why this answer

Amazon RDS for Oracle is the most direct migration path with minimal changes because it is fully compatible with Oracle and supports stored procedures, triggers, and strong consistency. Option A (Aurora PostgreSQL) is wrong because it requires converting Oracle-specific features to PostgreSQL. Option C (DynamoDB) is wrong because it does not support stored procedures or triggers natively (except for DynamoDB Streams and Lambda).

Option D (Redshift) is wrong because it is a data warehouse, not for OLTP.

Practice this question →
38
MCQeasy

A company uses Amazon DynamoDB to store application logs. The logs have a TTL of 7 days. The operations team needs to run ad-hoc analytical queries on logs older than 7 days, which are automatically deleted by TTL. Which solution should the team implement to retain and analyze old logs?

A.Use DynamoDB Streams to export logs to Amazon S3 and query with Amazon Athena.
B.Disable TTL and use a scheduled Lambda function to archive logs to Amazon S3.
C.Increase the TTL to 30 days and query the logs directly in DynamoDB.
D.Use AWS Glue to crawl DynamoDB tables and create a data catalog for Athena queries.
AnswerA

Streams capture data before deletion, and Athena can query S3 data cost-effectively.

Why this answer

Option D is correct because DynamoDB Streams captures old images before TTL deletion, and Lambda can write them to S3 for analysis with Athena. Option A is wrong because DynamoDB cannot be queried by Athena directly. Option B is wrong because disabling TTL would increase costs.

Option C is wrong because exporting to S3 is not automatic via streams.

Practice this question →
39
MCQmedium

Refer to the exhibit. A CloudFormation stack was deployed to create an RDS instance. The application team reports they cannot connect to the database using the endpoint provided. The security group allows inbound traffic on port 3306 from the application's security group. What is the most likely cause?

A.The RDS instance is in a Multi-AZ deployment and the endpoint is for the standby
B.The security group inbound rule is missing the port 3306
C.The database password is not provided in the stack outputs; the team may be using the wrong password
D.The RDS endpoint is incorrect; it should include the port number
AnswerC

The password is not output; they likely need to retrieve it from Secrets Manager.

Why this answer

Option D is correct because the output shows the DBName and MasterUsername, but not the password. The password is usually stored in Secrets Manager or parameter store and not output. Option A: the endpoint appears correct.

Option B: port 3306 is MySQL default, and the security group is allowed. Option C: Multi-AZ does not affect connectivity.

Practice this question →
40
MCQeasy

A company is migrating an on-premises MongoDB database to Amazon DocumentDB (with MongoDB compatibility). The application uses MongoDB's aggregation pipeline with $lookup and $unwind stages. What should the company verify before migration?

A.Check if all aggregation pipeline stages used by the application are supported in DocumentDB.
B.Verify that DocumentDB supports sharding for the collection.
C.Ensure the application uses the latest MongoDB driver.
D.Confirm that the application's secondary indexes can be migrated.
AnswerA

DocumentDB has limitations on some aggregation stages; verifying compatibility is essential.

Why this answer

Option A is correct because Amazon DocumentDB (with MongoDB compatibility) does not support all MongoDB aggregation pipeline stages. Specifically, the `$lookup` and `$unwind` stages are supported, but other stages like `$merge`, `$facet`, `$bucket`, `$bucketAuto`, `$graphLookup`, and `$search` are not. Before migration, the company must verify that every stage used in their application's aggregation pipelines is fully supported in DocumentDB to avoid runtime failures.

Exam trap

The trap here is that candidates assume DocumentDB is fully MongoDB-compatible and overlook the specific limitations in the aggregation pipeline, especially for advanced stages like `$facet` and `$graphLookup`, which are not supported.

How to eliminate wrong answers

Option B is wrong because DocumentDB does not support sharding in the same way as MongoDB; DocumentDB uses a single-writer, multi-reader architecture with automatic scaling, and sharding is not a feature that needs to be verified before migration. Option C is wrong because using the latest MongoDB driver is not a prerequisite for migration; DocumentDB supports MongoDB wire protocol version 3.6 and 4.0, and the driver version must be compatible with those versions, not necessarily the latest. Option D is wrong because secondary indexes are fully supported in DocumentDB and can be migrated automatically; the primary concern is aggregation pipeline compatibility, not index migration.

Practice this question →
41
MCQmedium

A company runs a reporting application that queries an Amazon RDS for PostgreSQL database. The queries are complex and take a long time to run, causing performance degradation on the primary instance. The team wants to improve query performance without affecting the transactional workload. Which solution should they use?

A.Increase the instance size of the primary database
B.Create one or more read replicas and direct reporting queries to them
C.Migrate to Amazon RDS for MySQL and use Multi-AZ
D.Use Amazon ElastiCache to cache the results of complex queries
AnswerB

Read replicas offload read traffic, isolating reporting queries from transactional workload.

Why this answer

Read replicas offload read queries from the primary. Amazon RDS for PostgreSQL supports read replicas, and the reporting application can be configured to connect to the replica. Option A (increase instance) helps but may not be cost-effective.

Option C (Aurora) is an alternative but not necessary. Option D (ElastiCache) is for caching, not complex queries.

Practice this question →
42
MCQmedium

A company needs to build a reporting dashboard that queries a large dataset stored in Amazon S3. The queries are complex and require full SQL support. Which service should be used?

A.Amazon Redshift Spectrum
B.Amazon RDS
C.Amazon DynamoDB
D.Amazon Athena
AnswerD

Athena allows querying S3 data directly with standard SQL, no loading required.

Why this answer

Amazon Athena is the correct choice because it is a serverless, interactive query service that allows you to analyze data directly in Amazon S3 using standard SQL. It supports complex queries, including joins, window functions, and CTEs, and requires no infrastructure management, making it ideal for ad-hoc reporting on large datasets in S3.

Exam trap

AWS often tests the misconception that Redshift Spectrum is the only way to query S3 with SQL, but Athena is the serverless, cost-effective alternative for ad-hoc queries without a cluster.

How to eliminate wrong answers

Option A is wrong because Amazon Redshift Spectrum is a feature of Amazon Redshift that queries data in S3, but it requires an active Redshift cluster and is not a standalone service; it is overkill for a simple reporting dashboard and incurs cluster costs. Option B is wrong because Amazon RDS is a relational database service for transactional workloads, not designed for querying large datasets stored in S3; it would require loading data into the database, which is inefficient for this use case. Option C is wrong because Amazon DynamoDB is a NoSQL key-value and document database that does not support full SQL or complex queries like joins and aggregations; it is optimized for low-latency access at scale, not analytical reporting.

Practice this question →
43
MCQmedium

A financial services company runs a critical application on Amazon RDS for Oracle. The workload is write-heavy with frequent small transactions. The DBA notices high latency during peak hours. Which design change would best address this?

A.Implement ElastiCache for Redis
B.Enable Multi-AZ deployment
C.Switch to Provisioned IOPS (io1 or io2) volume type
D.Add a read replica
AnswerC

Provides predictable high IOPS for write-heavy workloads.

Why this answer

Option C is correct because the workload is write-heavy with frequent small transactions, and high latency during peak hours indicates that the current storage volume is not meeting the IOPS demands. Provisioned IOPS (io1 or io2) volumes provide consistent, low-latency performance by guaranteeing a specific number of IOPS, which directly addresses the bottleneck caused by insufficient I/O capacity for write-intensive operations.

Exam trap

The trap here is that candidates often confuse high latency with a read performance issue and incorrectly choose a read replica or caching, when the problem is actually a write I/O bottleneck that requires a storage-level solution like Provisioned IOPS.

How to eliminate wrong answers

Option A is wrong because ElastiCache for Redis is an in-memory caching layer that reduces read latency for frequently accessed data, but it does not improve write latency for an RDS database; write operations still go to the database, and caching does not address storage I/O bottlenecks. Option B is wrong because Multi-AZ deployment provides high availability and automatic failover by maintaining a standby replica in a different Availability Zone, but it does not improve write performance or reduce latency during peak hours; in fact, synchronous replication to the standby can add slight latency to writes. Option D is wrong because a read replica offloads read traffic from the primary instance, but the workload is write-heavy, so adding a read replica does nothing to reduce write latency or improve write throughput.

Practice this question →
44
Multi-Selecthard

A company is migrating a legacy Oracle data warehouse to Amazon Redshift. The source uses complex stored procedures with cursors, temporary tables, and PL/SQL. Which THREE design considerations should the company evaluate?

Select 3 answers
A.Redshift does not support procedural languages like PL/SQL; stored procedures must be rewritten in SQL or Python.
B.Redshift supports temporary tables, but they are session-scoped and not automatically dropped in all cases.
C.Redshift Concurrency Scaling can handle thousands of concurrent queries.
D.Redshift does not support cursors; result sets must be handled differently.
E.Redshift automatically scales compute capacity based on workload.
AnswersA, B, D

Redshift supports PL/pgSQL and Python, but not Oracle's PL/SQL.

Why this answer

Amazon Redshift does not support Oracle's PL/SQL procedural language. Stored procedures must be rewritten using Redshift's SQL-based procedural language (PL/pgSQL) or Python (via UDFs). This is a critical migration consideration because complex logic involving loops, conditionals, and error handling must be translated to supported constructs.

Exam trap

The trap here is that candidates assume Redshift supports all Oracle database features (like PL/SQL, cursors, and auto-scaling) because both are relational databases, but Redshift is a columnar, MPP data warehouse with significant differences in procedural logic and resource management.

Practice this question →
45
MCQhard

A company runs a critical PostgreSQL database on Amazon RDS and needs to implement point-in-time recovery (PITR) with a recovery window of the last 35 days. Currently, automated backups are set to retain for 35 days. The database size is 500 GB. What additional configuration is required?

A.No additional configuration is required; automated backups enable PITR
B.Enable manual snapshots every hour
C.Set up a replication slot and stream transaction logs to S3
D.Enable Multi-AZ deployment
AnswerA

RDS automatically supports PITR with automated backups.

Why this answer

Automated backups in RDS by default support PITR within the retention period. No additional configuration is needed. Option A (manual snapshots) is not required.

Option B (Multi-AZ) doesn't affect PITR. Option D (log shipping) is not a separate feature.

Practice this question →
46
MCQhard

A media company stores video metadata in Amazon Aurora MySQL. The application performs frequent range queries on a 'creation_date' column. The table has 10 million rows. The team notices that queries filtering on 'creation_date' are slow despite an index on that column. The query pattern is: SELECT * FROM videos WHERE creation_date BETWEEN '2023-01-01' AND '2023-01-31' ORDER BY creation_date LIMIT 100. The execution plan shows a full index scan. What is the MOST likely cause?

A.The index should be a composite index on (creation_date, id)
B.The table is not partitioned by creation_date
C.The index on creation_date is not being used
D.The query selects all columns, causing excessive table access
AnswerD

SELECT * forces the database to fetch full rows; a covering index could avoid that.

Why this answer

A full index scan occurs when the query selects a large portion of the table; however, the issue may be that the index is not selective enough, leading to many rows being read. But the key problem is that the index on 'creation_date' is a B-tree, and the query uses LIMIT with ORDER BY, so the optimizer may decide to scan the entire index to find matching rows because the range is wide. However, the correct answer is that the query is selecting all columns (SELECT *), causing the database to fetch rows from the table after the index lookup, which is expensive.

Option A is wrong because the index is being used (full index scan). Option B is wrong because partitioning would help if designed correctly, but the issue is more fundamental. Option D is wrong because a composite index with columns in wrong order may not help.

Practice this question →
47
MCQhard

A healthcare company stores patient records in Amazon DynamoDB. Each record includes a 'patient_id' (partition key) and 'visit_date' (sort key). The company needs to run ad-hoc queries to find all patients seen by a specific doctor within a date range. Which design approach minimizes cost and latency for this query pattern?

A.Query the base table using a filter expression on doctor_id.
B.Create a local secondary index (LSI) with doctor_id as sort key.
C.Create a global secondary index (GSI) with doctor_id as partition key and visit_date as sort key.
D.Use a Scan operation with a filter expression for doctor_id and visit_date.
AnswerC

GSI enables efficient query by doctor and date range.

Why this answer

Option C is correct because a Global Secondary Index (GSI) with doctor_id as the partition key and visit_date as the sort key allows efficient key-based queries for all patients seen by a specific doctor within a date range. This avoids full table scans and filter operations, minimizing both cost (read capacity units) and latency. DynamoDB can directly retrieve the indexed items without scanning the base table.

Exam trap

The trap here is that candidates often confuse LSIs and GSIs, assuming an LSI can support queries on any attribute, but LSIs are restricted to the same partition key as the base table, making them unsuitable for querying by doctor_id across all patients.

How to eliminate wrong answers

Option A is wrong because querying the base table with a filter expression on doctor_id still requires a full table scan if doctor_id is not a key attribute; the base table's partition key is patient_id, so you cannot query by doctor_id without scanning all items, which is costly and slow. Option B is wrong because a Local Secondary Index (LSI) must have the same partition key as the base table (patient_id), so it cannot be used to query by doctor_id alone; it would only help for queries within a specific patient. Option D is wrong because a Scan operation reads every item in the table, incurring maximum read capacity and latency, even with a filter expression; it is the least efficient approach for ad-hoc queries.

Practice this question →
48
MCQhard

A company is designing a time-series database for IoT sensor data using Amazon DynamoDB. Each sensor sends a reading every second. The table uses 'sensor_id' as partition key and 'timestamp' as sort key. The application queries for the last hour of data for a specific sensor. The query uses 'KeyConditionExpression' with 'timestamp' between start and end time. The table has auto-scaling enabled. However, the query latency is high. What is the MOST likely cause?

A.Enable DynamoDB Accelerator (DAX) to cache the query results.
B.The sort key should be 'sensor_id' and partition key should be 'timestamp'.
C.The query is scanning from the beginning of time; use 'ScanIndexForward: false' and a 'Limit' parameter.
D.The table does not have enough read capacity units; increase the base capacity.
AnswerC

Reverses the sort order to retrieve recent items first, reducing scanned data.

Why this answer

Option B is correct because the sort key 'timestamp' is in ascending order, so the most recent data is at the end of the sorted range. When querying for the last hour, DynamoDB may scan a large number of items before finding the recent ones, especially if the sensor has been running for a long time. Using 'ScanIndexForward: false' with a limit would reverse the order and retrieve recent items first.

Option A is wrong because auto-scaling would add capacity if needed, but the issue is query design. Option C is wrong because the sort key is already 'timestamp'. Option D is wrong because DAX would reduce latency but not the underlying read consumption.

Practice this question →
49
Multi-Selecthard

A company runs a time-series application on Amazon DynamoDB. The data has a pattern of frequent writes for recent data and rare reads for older data. They want to optimize storage costs and query performance for the time-series data. Which THREE strategies should they implement? (Choose THREE.)

Select 3 answers
A.Use DynamoDB Time to Live (TTL) to automatically delete old data after a certain period
B.Store historical data in Amazon S3 and query with Amazon Athena
C.Increase DynamoDB read capacity units to improve query performance
D.Archive old data to Amazon S3 Glacier using AWS Lambda and DynamoDB Streams
E.Decrease DynamoDB write capacity units to reduce cost
AnswersA, B, D

TTL removes items without consuming WCU and reduces storage costs.

Why this answer

DynamoDB Time to Live (TTL) automatically deletes expired items, reducing storage. Archiving old data to S3 Glacier provides cheap storage. Using S3 and Athena for historical queries avoids scanning old data in DynamoDB.

Option D is wrong because increasing RCU is expensive and not a storage optimization. Option E is wrong because decreasing WCU may cause throttling.

Practice this question →
50
Multi-Selectmedium

A company is designing an Amazon RDS for MySQL database for an e-commerce application. Which TWO design strategies will help ensure high availability and automatic failover in the event of a primary instance failure?

Select 1 answer
A.Use Amazon Aurora instead of RDS MySQL.
B.Create a read replica in the same Availability Zone.
C.Enable Multi-AZ deployment.
D.Provision read replicas in different Availability Zones.
E.Enable automatic backups.
AnswersC

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

Why this answer

Option C is correct because enabling Multi-AZ deployment for Amazon RDS MySQL automatically provisions and maintains a synchronous standby replica in a different Availability Zone. In the event of a primary instance failure, Amazon RDS automatically fails over to the standby replica, providing high availability with minimal downtime.

Exam trap

The trap here is that candidates often confuse read replicas (which are for read scaling and require manual promotion) with Multi-AZ standby replicas (which provide automatic failover), leading them to select options B or D incorrectly.

Practice this question →
51
MCQmedium

A company is designing a database for a real-time bidding system that requires sub-millisecond read and write latency for ad impressions. The workload is heavily write-intensive with occasional reads by campaign IDs. Which AWS database service is most suitable?

A.Amazon DynamoDB with DAX
B.Amazon ElastiCache for Redis
C.Amazon DocumentDB
D.Amazon Aurora MySQL
AnswerA

DynamoDB with DAX provides microsecond to single-digit millisecond latency for high-throughput workloads.

Why this answer

Amazon DynamoDB with DAX is the most suitable choice because DynamoDB provides single-digit millisecond latency for read and write operations at any scale, and DAX (DynamoDB Accelerator) is an in-memory cache that reduces read latency to microseconds for frequently accessed items. This combination meets the sub-millisecond read and write latency requirements for a heavily write-intensive real-time bidding system, while supporting occasional reads by campaign IDs via efficient query patterns.

Exam trap

The trap here is that candidates may choose ElastiCache for Redis because of its sub-millisecond latency, overlooking that it is not designed as a primary database for write-heavy, durable workloads, and that DynamoDB with DAX provides the same latency with built-in durability and auto-scaling for writes.

How to eliminate wrong answers

Option B (Amazon ElastiCache for Redis) is wrong because while it offers sub-millisecond latency, it is primarily an in-memory data store that is not optimized for heavy write-intensive workloads with persistence requirements; it lacks the native write scaling and durability features of DynamoDB, and using it as a primary database for ad impressions would risk data loss on node failure without complex replication. Option C (Amazon DocumentDB) is wrong because it is a document database that provides millisecond latency but not sub-millisecond performance for writes, and its write throughput is limited by instance size and storage IOPS, making it unsuitable for the extreme write volume of a real-time bidding system. Option D (Amazon Aurora MySQL) is wrong because it is a relational database that offers low latency but typically in the single-digit millisecond range for writes, and its write performance is constrained by the underlying storage and replication architecture, failing to meet the sub-millisecond write latency requirement for a heavily write-intensive workload.

Practice this question →
52
MCQmedium

A financial services company needs a database for trade settlement records. Each trade must be processed exactly once and the database must ensure ACID compliance across multiple rows. The workload is write-intensive with moderate reads. Which AWS database service should they choose?

A.Amazon Aurora PostgreSQL
B.Amazon DynamoDB with DynamoDB transactions
C.Amazon ElastiCache for Redis
D.Amazon Neptune
AnswerA

Aurora PostgreSQL provides full ACID compliance and is optimized for high write throughput.

Why this answer

Option B is correct because Aurora is ACID-compliant, supports complex transactions, and provides high availability. Option A (DynamoDB) is not fully ACID (only single-item transactions are atomic). Option C (Neptune) is a graph database.

Option D (ElastiCache) is not durable and not ACID.

Practice this question →
53
MCQhard

A security engineer created the IAM policy above for an application that reads from a DynamoDB table named UserSessions. The application reports that it cannot query the table using a Global Secondary Index (GSI). The table's GSI is named GSI_UserSessions. Why is the application unable to query the index?

A.The Query action is not allowed on the index because the Allow statement only applies to the table, not the index.
B.The Deny statement explicitly denies all DynamoDB actions on the index resource, overriding the Allow statement.
C.The application is using GetItem instead of Query to access the index.
D.The policy allows Query on the table, which automatically includes the index.
AnswerA, B

The Allow statement's resource is the table, not the index; however, the Deny is explicit. Actually, both A and C could be argued, but A is the primary reason because the Deny explicitly blocks. But the question expects A. However, in the context, the correct answer is A because Deny overrides Allow. However, note that the Allow statement does not include index ARN, so Query on index is implicitly denied. But there is an explicit Deny, which makes it explicit. The best answer is A.

Why this answer

Option A is correct because the IAM policy's Allow statement grants the Query action on the DynamoDB table resource (arn:aws:dynamodb:...:table/UserSessions) but does not include the index resource (arn:aws:dynamodb:...:table/UserSessions/index/GSI_UserSessions). In DynamoDB, a Global Secondary Index is a separate subresource, and IAM policies must explicitly grant permissions on the index ARN to allow operations like Query on that index. Without this, the application cannot query the GSI.

Exam trap

The trap here is that candidates often assume that granting permissions on a DynamoDB table automatically covers its Global Secondary Indexes, but AWS IAM treats indexes as separate resources requiring explicit ARN-based permissions.

How to eliminate wrong answers

Option B is wrong because the Deny statement in the policy explicitly denies all DynamoDB actions on the index resource, which would indeed override the Allow statement, but the question states the application cannot query the index; the Deny statement is present in the policy and is the actual reason for the failure, not the Allow statement's scope. Option C is wrong because the application reports it cannot query the table using a GSI, and the issue is about permissions, not the API method; GetItem cannot query an index anyway, but the problem is IAM authorization. Option D is wrong because allowing Query on the table does not automatically include the index; DynamoDB treats indexes as separate resources for IAM purposes, so explicit permissions on the index ARN are required.

Practice this question →
54
Multi-Selecteasy

Which TWO of the following are valid design considerations when using Amazon DynamoDB for a high-traffic e-commerce application? (Select TWO.)

Select 2 answers
A.Use scan operations for frequent queries to reduce provisioned capacity
B.Use DynamoDB transactions to reduce read capacity consumption
C.Use atomic counters to maintain inventory counts
D.Always use strongly consistent reads for all queries
E.Use sparse global secondary indexes to reduce write capacity costs
AnswersC, E

Atomic counters allow incrementing without read-modify-write.

Why this answer

Option C is correct because atomic counters in DynamoDB allow you to increment or decrement a numeric attribute atomically using the UpdateItem operation with an UpdateExpression like 'SET inventory = inventory - :qty'. This is ideal for maintaining inventory counts in a high-traffic e-commerce application, as it avoids the need for read-modify-write cycles and reduces the risk of race conditions without consuming additional read capacity.

Exam trap

AWS often tests the misconception that DynamoDB transactions reduce capacity consumption, but in reality, transactions increase capacity costs (e.g., TransactGetItems consumes 2x the read capacity units) and are designed for atomicity, not efficiency.

Practice this question →
55
MCQmedium

A company is migrating an on-premises Oracle database to Amazon Aurora PostgreSQL. The database is used for a financial application that requires complex joins and transactions. Which migration strategy is MOST appropriate?

A.Use AWS DMS with native Oracle to PostgreSQL endpoint
B.Use Oracle GoldenGate to replicate data to Aurora PostgreSQL
C.Use AWS SCT to convert the schema and AWS DMS to migrate data
D.Use pg_dump to export the Oracle database and restore to Aurora PostgreSQL
AnswerC

SCT converts schema, DMS migrates data.

Why this answer

Option C is correct because AWS Schema Conversion Tool (SCT) is required to convert the Oracle schema (including complex joins and transaction logic) to a PostgreSQL-compatible format, and AWS Database Migration Service (DMS) performs the ongoing data migration with minimal downtime. This combination handles both schema transformation and data replication for heterogeneous migrations, which is essential for a financial application with complex joins and transactions.

Exam trap

The trap here is that candidates assume DMS alone can handle heterogeneous migrations without schema conversion, or that a PostgreSQL-native tool like pg_dump can extract data from Oracle, leading them to choose options A or D instead of recognizing the mandatory role of SCT.

How to eliminate wrong answers

Option A is wrong because AWS DMS with native Oracle to PostgreSQL endpoint does not automatically convert the schema; DMS relies on SCT for schema conversion, and without it, the migration would fail due to incompatible data types, stored procedures, and transaction semantics. Option B is wrong because Oracle GoldenGate is a log-based replication tool primarily used for homogeneous Oracle-to-Oracle migrations or real-time streaming, and it does not natively convert Oracle schema objects to PostgreSQL; using it would require additional custom transformation logic and is not the most appropriate strategy for a full migration to Aurora PostgreSQL. Option D is wrong because pg_dump is a PostgreSQL-native tool that cannot export from an Oracle database; it only works with PostgreSQL databases, so it cannot be used to extract data from an Oracle source.

Practice this question →
56
Multi-Selecteasy

A company is designing a highly available e-commerce application using Amazon DynamoDB. The application requires strongly consistent reads for inventory data and eventual consistency for user session data. Which TWO design decisions should the company make?

Select 2 answers
A.Enable DynamoDB Streams on the inventory table to replicate data for disaster recovery.
B.Use DynamoDB Accelerator (DAX) for the inventory table to provide strongly consistent reads.
C.Use a single DynamoDB table for both inventory and session data with different partition keys.
D.Use strongly consistent reads for the inventory table by setting ConsistentRead=true in the query.
E.Use DynamoDB global tables for the user session data to achieve low-latency access across regions.
AnswersD, E

ConsistentRead=true ensures strongly consistent reads in DynamoDB.

Why this answer

Option D is correct because DynamoDB supports strongly consistent reads by setting the `ConsistentRead=true` parameter in the GetItem, Query, or Scan API calls. This ensures that the application always reads the most recent write, which is critical for inventory data where accuracy is paramount. Strongly consistent reads come at the cost of higher latency and lower throughput compared to eventually consistent reads, but they meet the requirement for inventory consistency.

Exam trap

The trap here is that candidates often assume DAX can provide strongly consistent reads because it accelerates read performance, but DAX is an eventually consistent cache and cannot guarantee read-after-write consistency for inventory data.

Practice this question →
57
Multi-Selecteasy

A company runs a web application that uses Amazon RDS for MySQL. The database frequently experiences high CPU utilization due to many concurrent connections. The application uses connection pooling at the application layer. Which TWO approaches can reduce CPU load on the database?

Select 2 answers
A.Use Amazon RDS Proxy to manage database connections.
B.Enable Multi-AZ to distribute the load.
C.Create read replicas to offload read traffic.
D.Increase the DB instance size to a larger instance type.
E.Implement caching with Amazon ElastiCache for frequently accessed data.
AnswersA, E

Reduces connection overhead.

Why this answer

Option A is correct because RDS Proxy manages connection pooling, reducing the overhead of establishing connections. Option D is correct because caching frequent read queries with ElastiCache reduces database load. Option B is wrong because increasing instance size may help but is not the most targeted solution.

Option C is wrong because read replicas help with read scaling, not CPU due to connections. Option E is wrong because Multi-AZ does not reduce CPU load.

Practice this question →
58
Multi-Selecthard

Which THREE of the following are best practices for designing a DynamoDB table for a gaming leaderboard that updates scores frequently and supports queries for top players? (Choose 3.)

Select 2 answers
A.Scan the entire table and sort to get top scores
B.Use strongly consistent reads for the leaderboard queries
C.Use a Global Secondary Index with score as the sort key to query top scores efficiently
D.Use DynamoDB Streams to update a materialized leaderboard table
E.Use a single partition key for all players to easily query top scores
AnswersC, D

Allows efficient range queries on scores.

Why this answer

Option C is correct because a Global Secondary Index (GSI) with score as the sort key allows efficient range queries (e.g., Query with ScanIndexForward=false) to retrieve top players without scanning the entire table. This leverages DynamoDB's key-value and sorted-index capabilities to minimize read throughput and latency, which is critical for frequently updated leaderboards.

Exam trap

The trap here is that candidates often confuse strongly consistent reads with eventual consistency for leaderboard use cases, or assume a single partition key is acceptable for global ranking, not realizing it creates a hot partition and prevents efficient sorted queries.

Practice this question →
59
Multi-Selecthard

Which THREE factors should be considered when choosing between Amazon DynamoDB and Amazon Aurora for a new application? (Select THREE.)

Select 3 answers
A.Access patterns (key-value vs relational queries)
B.Need for complex joins and transactions
C.Scalability model (horizontal vs vertical)
D.Cost per GB of storage
E.Maximum data size per table
AnswersA, B, C

Determines NoSQL vs SQL choice.

Why this answer

Access pattern (key-value vs relational), transaction support (Aurora supports complex transactions), and scalability model (DynamoDB scales horizontally) are key. Data size and cost are not primary differentiators.

Practice this question →
60
MCQhard

A company uses Amazon RDS for SQL Server with a 4 TB database for a financial reporting application. The database performs nightly batch updates that take 6 hours. The company needs to reduce the batch update time to under 2 hours. The current instance is db.r5.8xlarge with 64 vCPUs and 512 GB memory. The batch process is I/O-bound with high write throughput. Which change will MOST effectively reduce the batch update time?

A.Upgrade to db.r5.16xlarge with 128 vCPUs.
B.Switch to Provisioned IOPS (io2) with 80,000 IOPS.
C.Increase the instance memory to 1024 GB.
D.Enable Multi-AZ deployment.
AnswerB

Eliminates I/O bottleneck with consistent performance.

Why this answer

The batch process is I/O-bound with high write throughput, so the bottleneck is disk I/O, not compute or memory. Switching to Provisioned IOPS (io2) with 80,000 IOPS provides a predictable, high-performance storage tier that can sustain the required write throughput, directly reducing the batch update time from 6 hours to under 2 hours. RDS for SQL Server on io2 volumes delivers consistent low-latency I/O, which is critical for write-heavy workloads.

Exam trap

The trap here is that candidates often assume adding more vCPUs or memory will speed up any slow process, but the question explicitly states the workload is I/O-bound, so the correct solution must address storage performance, not compute or memory.

How to eliminate wrong answers

Option A is wrong because upgrading to db.r5.16xlarge adds more vCPUs, but the process is I/O-bound, not CPU-bound; additional compute resources will not address the I/O bottleneck. Option C is wrong because increasing instance memory to 1024 GB does not improve I/O throughput; memory helps with caching reads, but the batch is write-heavy and I/O-bound, so more memory will not reduce write latency. Option D is wrong because enabling Multi-AZ deployment provides high availability and automatic failover, but does not improve I/O performance; it may even add synchronous replication overhead, potentially increasing write latency.

Practice this question →
61
Matchingmedium

Match each RDS storage type to its description.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts
Matches

SSD storage with baseline IOPS and burst credits

SSD storage with consistent IOPS for I/O-intensive workloads

Previous generation HDD storage, lowest cost

SSD storage with baseline IOPS and throughput independent of size

Block Express SSD with higher durability and IOPS

Why these pairings

RDS storage options for different performance and cost needs.

Practice this question →
62
MCQmedium

A gaming company uses Amazon DynamoDB as the primary database for their player sessions. The player sessions table has a partition key of 'player_id' and a sort key of 'session_start_time'. The application frequently queries for recent sessions of a specific player, using the query API with 'player_id' and a filter on 'session_start_time' for the last 24 hours. The average item size is 5 KB. The company notices high latency on these queries during peak hours. The table has 10 Read Capacity Units (RCUs) provisioned. There are no indexes. Which design change would MOST improve query performance?

A.Increase the RCUs to 100.
B.Add a random suffix to the partition key values to distribute writes across partitions.
C.Create a Local Secondary Index (LSI) with the same partition key and a sort key of 'session_start_time', and query the index instead of the table.
D.Create a Global Secondary Index (GSI) with partition key 'event_type' and sort key 'session_start_time' and query the GSI.
AnswerC

LSI allows efficient range queries on the sort key without scanning and filtering.

Why this answer

Option C is correct because creating a Local Secondary Index (LSI) with the same partition key (player_id) and sort key (session_start_time) allows DynamoDB to efficiently retrieve items for a specific player sorted by session_start_time without scanning and filtering. The current query uses a filter on session_start_time after retrieving all sessions for the player, which wastes read capacity and increases latency. Querying the LSI directly uses the sort key to limit the data read to only the last 24 hours, reducing the read footprint and improving performance.

Exam trap

AWS often tests the misconception that simply increasing RCUs (Option A) solves high latency, but the real issue is inefficient data access patterns that waste read capacity, not insufficient throughput.

How to eliminate wrong answers

Option A is wrong because increasing RCUs to 100 only addresses throughput capacity but does not fix the root cause of high latency—the query still reads all sessions for the player and applies a filter, wasting read capacity and causing throttling or excessive consumed capacity. Option B is wrong because adding a random suffix to the partition key would distribute writes across partitions but does not improve query performance for reading recent sessions of a specific player; it would actually make queries harder by requiring knowledge of the suffix. Option D is wrong because creating a GSI with partition key 'event_type' is irrelevant to the query pattern (which filters by player_id), and querying such a GSI would not efficiently retrieve sessions for a specific player, leading to full index scans.

Practice this question →
63
Multi-Selectmedium

A company is designing a document database on Amazon DocumentDB. The workload requires high write throughput and needs to support complex queries on nested attributes. Which THREE design considerations should the company evaluate to meet these requirements?

Select 3 answers
A.Denormalize data to reduce the number of joins.
B.Enable Multi-AZ deployment for high availability.
C.Use sharding to distribute write load across shards.
D.Use change streams to capture and process data changes.
E.Use appropriate indexes on frequently queried fields.
AnswersA, C, E

Denormalization improves query performance for document databases.

Why this answer

Option A is correct because denormalizing data in Amazon DocumentDB reduces the need for joins, which are expensive and can degrade write throughput. By embedding related data into a single document, the database can perform complex queries on nested attributes more efficiently, as DocumentDB is optimized for document-level operations. This design aligns with the workload's requirement for high write throughput and complex query support.

Exam trap

The trap here is that candidates often confuse high availability features (like Multi-AZ) with performance optimization, or mistake change streams as a mechanism to improve write throughput rather than a tool for capturing data changes.

Practice this question →
64
Multi-Selectmedium

A company is designing a database for a global e-commerce platform that requires low-latency reads and writes from multiple AWS regions. The data must be strongly consistent within a region but can be eventually consistent across regions. Which TWO services should the company consider?

Select 2 answers
A.Amazon DynamoDB Global Tables
B.Amazon ElastiCache for Redis Global Datastore
C.Amazon RDS Cross-Region Read Replicas
D.Amazon Redshift
E.Amazon Aurora Global Database
AnswersA, E

Provides multi-region, multi-master replication.

Why this answer

DynamoDB Global Tables provides multi-region replication with eventual consistency across regions and strong consistency within a region. Aurora Global Database also provides low-latency reads across regions and can be configured for cross-region replication. Option C (Redshift) is wrong because it is not designed for multi-region active-active workloads.

Option D (ElastiCache Global Datastore) is wrong because it is for Redis and provides cross-region replication but with eventual consistency and is not a primary database. Option E (RDS Cross-Region Read Replicas) is wrong because they are read-only and do not support writes from multiple regions.

Practice this question →
65
MCQhard

A company runs a MySQL-compatible database on Amazon RDS with a 3 TB dataset. They need to run complex analytical queries that involve joins and aggregations on millions of rows. The current RDS instance is a db.r5.8xlarge with 32 vCPUs and 256 GB RAM, but complex queries take over an hour. Which design change would most improve query performance for this workload?

A.Migrate to Amazon Aurora with parallel query
B.Add an Amazon ElastiCache cluster to cache query results
C.Enable DynamoDB Accelerator (DAX) on the RDS instance
D.Use Amazon Redshift for the analytical workload
AnswerD

Redshift is a columnar data warehouse ideal for complex analytics.

Why this answer

Using Amazon Redshift, a columnar data warehouse, would dramatically improve analytical query performance because it is optimized for complex joins and aggregations. Option A (Aurora) is wrong because it is still row-based and not optimized for analytical workloads. Option B (ElastiCache) is wrong because it is an in-memory cache not designed for complex analytical queries.

Option D (DynamoDB Accelerator) is wrong because it is a cache for DynamoDB, not for relational databases.

Practice this question →
66
Drag & Dropmedium

Arrange the steps to migrate an on-premises Oracle database to Amazon RDS for Oracle using AWS DMS (Database Migration Service) in the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps
Order

Why this order

DMS migration requires setting up the replication instance, configuring endpoints with proper source database settings for CDC, creating a migration task, and monitoring for completion.

Practice this question →
67
MCQmedium

A company is migrating an on-premises MongoDB database to AWS. They need a managed database service that is compatible with MongoDB and supports automated backups, scaling, and high availability. Which service should they use?

A.Amazon DynamoDB
B.Amazon RDS for MySQL
C.Amazon Neptune
D.Amazon DocumentDB
AnswerD

DocumentDB is MongoDB-compatible and offers the required managed features.

Why this answer

Amazon DocumentDB is a fully managed, MongoDB-compatible document database service designed for workloads that require MongoDB's document model, query patterns, and APIs. It supports automated backups (continuous backups to S3 with point-in-time recovery), automatic scaling of storage and compute, and multi-AZ high availability with synchronous replication across three Availability Zones, making it the correct choice for migrating an on-premises MongoDB database to a managed AWS service.

Exam trap

The trap here is that candidates often confuse Amazon DynamoDB's document support (JSON-like items) with MongoDB compatibility, but DynamoDB does not support MongoDB's wire protocol, query operators, or aggregation pipeline, making it a non-trivial migration requiring significant application rewrites.

How to eliminate wrong answers

Option A is wrong because Amazon DynamoDB is a key-value and document database that uses a proprietary API and is not compatible with MongoDB's wire protocol or query language; it requires application code changes to use its own SDK and data model. Option B is wrong because Amazon RDS for MySQL is a relational database service using SQL and does not support MongoDB's document model, BSON data format, or MongoDB-specific operations like aggregation pipelines or geospatial queries. Option C is wrong because Amazon Neptune is a graph database service optimized for highly connected data (e.g., social networks, fraud detection) and does not support MongoDB's document storage or query interface.

Practice this question →
68
MCQmedium

A media company uses Amazon ElastiCache for Redis to cache database query results and reduce load on the primary database. The cache hit ratio is low because the cache is purged frequently. The team wants to improve the hit ratio without increasing the cache size. Which strategy should they implement?

A.Increase the TTL for cached entries to reduce early evictions.
B.Implement lazy loading to populate cache only on demand.
C.Use write-through caching to update cache on every database write.
D.Set eviction policy to allkeys-random to spread evictions evenly.
AnswerA

Longer TTL keeps data in cache longer, improving hit ratio.

Why this answer

Option A is correct because increasing the TTL (Time-To-Live) for cached entries allows them to remain in the cache longer, reducing the frequency of evictions due to expiration. Since the cache is purged frequently, a low TTL is likely causing entries to expire before they can be reused, which directly lowers the hit ratio. By extending the TTL, the team can retain popular entries longer without needing to increase the cache size, as the existing memory is used more efficiently.

Exam trap

The trap here is that candidates confuse cache eviction (due to memory pressure) with cache expiration (due to TTL), and assume that changing the eviction policy or caching strategy will fix a problem caused by entries being removed too quickly by expiration.

How to eliminate wrong answers

Option B is wrong because lazy loading (populating cache on cache miss) is already the default behavior in many Redis caching patterns and does not address the root cause of frequent purging; it may even increase write traffic to the database on misses. Option C is wrong because write-through caching updates the cache on every database write, which can increase write latency and memory usage without solving the issue of entries being evicted too early due to low TTL or memory pressure. Option D is wrong because setting the eviction policy to allkeys-random spreads evictions evenly across all keys, but this does not prevent frequent purging; it only changes which keys are evicted when memory is full, and if the cache is already being purged frequently due to expiration (not memory pressure), this policy has no effect.

Practice this question →
69
MCQhard

A company is designing a global e-commerce application that requires a relational database with sub-10ms read latency across multiple AWS Regions. The database will store inventory and product catalog data. Which database design should they choose?

A.Use Amazon DynamoDB Global Tables with eventual consistency.
B.Deploy Multi-AZ for Amazon RDS and use Route 53 latency-based routing.
C.Set up Cross-Region Read Replicas for Amazon RDS MySQL.
D.Use Amazon Aurora Global Database with a primary cluster in one Region and secondary clusters in other Regions.
AnswerD

Aurora Global Database offers low-latency global reads.

Why this answer

Amazon Aurora Global Database is designed for low-latency global reads, with typical replication lag of under 1 second and read latency in the single-digit milliseconds from secondary clusters. It uses a dedicated storage-based replication mechanism that does not impact the performance of the primary cluster, making it ideal for a global e-commerce application requiring sub-10ms reads across multiple AWS Regions.

Exam trap

The trap here is that candidates confuse Multi-AZ or Cross-Region Read Replicas with true global low-latency read scaling, not realizing that Aurora Global Database is the only option that provides dedicated secondary clusters with storage-based replication for sub-10ms reads across Regions.

How to eliminate wrong answers

Option A is wrong because DynamoDB Global Tables is a NoSQL key-value and document database, not a relational database, and the question explicitly requires a relational database. Option B is wrong because Multi-AZ for Amazon RDS provides high availability within a single Region, not global read scaling; Route 53 latency-based routing cannot reduce cross-Region read latency when the database itself is in one Region. Option C is wrong because Cross-Region Read Replicas for Amazon RDS MySQL use asynchronous replication with typical lag of seconds or more, and read requests from secondary Regions still incur cross-Region network latency that often exceeds 10ms.

Practice this question →
70
MCQeasy

A gaming company needs a database to store player session data that is ephemeral and requires sub-millisecond latency. The data can be lost on failure without impact. Which service is best?

A.Amazon DynamoDB
B.Amazon RDS for PostgreSQL
C.Amazon S3
D.Amazon ElastiCache for Redis
AnswerD

ElastiCache Redis provides sub-millisecond latency and can be configured with no persistence.

Why this answer

Amazon ElastiCache for Redis is the best choice because it provides an in-memory data store with sub-millisecond latency, ideal for ephemeral player session data that can be lost on failure. Redis supports data structures like strings and hashes with TTL (time-to-live) expiration, perfectly matching the transient, low-latency requirement without needing durability.

Exam trap

The trap here is that candidates may choose DynamoDB (Option A) because it is a common choice for session data, but the question's explicit requirement for sub-millisecond latency and tolerance for data loss points to an in-memory cache like Redis, not a durable database.

How to eliminate wrong answers

Option A is wrong because Amazon DynamoDB, while fast, is a fully managed NoSQL database that persists data to disk and typically offers single-digit millisecond latency, not the sub-millisecond latency required for ephemeral session data; it also incurs higher cost and overhead for data that can be lost. Option B is wrong because Amazon RDS for PostgreSQL is a relational database with disk-based storage, offering higher latency (often 5-10+ ms) and ACID compliance, which is unnecessary and over-engineered for transient session data that can be lost. Option C is wrong because Amazon S3 is an object storage service with high latency (typically 100+ ms for first byte) and is designed for durable, persistent storage, not ephemeral, sub-millisecond access patterns.

Practice this question →
71
MCQhard

A company is running a production Amazon RDS for MySQL database that is experiencing performance degradation. Amazon CloudWatch metrics show high CPU utilization and high number of connections. The company has already optimized queries and implemented connection pooling. What is the MOST cost-effective solution to address the high CPU utilization?

A.Add Read Replicas to offload read traffic
B.Change the storage type to Provisioned IOPS (io1)
C.Enable RDS Proxy to reduce database connections
D.Scale up to a larger DB instance class
AnswerD

More CPU capacity directly addresses high CPU utilization.

Why this answer

Option D is correct because scaling up to a larger DB instance class directly increases the compute capacity (vCPUs and memory) available to the database, which addresses the root cause of high CPU utilization. Since queries are already optimized and connection pooling is in place, the remaining bottleneck is the instance's processing power, making a vertical scale-up the most cost-effective solution to handle the sustained CPU load without introducing additional architectural complexity.

Exam trap

The trap here is that candidates often choose RDS Proxy (Option C) assuming it reduces CPU utilization by lowering connection overhead, but the question explicitly states connection pooling is already implemented, so the CPU issue is from compute-bound operations, not connection management.

How to eliminate wrong answers

Option A is wrong because adding Read Replicas offloads read traffic but does not reduce CPU utilization on the primary instance; the primary still handles all write operations and the high connection count, so CPU pressure remains. Option B is wrong because changing the storage type to Provisioned IOPS (io1) improves I/O latency and throughput, but does not address high CPU utilization caused by compute-bound workloads or connection overhead. Option C is wrong because enabling RDS Proxy reduces the number of database connections by pooling them, but the company has already implemented connection pooling, and the high CPU utilization persists due to compute-intensive operations, not connection churn.

Practice this question →
72
MCQmedium

A logistics company uses Amazon RDS for MySQL to track package shipments. The 'shipments' table contains 200 million rows and has a primary key on 'shipment_id' (UUID). The application frequently queries for shipments by 'tracking_number', which is a unique string of 20 characters. The DBA created a B-tree index on tracking_number. The queries by tracking_number are fast, but inserts are becoming slower over time. The table has 50 GB of data. The company plans to double the insert rate next month. The database is a db.r5.large instance with 500 GB of Provisioned IOPS SSD storage. The instance's CPU utilization is below 30%, and there is no lock contention. What should the database specialist do to improve insert performance?

A.Add a read replica and route insert queries to the replica.
B.Drop the index on tracking_number to reduce write overhead.
C.Change the primary key from UUID to an auto-increment integer, and keep the tracking_number index.
D.Increase the provisioned IOPS to 20,000.
AnswerC

An auto-increment primary key allows sequential inserts, reducing page splits and improving insert speed.

Why this answer

Option C is correct because UUID primary keys cause random writes and index fragmentation, degrading insert performance as the table grows. Switching to an auto-increment integer primary key allows sequential writes to the clustered index, reducing page splits and improving insert throughput. The B-tree index on tracking_number remains to support fast queries, while the new primary key eliminates the UUID write overhead.

Exam trap

The trap here is that candidates often focus on index overhead or IOPS as the cause of slow inserts, overlooking the fundamental impact of UUID fragmentation on clustered index write performance.

How to eliminate wrong answers

Option A is wrong because read replicas cannot accept write traffic; they are read-only and do not improve insert performance. Option B is wrong because dropping the index on tracking_number would severely degrade query performance for the frequent tracking_number lookups, and the index overhead is not the primary cause of slow inserts (UUID fragmentation is). Option D is wrong because increasing IOPS does not address the root cause of random write amplification from UUID primary keys; CPU and IOPS are not the bottleneck (CPU is below 30%, storage is Provisioned IOPS SSD).

Practice this question →
73
MCQmedium

A social media application uses Amazon DynamoDB as its primary data store. The application stores user posts and allows users to retrieve the most recent 10 posts of users they follow. The access pattern is a followee-based query that needs to be highly scalable and low-latency. Which DynamoDB table design should the database specialist recommend?

A.Use a partition key of post ID and a local secondary index on the followee ID
B.Use a single table with a scan operation and filter on the followee attribute
C.Use a composite primary key with a partition key of follower ID and a sort key of timestamp, and store the followee ID as an attribute
D.Design the table with a partition key of user ID and a sort key of timestamp, and create a global secondary index (GSI) on followee ID
AnswerC

This design allows efficient Query on the follower ID to retrieve recent posts in reverse order by timestamp.

Why this answer

Option C is correct because it models the access pattern directly: the follower ID as the partition key ensures all posts from followed users are co-located, and the sort key of timestamp allows efficient retrieval of the most recent 10 posts via a Query with a limit of 10 and descending order. This design avoids expensive scans or secondary index lookups, meeting the low-latency and scalability requirements.

Exam trap

The trap here is that candidates often choose Option D because they think a GSI on followee ID solves the query pattern, but they overlook that the base table's partition key (user ID) does not match the follower-based access pattern, requiring multiple queries or a Scan, and the GSI still incurs additional latency and cost for index maintenance.

How to eliminate wrong answers

Option A is wrong because using post ID as the partition key scatters posts randomly across partitions, and a local secondary index on followee ID would require a full table scan to find all posts for a given followee, as LSIs cannot be queried independently of the base table's partition key. Option B is wrong because a Scan operation reads every item in the table and then filters on the followee attribute, which is not scalable and violates the low-latency requirement for a social media application. Option D is wrong because while a GSI on followee ID allows querying by followee, the base table's partition key of user ID does not align with the follower-based access pattern, and the GSI would still require a separate query for each followee, leading to multiple round trips and higher latency compared to a single query in Option C.

Practice this question →
74
MCQeasy

A startup is building a social media analytics platform that requires storing time-series data with frequent writes and queries for the last hour. Which AWS database service is BEST suited for this workload?

A.Amazon Timestream
B.Amazon RDS with MySQL
C.Amazon Neptune
D.Amazon DynamoDB
AnswerA

Timestream is a fast, scalable, serverless time-series database.

Why this answer

Option C is correct because Timestream is purpose-built for time-series data and supports high-frequency writes and recent data queries. Option A is wrong because RDS is not optimized for time-series. Option B is wrong because DynamoDB can store timestamps but lacks time-series optimizations.

Option D is wrong because Neptune is a graph database.

Practice this question →
75
MCQmedium

A company is designing a database for a global e-commerce platform that requires low-latency reads and writes across multiple AWS Regions. The database must support strongly consistent reads and provide automatic failover. Which AWS service should the company use?

A.Amazon ElastiCache for Redis global datastore
B.Amazon S3 with cross-region replication
C.Amazon Aurora Global Database
D.Amazon DynamoDB global tables
AnswerD

DynamoDB global tables provide multi-Region, multi-master replication with strong consistency and automatic failover.

Why this answer

Amazon DynamoDB global tables provide a fully managed, multi-Region, multi-active database solution that delivers low-latency reads and writes across AWS Regions. It supports strongly consistent reads when using the same-Region endpoint and offers automatic failover by allowing any Region to handle writes independently, ensuring high availability without manual intervention.

Exam trap

The trap here is that candidates often confuse Amazon Aurora Global Database (which is active-passive) with a multi-active solution, assuming it supports automatic failover for writes across Regions, but DynamoDB global tables are the only option that provides true multi-Region write capability with automatic failover.

How to eliminate wrong answers

Option A is wrong because Amazon ElastiCache for Redis global datastore is an in-memory cache, not a durable database, and it does not support strongly consistent reads across Regions (it offers eventual consistency for cross-Region replication). Option B is wrong because Amazon S3 with cross-region replication is an object storage service that does not support strongly consistent writes across Regions (replication is eventually consistent) and lacks automatic failover for database workloads. Option C is wrong because Amazon Aurora Global Database supports only one primary Region for writes (active-passive), so it does not provide multi-Region write capability or automatic failover for writes across Regions; failover requires promoting a secondary Region, which is not automatic.

Practice this question →
Page 1 of 6 · 444 questions totalNext →

Ready to test yourself?

Try a timed practice session using only Workload-Specific Database Design questions.

Start 20-question session