CCNA Db Design Questions

Why this answer

How to eliminate wrong answers

Option B is wrong because self-managed MongoDB on Amazon EC2 requires the company to manually handle patching, backups, and operational overhead, which contradicts the requirement for automated patching and backups. Option C is wrong because Amazon DynamoDB is a key-value and document database that is not MongoDB-compatible; it uses a different API and data model, so it cannot run MongoDB workloads. Option D is wrong because Amazon RDS for MySQL is a relational database that does not support the MongoDB wire protocol or document model, making it incompatible with MongoDB-based applications.

Why this answer

Why this answer

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 storing and querying JSON documents with varying attributes using SQL-like queries. Option C is wrong because Amazon DynamoDB with PartiQL is a NoSQL key-value and document database that supports SQL-compatible queries, but it is optimized for high-scale, low-latency workloads with a fixed primary key schema; while it can store JSON, it does not natively support rich querying on varying attributes without secondary indexes and is less suited for complex SQL-like joins or aggregations compared to a document database. Option D is wrong because Amazon RDS for MySQL with JSON data type requires a fixed relational schema for the table structure, and while it can store JSON in a column, it does not provide the flexible schema or native document querying capabilities that DocumentDB offers; querying varying attributes often involves complex JSON functions and can lead to performance issues in read-heavy workloads.

Why this answer

How to eliminate wrong answers

Option A is wrong because the COPY command is an Amazon Redshift feature for loading data into Redshift, not for exporting from RDS; it cannot pull data from RDS directly. Option C is wrong because the AWS Schema Conversion Tool (SCT) is designed for schema conversion and heterogeneous database migrations, not for efficient ad-hoc data export of query results to S3. Option D is wrong because mysqldump exports entire tables or databases in a serialized format (SQL or delimited text) that requires manual upload to S3, and it cannot handle complex joins or subsetting efficiently, making it far less efficient than the native S3 export extension.

Why this answer

How to eliminate wrong answers

Option A is wrong because GetItem requires both partition key and sort key; using only device_id with a maximum timestamp is not a valid operation—GetItem cannot compute a max value, and you would need to know the exact timestamp. Option B is wrong because ScanIndexForward=true retrieves items in ascending order (oldest first), so with Limit=10 you get the oldest 10 items, not the latest; reversing the result set still gives the oldest 10, not the newest. Option D is wrong because Scan reads the entire table, which is inefficient and costly for large datasets, and filtering by device_id after scanning defeats the purpose of using DynamoDB's indexed access.

Why this answer

How to eliminate wrong answers

Option A is wrong because a single Redis node in one AZ provides no redundancy; if the node or AZ fails, all session data is lost and the application becomes unavailable. Option B is wrong because a Redis cluster with cluster mode disabled (i.e., a single shard with replicas) can provide multi-AZ replication, but the question specifies 'cluster mode enabled' is required for the configuration that explicitly supports sharding and scaling; however, the core issue is that cluster mode disabled still allows replicas in different AZs, but the exam trap is that candidates may think cluster mode disabled cannot achieve multi-AZ HA—actually it can, but the question's correct answer explicitly requires cluster mode enabled for the described scenario, and the other options are clearly wrong. Option C is wrong because Memcached does not support replication or persistence; it is a pure caching engine with no built-in high availability or failover, so it cannot guarantee session data durability across AZ failures.

Why this answer

How to eliminate wrong answers

Option A is wrong because exporting data to Amazon Elasticsearch Service introduces unnecessary complexity, latency, and cost for a simple query pattern that DynamoDB can handle natively with an index. Option B is wrong because a Local Secondary Index (LSI) can only be created at table creation time and shares the same partition key as the base table, which would not allow efficient querying by subscription tier and registration date as a composite sort key across all partitions. Option C is wrong because enabling DynamoDB Streams and populating a separate table adds operational overhead and eventual consistency delays without providing the direct query capability that a GSI offers.

Why this answer

How to eliminate wrong answers

Option A is wrong because DynamoDB with a time-series design pattern requires manual sharding, TTL management, and lacks native time-series query optimizations, leading to higher complexity and cost for large-scale append-only workloads. Option C is wrong because Amazon Redshift is a columnar data warehouse designed for complex analytical queries on structured data, not for high-ingest, append-only time-series data; its minimum cluster size and provisioning overhead make it less cost-effective for this use case. Option D is wrong because Amazon RDS for MySQL with partitioning by date incurs significant storage and I/O overhead for high-frequency inserts, lacks automatic tiered storage, and requires manual maintenance of partitions, making it less performant and more expensive than a purpose-built time-series database.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon DynamoDB Global Tables is a NoSQL database, not a relational database, and the question explicitly requires a relational database. Option B is wrong because Amazon RDS with Multi-AZ deployment only provides high availability within a single AWS Region (across Availability Zones), not automated failover across Regions. Option D is wrong because Amazon Redshift with cross-Region snapshot copy is a data warehouse solution, not a relational database designed for transactional e-commerce workloads, and its cross-Region copy is manual or scheduled, not automated failover.

Why this answer

How to eliminate wrong answers

Option A is wrong because the policy does not require a filter expression for Scan; filter expressions are optional and do not affect IAM authorization. Option B is wrong because the Deny statement uses `NotAction` to block all actions except those listed (like `dynamodb:GetItem`), but `dynamodb:Scan` is not listed in the Deny's `NotAction`, so it is not blocked. Option D is wrong because IAM policies do not require a condition element for an action to be allowed; conditions are optional and only refine permissions.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon RDS for PostgreSQL is a relational database that would require complex JOINs across multiple tables (users, posts, comments, likes) to traverse many-to-many relationships, leading to poor performance as the social graph grows. Option C is wrong because Amazon DocumentDB is a document database optimized for JSON-like documents and does not natively support graph traversal queries or relationship traversal without application-level joins. Option D is wrong because Amazon DynamoDB is a key-value and document database that lacks native graph traversal capabilities; modeling many-to-many relationships would require manual denormalization, adjacency lists, or multiple queries with application-side logic, which is inefficient for deep relationship queries.

Why this answer

How to eliminate wrong answers

Option A is wrong because simply increasing the RDS instance size does not address the fundamental architectural limitation: MySQL is optimized for OLTP, not for full-table scans and large aggregations; the query will still be I/O and CPU-bound, and scaling vertically has a hard ceiling and high cost. Option C is wrong because creating a materialized view in MySQL adds significant operational overhead—it requires custom refresh logic, storage management, and risks data staleness, contradicting the requirement to minimize overhead. Option D is wrong because adding a composite index on (account_id, transaction_date) will not help a query that scans the entire table with a GROUP BY; the optimizer will likely ignore the index for a full scan, and even if used, it cannot avoid reading all rows for aggregation.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because ElastiCache caches query results or session data, not database connections; it does not reduce failover downtime for the database itself. Option C is wrong because increasing instance size improves performance but does not affect the failover process timing, which is governed by DNS propagation and replication lag, not compute capacity. Option D is wrong because promoting a read replica manually requires application reconfiguration and typically takes longer than 30 seconds due to DNS changes and manual intervention, defeating the goal of automated fast failover.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon Neptune is a graph database optimized for highly connected data (e.g., social graphs, recommendation engines) and does not support SQL JOINs or relational schema design; it uses Gremlin or SPARQL query languages. Option C is wrong because Amazon DynamoDB is a NoSQL key-value and document database that lacks native JOIN operations; while global secondary indexes improve query flexibility, they cannot replace the relational JOIN logic required for generating a user's feed. Option D is wrong because Amazon ElastiCache for Redis is an in-memory caching layer, not a primary database; it does not support complex JOIN queries or provide durable, relational storage.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon S3 is an object storage service designed for large, static objects with higher latency (typically tens to hundreds of milliseconds), not suitable for low-latency session state access. Option C is wrong because Amazon DynamoDB is a NoSQL database that offers single-digit millisecond latency, but it is a disk-based service with higher overhead for very small, frequently accessed session data compared to an in-memory cache like Redis. Option D is wrong because Amazon RDS for MySQL is a relational database with ACID transactions and disk-based storage, introducing unnecessary latency and complexity for simple key-value session storage, and it lacks native TTL-based expiration for session data.

Why this answer

How to eliminate wrong answers

Option A is wrong because Multi-AZ failover in the primary region would cause a brief write outage or failover time, not consistently longer write latencies; after failover, writes resume normally. Option B is wrong because Aurora Global Database replication is asynchronous, not synchronous; synchronous replication would cause commit latency, but that is not how Aurora Global Database works. Option D is wrong because read replicas in secondary regions are read-only and do not affect write performance on the primary; they handle only read traffic.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon DynamoDB is a key-value and document database that does not support MongoDB aggregation pipelines or MongoDB wire protocol, requiring significant application rewrites. Option C is wrong because Amazon RDS for PostgreSQL is a relational database that does not natively support MongoDB's document model or aggregation pipelines, forcing schema redesign and data migration complexity. Option D is wrong because Amazon Elasticsearch Service is a search and analytics engine, not a document database, and lacks MongoDB compatibility, making it unsuitable for running MongoDB workloads.

Why this answer

Why this answer

How to eliminate wrong answers

Option B (Amazon Neptune) is wrong because it is a graph database optimized for highly connected data and complex relationship queries (e.g., social graphs), but the question emphasizes flexible schemas and horizontal scaling for general content types, not graph traversal performance; Neptune also has a different scaling model and is not as cost-effective for simple key-value or document workloads. Option C (Amazon Redshift) is wrong because it is a columnar data warehouse designed for analytical queries on large datasets, not for transactional workloads with flexible schemas; it does not support real-time, low-latency reads/writes for a social media application and has a different scaling architecture. Option D (Amazon RDS for MySQL) is wrong because it is a relational database with a fixed schema, requiring predefined tables and relationships, which contradicts the need for flexible schemas; it also scales vertically (by increasing instance size) rather than horizontally, and single-AZ deployments can be a single point of failure unless Multi-AZ is configured, which still does not provide the same horizontal scaling as DynamoDB.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon RDS for MySQL is a relational database designed for transactional workloads, not for storing and querying large volumes of log data at petabyte scale; it would be prohibitively expensive for 90 TB of logs and lacks native log expiration features. Option B is wrong because Amazon Redshift is a data warehouse optimized for complex analytical queries on structured data, but it is overkill and costly for simple log retention and periodic queries; it also requires loading data into the warehouse, incurring additional compute and storage costs. Option C is wrong because Amazon DynamoDB is a NoSQL key-value and document database designed for low-latency access at scale, but it is not cost-effective for storing 90 TB of log data due to its per-GB storage cost and provisioned throughput costs; while TTL can expire items, DynamoDB is not optimized for analytical queries like S3 Select.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon DynamoDB is a NoSQL key-value and document database optimized for high-scale OLTP workloads, but it lacks native support for complex SQL joins, aggregations, and the relational schema required for read-heavy analytics typical of an e-commerce platform. Option B is wrong because Amazon RDS for MySQL, while supporting read replicas, has a single-AZ primary by default and requires Multi-AZ deployment for failover, which still incurs a longer failover time (typically 1-2 minutes) and does not offer the same level of read replica performance or automatic scaling as Aurora. Option C is wrong because Amazon Redshift is a columnar data warehouse designed for large-scale analytics and OLAP workloads, not for OLTP transactions with high concurrency and sub-millisecond latency requirements.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon RDS Proxy is a connection pooling service for relational databases, not designed for offline sync or mobile client data caching. Option B is wrong because Amazon S3 Transfer Acceleration speeds up uploads to S3 over long distances using edge locations, but it does not provide offline write queuing or conflict resolution for application data. Option C is wrong because Amazon Cognito is an identity and user management service; while it can integrate with AppSync for authentication, it alone does not enable offline data synchronization or local mutation storage.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because AWS Glue is an ETL service designed for transforming and loading data into data lakes or analytics services, not for direct database migration with minimal downtime; it cannot handle ongoing replication of MySQL binary logs. Option B is wrong because you cannot attach an EBS volume to an RDS instance; RDS manages its own storage and does not allow direct mounting of external EBS volumes. Option C is wrong because mysqldump is a logical backup tool that requires taking the source database offline or locking tables to ensure consistency, resulting in significant downtime for a 500 GB database with a high write workload.

Why this answer

How to eliminate wrong answers

Option A is wrong because DynamoDB Accelerator (DAX) is an in-memory cache that reduces read latency but does not handle write capacity spikes or automatically adjust provisioned throughput; it addresses performance, not scaling. Option C is wrong because TTL (Time to Live) is used to automatically expire and delete old items to manage storage costs and data retention, not to handle traffic spikes or scale capacity. Option D is wrong because DynamoDB Global Tables provide multi-region replication for disaster recovery and low-latency global access, but they do not automatically scale read/write capacity in response to traffic spikes; each replica table still requires its own capacity management.

Why this answer

How to eliminate wrong answers

Option A is wrong because increasing the DB instance class to db.r5.xlarge would add more CPU and memory to the primary instance, but it does not offload read traffic; the primary would still handle all read requests, potentially increasing CPU utilization further. Option C is wrong because changing storage type to io1 with higher IOPS improves disk I/O performance but does not reduce CPU load; CPU utilization is driven by query processing, not storage throughput. Option D is wrong because enabling Multi-AZ deployment provides high availability and automatic failover via synchronous standby replication, but it does not offload read traffic; the standby replica cannot serve reads, so CPU load on the primary remains unchanged.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon RDS for MySQL with read replicas is a relational database that cannot achieve sub-millisecond read latency for leaderboard queries at high write throughput; read replicas introduce replication lag and are not designed for real-time, high-frequency writes. Option B is wrong because Amazon Redshift is a petabyte-scale data warehouse optimized for complex analytical queries on large datasets, not for real-time, high-write-throughput transactional workloads or sub-millisecond reads. Option C is wrong because Amazon ElastiCache for Redis is an in-memory cache, not a durable database; while it provides sub-millisecond latency, it lacks the persistence and durability guarantees needed for storing player scores and leaderboards as a primary database, and data loss can occur on node failure.

Why this answer

How to eliminate wrong answers

Option A is wrong because manual sharding across multiple Aurora clusters requires significant application code changes to route queries, which violates the constraint of not changing application code. Option B is wrong because adding read replicas only offloads read traffic and does nothing to reduce write contention or deadlocks on the primary writer. Option C is wrong because using a larger instance type with higher IOPS can improve performance but does not address the fundamental issue of concurrent write contention; it still relies on a single writer node, which remains a bottleneck.

Why this answer

How to eliminate wrong answers

Option B is wrong because Amazon RDS for MySQL is a relational database that uses SQL joins and indexes to model relationships, which becomes inefficient and slow for deep graph traversals as the number of connections grows. Option C is wrong because Amazon ElastiCache for Redis is an in-memory key-value store, not a graph database; while it can store adjacency lists, it lacks native graph query capabilities like Gremlin or SPARQL, and traversals require application-level logic. Option D is wrong because Amazon DynamoDB is a NoSQL key-value and document database that does not support graph-specific operations; modeling graph data in DynamoDB requires manual adjacency lists and results in high-latency multi-hop queries due to its lack of native graph traversal engines.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon Neptune is a graph database optimized for highly connected data (e.g., social networks, fraud detection), not for high-throughput, low-latency key-value access patterns required by a real-time leaderboard. Option B is wrong because Amazon Redshift is a petabyte-scale data warehouse designed for complex analytical queries on large datasets, not for single-digit millisecond transactional updates or real-time point lookups. Option D is wrong because Amazon RDS for PostgreSQL is a relational database that, while capable, introduces overhead from ACID transactions, indexing, and connection management that typically results in higher latency (often 5–20 ms or more) compared to DynamoDB's optimized NoSQL engine, and it does not natively support the auto-scaling or DAX caching needed for such a dynamic workload.

Why this answer

How to eliminate wrong answers

Option B is wrong because AWS Data Pipeline is a workflow orchestration service, not a database migration tool; it lacks built-in CDC capabilities and would require manual scripting to handle ongoing replication, leading to significant downtime. Option C is wrong because AWS SCT only converts the schema and code, not the data; using native PostgreSQL tools for data migration would require the source database to be offline or heavily throttled, causing unacceptable downtime for the nightly batch job. Option D is wrong because AWS Glue is an ETL service designed for data transformation and analytics, not for transactional database migrations; it does not support ongoing replication (CDC) and would require the source to be quiesced, breaking the requirement for minimal downtime.

Why this answer

How to eliminate wrong answers

Option A is wrong because enabling DynamoDB Streams adds cost and complexity without addressing the access pattern; streams are for change data capture, not for efficient querying of recent messages. Option B is wrong because DAX is an in-memory cache that reduces read latency but adds cost and complexity; the primary access pattern can be efficiently served directly from DynamoDB without caching, making DAX unnecessary and more expensive. Option D is wrong because using a GSI on timestamp introduces additional storage and write costs, and the query still requires a ScanIndexForward=false with Limit=50 on the GSI, which is redundant since the base table's sort key already supports the same pattern more efficiently.

Why this answer

How to eliminate wrong answers

Option B is wrong because Performance Insights and RDS Proxy are designed for monitoring and connection management, not for offloading analytical queries; they do not prevent analytical workloads from consuming Aurora's compute and I/O resources. Option C is wrong because exporting data to S3 and querying with Athena introduces latency and manual ETL steps, and Athena is optimized for ad-hoc querying of data lakes, not for continuous, complex analytical queries on live transactional data. Option D is wrong because an Aurora Replica shares the same underlying storage and can still impact the primary instance's performance during heavy analytical queries, as it competes for storage I/O and can cause replication lag.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon Redshift is a columnar data warehouse optimized for complex analytical queries on large datasets, not for high-velocity, high-volume time-series ingestion; its auto-ingest feature cannot handle millions of writes per second without significant cost and latency. Option C is wrong because Amazon RDS for PostgreSQL with pg_partman is a relational database that, even with partitioning, cannot sustain millions of writes per second due to single-writer limitations and transaction overhead, and it lacks the specialized storage tiering for time-series data. Option D is wrong because while DynamoDB can be modeled for time-series data, it is not purpose-built for time-series workloads; it requires manual partitioning and TTL management, and its query model is less efficient for range scans over time compared to Timestream's native time-based indexing.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon Aurora is a relational database optimized for OLTP workloads with moderate write throughput; it cannot sustain millions of writes per second without significant scaling challenges and incurs higher latency for simple key-value lookups. Option C is wrong because Amazon ElastiCache for Redis is an in-memory cache, not a durable database; while it can serve recent data quickly, it lacks the persistence, durability, and query capabilities (e.g., filtering by timestamp) required for a primary data store of sensor readings. Option D is wrong because Amazon RDS for MySQL is a relational database with limited write scalability and higher per-request overhead; it would require complex sharding and still struggle with the ingestion rate and the need for a simple, fast 'latest reading' query.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon DynamoDB is a key-value and document database that does not natively support graph traversals; querying friends of friends would require multiple expensive client-side joins or scans. Option B is wrong because Amazon RDS for MySQL is a relational database that can model relationships with JOINs, but it suffers from performance degradation and complexity as the depth of graph traversals increases, lacking native graph traversal optimizations. Option C is wrong because Amazon ElastiCache for Redis is an in-memory data store primarily used for caching, session management, and simple data structures; while it can store adjacency lists, it does not provide a graph query language or support complex multi-hop traversals efficiently.

Why this order

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because scanning the entire table and filtering on user ID would read every item in the table, consuming excessive read capacity and causing high latency, especially as the table grows. Option B is wrong because storing all orders as a JSON document in a single item per user would exceed DynamoDB's 400 KB item size limit when a user has up to 10,000 orders, and it prevents efficient filtering and pagination by order date. Option C is wrong because while a Global Secondary Index (GSI) on order date could support date-based queries, it would require a separate query to retrieve orders for a specific user and would not be as efficient as using the sort key on the base table, which avoids the eventual consistency and additional cost of a GSI.

Why this answer

How to eliminate wrong answers

Option B is wrong because Amazon RDS for PostgreSQL with partitioning requires manual management of partition maintenance, vacuuming, and scaling, and does not natively separate hot and cold storage tiers for time-series data, leading to higher operational overhead and cost for this volume. Option C is wrong because Amazon DynamoDB with TTL only handles data expiration, not efficient range scans or aggregation queries over time-series data; it lacks native time-based query optimization and can result in high read costs for scanning large time ranges. Option D is wrong because Amazon S3 with Athena and partitioning requires running a query engine that incurs per-scan costs and latency, making it unsuitable for frequent sub-second queries on the last 30 days of data, and it lacks a built-in hot/cold storage tier.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because partitioning by a high-cardinality, low-selectivity column would create many partitions with similar row counts, offering minimal pruning benefit and adding management overhead without improving query performance. Option B is wrong because a read replica offloads the query execution but does not optimize the query itself; the same slow table scan or index lookup would still occur on the replica. Option C is wrong because increasing provisioned read IOPS addresses throughput capacity but does not reduce the number of I/O operations required; the query still performs the same inefficient access pattern.

Why this answer

How to eliminate wrong answers

Option A is wrong because partitioning by month would still require scanning all partitions for the last 30 days unless the table is partitioned by day, and even then, querying multiple partitions still incurs overhead; moreover, partitioning alone does not precompute aggregates, so the query would still need to aggregate rows across partitions, which may not achieve sub-30-second performance. Option C is wrong because a composite index on the date and sales amount columns would not eliminate the need to scan and aggregate 500 million rows; the index would help with filtering but the aggregation step would still require a full index scan or table scan, and the query time would remain high. Option D is wrong because upgrading to a larger RDS instance increases cost significantly without addressing the root cause—the query still performs a full table scan and aggregation; it may reduce time but not reliably to under 30 seconds, and it is not cost-effective compared to precomputing results.

Why this answer

How to eliminate wrong answers

Option A is wrong because using SCT for schema only leaves the stored procedures unconverted, and no data migration is performed, so the database cannot be used. Option C is wrong because Oracle Data Pump and pg_restore are manual, offline tools that require significant downtime for a 1 TB database and do not handle stored procedure conversion automatically, likely exceeding the 4-hour window. Option D is wrong because DMS with ongoing replication alone does not convert the schema or stored procedures; it requires a compatible target schema, which is missing without SCT.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon RDS for MySQL uses a fixed schema, which conflicts with the requirement for flexible schemas, and its read throughput is limited by instance size without native auto-scaling for high traffic. Option B is wrong because Amazon Neptune is a graph database designed for highly connected data (e.g., social graphs), but it does not provide strong consistency by default (it uses eventual consistency) and is overkill for simple user profiles and friend requests. Option D is wrong because Amazon DocumentDB (MongoDB-compatible) offers flexible schemas but does not support strong consistency for read operations (it uses eventual consistency by default), making it unsuitable for friend requests that require immediate consistency.

Why this answer

How to eliminate wrong answers

Option B is wrong because DynamoDB global tables replicate data across regions for disaster recovery and low-latency reads, but they do not solve hot partition issues within a single table. Option C is wrong because DAX is an in-memory cache that accelerates reads, not writes, and does not address write-heavy throttling. Option D is wrong because increasing RCU only improves read capacity, but the problem is write-heavy throttling; increasing write capacity units (WCU) would be needed, and even that does not fix the underlying hot partition issue.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon Aurora is a relational database with a fixed schema, which does not support flexible schema design and incurs higher latency for high-write workloads compared to DynamoDB. Option B is wrong because Amazon ElastiCache for Redis is an in-memory cache, not a durable database; it lacks persistent storage guarantees and is intended for caching, not as a primary data store for user profiles. Option C is wrong because Amazon RDS for MySQL is a relational database with a rigid schema, requiring schema migrations for flexible fields, and its write throughput is limited by the underlying instance size and replication overhead, making it unsuitable for high-write, low-latency access with a flexible schema.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon ElastiCache for Redis is an in-memory cache, not a durable database; it cannot reliably store 10,000 writes/sec of 1 KB events long-term without data loss on failure, and OpenSearch Service is optimized for search and log analytics, not cost-effective ad-hoc SQL queries on months of historical data. Option C is wrong because Amazon Redshift is a data warehouse designed for batch and complex analytical queries, not for sub-second real-time writes at 10,000/sec; its write throughput is limited by node types and it incurs high costs for continuous ingestion of streaming data. Option D is wrong because Amazon RDS for PostgreSQL with read replicas cannot sustain 10,000 writes/sec on a single primary instance without significant scaling issues, and using Redshift for historical analytics adds unnecessary cost and complexity compared to S3 and Athena.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon RDS for PostgreSQL is a relational database optimized for OLTP workloads, not for high-velocity time-series ingestion or time-based analytical queries; it lacks automatic time-series data lifecycle management and can suffer from write contention under high-frequency sensor data. Option B is wrong because Amazon DynamoDB with TTL is a key-value and document database designed for low-latency lookups and simple queries, not for complex analytical queries over time-series data; TTL only handles data expiration, not time-based aggregation or interpolation. Option D is wrong because Amazon Redshift is a columnar data warehouse optimized for batch analytics and complex queries over large datasets, but it is not designed for real-time, high-frequency ingestion of streaming IoT data; its ingestion latency and cost model are unsuitable for per-second sensor writes.

Why this answer

How to eliminate wrong answers

Option A is wrong because QLDB is a fully managed ledger database that automatically partitions data; manual partitioning by transaction date is not supported and would not distribute write load. Option B is wrong because creating multiple ledgers increases operational complexity and does not inherently increase write throughput per ledger; QLDB's throughput limit applies per ledger, and distributing writes across ledgers would require application-level sharding, which is not a recommended design for a single ledger system. Option C is wrong because QLDB does not support auto-scaling; it has a fixed throughput limit of 1,000 transactions per second per ledger, and enabling auto-scaling is not a feature available in QLDB.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because simply increasing WCUs to 5000 does not solve the hot partition issue — the writes are still concentrated on a single partition key (user_id), and a single partition can only handle up to 1,000 WCUs (or 3,000 if using burst capacity), so throttling will persist. Option B is wrong because DynamoDB Accelerator (DAX) is an in-memory cache for reads, not writes — it does not absorb or buffer write requests, so it cannot reduce write throttling. Option D is wrong because creating a Global Secondary Index (GSI) on the like count attribute does not affect the base table's write capacity or partition distribution; GSIs have their own write capacity and are used for querying, not for alleviating write contention on the base table.

Why this answer

How to eliminate wrong answers

Option A is wrong because on-demand backups are point-in-time snapshots that require manual restore to another Region, which typically takes longer than 15 minutes and does not provide continuous replication for real-time availability. Option B is wrong because DynamoDB Streams with AWS Lambda introduces eventual consistency and potential replication lag that can exceed 15 minutes, and it requires custom code for conflict resolution and error handling, making it less reliable for strict RTOs. Option D is wrong because DynamoDB does not support cross-Region Read Replicas; this feature is available in Amazon RDS (e.g., Aurora, MySQL) but not in DynamoDB, which uses Global Tables for multi-Region replication.

Why this answer

How to eliminate wrong answers

Option A is wrong because on-demand capacity mode does not have a maximum read capacity unit setting; it scales automatically based on traffic, and increasing a non-existent setting cannot fix a hot key issue. Option B is wrong because switching to provisioned capacity mode and increasing write capacity units does not address the root cause of a hot key; it only increases the overall table throughput, but a single partition still has a hard limit of 1,000 write capacity units, so throttling will persist. Option D is wrong because DynamoDB Accelerator (DAX) is an in-memory cache for reads, not writes; it cannot absorb or distribute write traffic, so it does not solve write throttling due to a hot key.

Why this answer

How to eliminate wrong answers

Option A is wrong because DynamoDB Accelerator (DAX) is an in-memory cache that speeds up read-heavy workloads but does not change the underlying data model or query pattern; it would still require full table scans for analytical queries that aggregate by month. Option B is wrong because changing the sort key from TransactionDate to Month would break existing query patterns that rely on precise date ranges and would not eliminate the need for scans if the partition key alone is used; it also does not support efficient aggregation across all accounts. Option C is wrong because enabling DynamoDB Streams and processing with Lambda to pre-aggregate results introduces eventual consistency and operational complexity, and it does not improve the performance of the existing query directly; it is a workaround for real-time aggregation, not a design change for the current query.

Why this answer

Why this answer

Why this answer

How to eliminate wrong answers

Option B is wrong because Amazon RDS for MySQL with a normalized schema would require complex multi-table joins (e.g., document, tag, document_tag junction table) to query by tag combinations, which becomes slow and unscalable at 50 million documents and 20 tags per document, leading to performance bottlenecks and the need for extensive indexing and query optimization. Option C is wrong because Amazon Neptune is a graph database designed for highly connected data and complex graph traversals (e.g., social networks, recommendation engines), which is overkill and unnecessarily complex for simple tag-based document queries that do not require graph-specific operations like shortest path or pattern matching. Option D is wrong because Amazon ElastiCache for Memcached is a caching layer, not a persistent database; it lacks query capabilities for tag-based filtering and cannot serve as the primary data store for 50 million documents with flexible query requirements.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon RDS for MySQL with self-joins is a relational database that does not natively support graph traversal operations; self-joins become exponentially slower and more complex as the depth of relationships increases, leading to poor performance at tens of terabytes. Option B is wrong because Amazon Redshift is a columnar data warehouse designed for analytical queries on large datasets, not for real-time graph queries or transactional relationship storage, and it lacks native graph traversal capabilities. Option C is wrong because Amazon DynamoDB with adjacency list design can model simple one-to-many relationships but is not optimized for multi-hop graph traversals; queries like 'find followers of followers' require multiple round trips and client-side joins, resulting in high latency and complexity at scale.

Why this answer

How to eliminate wrong answers

Option A is wrong because switching to DynamoDB on-demand mode would eliminate throttling but introduces unpredictable costs and may not be cost-effective for a workload with a baseline of 5000 RCU and only occasional spikes; on-demand is designed for unpredictable or new workloads, not for optimizing cost in a known pattern. Option B is wrong because adding a global secondary index (GSI) with a different partition key does not address read capacity throttling on the base table; GSIs have their own read/write capacity and are used for alternative query patterns, not for scaling existing read throughput. Option D is wrong because adding a DAX cluster caches read requests to reduce latency and offload reads from the table, but it does not increase the provisioned read capacity; if the cache misses or the DAX cluster itself is overwhelmed, throttling can still occur on the underlying table.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon Aurora (MySQL compatible) is a relational database with a fixed schema, requiring predefined tables and columns, which conflicts with the schema-less requirement; it also does not natively provide single-digit millisecond latency for all access patterns under high throughput. Option B is wrong because Amazon Redshift is a petabyte-scale data warehouse optimized for complex analytical queries (OLAP), not for low-latency reads and writes of individual user profiles (OLTP). Option C is wrong because Amazon RDS for SQL Server is a relational database with a rigid schema and is not designed for schema-less data; it also cannot guarantee single-digit millisecond latency under rapid growth and high concurrency without significant over-provisioning.

Why this answer

How to eliminate wrong answers

Option A is wrong because sharding across multiple Aurora clusters adds significant application complexity (e.g., distributed transactions, cross-cluster joins) and does not address the root cause of random-write overhead from UUIDs. Option C is wrong because read replicas cannot handle write traffic; they only serve read queries, so redirecting write-heavy queries to replicas is impossible and would not reduce write latency on the writer instance. Option D is wrong because upgrading the instance type with more IOPS only masks the symptom of high write latency; it does not fix the underlying index fragmentation caused by UUID primary keys, so the latency will persist after the upgrade.

Why this answer

Why this answer

How to eliminate wrong answers

Option B is wrong because Amazon ElastiCache for Redis with replication across Regions is not natively multi-master; cross-Region replication requires additional tooling (e.g., Global Datastore for Redis) and does not offer the same strong consistency or automatic conflict resolution as DynamoDB global tables for frequent writes. Option C is wrong because Amazon Aurora Global Database is designed for relational workloads with a single writer and multiple readers, which cannot handle the high-velocity, concurrent writes required by a real-time leaderboard without introducing write bottlenecks and latency. Option D is wrong because Amazon S3 with event notifications is not a real-time database; it introduces significant latency for updates and lacks the low-latency query capabilities needed for a live leaderboard, making it unsuitable for frequent updates and global access.

Why this answer

How to eliminate wrong answers

Option A is wrong because adding a composite index on (event_type, event_time) may improve some queries but does not solve the fundamental problem of scanning a 500-million-row table for a one-hour time range; the index still has to traverse a large B-tree and fetch rows from the heap, leading to significant I/O. Option C is wrong because migrating to DynamoDB with TTL is designed for automatic item expiration, not for improving query performance on time-series data; DynamoDB lacks native time-range query optimization like partition pruning and would require careful design of partition keys and secondary indexes to avoid hot partitions. Option D is wrong because upgrading to a larger RDS instance provides more CPU and memory but does not change the fact that queries must scan the entire table or a large index; it is a vertical scaling approach that does not address the architectural inefficiency of a monolithic table for time-based queries.

Why this answer

How to eliminate wrong answers

Option A is wrong because AWS CloudTrail records AWS API calls (e.g., RDS instance creation, modification) but does not capture database-level DML operations like INSERT, UPDATE, or DELETE. Option B is wrong because Oracle Flashback is a feature for point-in-time recovery and historical queries, not for continuous auditing of DML changes; additionally, flashback logs are stored internally and cannot be easily exported to an external audit store. Option C is wrong because Oracle Audit Vault requires installation of an agent on the database host and is not supported on Amazon RDS, which does not allow custom software installation or OS-level access.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon RDS Multi-AZ is a single-region, high-availability feature that provides a standby replica in a different Availability Zone, not multi-region active-active capability, and it does not support conflict resolution. Option C is wrong because Amazon Redshift is a data warehouse optimized for analytical queries, not low-latency transactional reads and writes across regions, and it lacks conflict resolution mechanisms. Option D is wrong because Amazon Aurora Global Database is designed for cross-region replication but supports only one primary region for writes (active-passive), not active-active, and it does not provide built-in conflict resolution for concurrent writes.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because querying the table by game_id and sorting results in the application requires retrieving all players for that game, which is inefficient for large datasets and does not scale. Option B is wrong because a Scan operation with a filter expression and Limit=10 still reads the entire table (up to 1 MB per scan) before applying the filter, incurring high read costs and latency. Option C is wrong because a local secondary index (LSI) shares the table's partition key but cannot be queried independently; it requires the same partition key and sort key combination as the base table, and the LSI's sort key (score) cannot be used to retrieve top N items without scanning all items for that partition key.

Why this answer

Why this answer

How to eliminate wrong answers

Option B is wrong because TTL does not enforce uniqueness on the 'expire_time' attribute; DynamoDB only uses the attribute's value to determine expiration, and multiple items can share the same timestamp. Option C is wrong because TTL never automatically updates the 'expire_time' attribute when an item is read; it is a passive deletion mechanism based solely on the stored timestamp. Option D is wrong because TTL does not create backups of expired items; expired items are permanently deleted within 48 hours of expiration, and you must use DynamoDB Streams or separate backup mechanisms to capture them before deletion.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon ElastiCache for Redis is an in-memory key-value store, not a document database; it does not natively support JSON document storage with MongoDB-compatible querying, and its eventual consistency model (with optional strong consistency via WAIT command) is not designed for persistent, read-after-write consistent document workloads. Option B is wrong because Amazon DynamoDB is a key-value and document database but uses a different API and consistency model (eventually consistent reads by default, with strongly consistent reads available at additional cost); it lacks MongoDB wire protocol compatibility, requiring application refactoring. Option C is wrong because Amazon RDS for PostgreSQL is a relational database that stores data in tables with a fixed schema, not as JSON documents; while it supports JSONB, it does not provide MongoDB-compatible APIs or automatic scaling of storage without manual intervention, and it requires schema migration from MongoDB's document model.