SAA-C03 - Design High-Performing Architectures (24% of the exam) - Section 3.5

Determine high-performing database solutions by selecting relational and purpose-built databases such as Amazon RDS, Amazon Aurora and Amazon DynamoDB.

Compare Amazon RDS managed relational databases, Amazon Aurora's cloud-native engine with up to five times the throughput of standard MySQL, and Amazon DynamoDB's managed NoSQL key-value and document store. Recognise when a purpose-built database such as Amazon Neptune for graph data, Amazon Timestream for time-series, or Amazon OpenSearch Service for full-text search suits an access pattern better than a relational engine.

Amazon AuroraAmazon DynamoDBAmazon RDSPurpose-built databases

Practice question for this objective

Free sampleDesign High-Performing Architectureshard

A solutions architect is choosing purpose-built databases for two new workloads in the same platform. The first stores hierarchical, schema-flexible product documents queried by attribute with single-digit millisecond latency at very large scale. The second must answer queries that walk many connected relationships, such as which accounts ultimately funded a given transaction through chains of intermediaries. The team wants a fully managed AWS service that fits each access pattern natively rather than forcing both onto one relational engine. Which two services correctly match these workloads? Select TWO.

  • AAmazon Redshift for the schema-flexible product documents, using its columnar storage to serve low-latency lookups
  • BAmazon DynamoDB for the schema-flexible product documents queried at scale with single-digit millisecond latency Correct
  • CAmazon RDS for PostgreSQL for the relationship traversal, relying on recursive multi-table joins across intermediaries
  • DAmazon Neptune for the queries that traverse many connected relationships between funding accounts and intermediaries Correct
  • EAmazon ElastiCache for the schema-flexible product documents to provide the primary durable document store
Match purpose-built AWS databases to access patterns: DynamoDB for low-latency flexible documents at scale and Neptune for connected-relationship traversal. The decisive requirements are access patterns. Single-digit millisecond document lookups at massive scale point to DynamoDB, while queries that walk chains of connected entities point to a graph engine, Neptune, whose traversal cost stays bounded where relational recursive joins balloon. Warehouse, relational, and cache services each solve a different problem and fail at least one stated requirement.

Why A is wrong: Redshift is a columnar data warehouse tuned for analytical scans, not single-item low-latency document lookups, so it is the wrong fit here.

Why B is correct: DynamoDB is a managed key-value and document store giving single-digit millisecond latency at very large scale, matching the flexible-document access pattern.

Why C is wrong: Recursive joins on a relational engine grow expensive as relationship depth increases, which is exactly the pattern a graph database is meant to replace.

Why D is correct: Neptune is a managed graph database built to traverse highly connected relationships efficiently, which suits the multi-hop funding-chain queries.

Why E is wrong: ElastiCache is an in-memory cache, not a durable primary document store, so using it as the system of record would risk data loss.

See more SAA-C03 practice questions, answers explained.

Exam traps in Design High-Performing Architectures

Answers that look right on this material and are not. Each one is a distractor from a different question in the SAA-C03 bank for this domain.

  • Store each measurement as an item in Amazon DynamoDB keyed by sensor and timestamp and run time-window aggregations by scanning the relevant key ranges at query time.

    Why it is wrong: DynamoDB can hold timestamped items but has no native time-series functions or tiering, so trend and window analytics require costly client-side aggregation it is not optimised for.

  • Amazon Kinesis Data Streams with a fleet of EC2 consumers running the Kinesis Client Library to read shards, convert each batch to Parquet, and write the objects into the destination S3 bucket.

    Why it is wrong: Kinesis Data Streams is a raw streaming store with no built-in S3 delivery, so the team would have to build and operate the consumers, buffering, and Parquet conversion themselves.

  • Migrate the JSON documents into Amazon DynamoDB tables and rewrite the data access layer to use the DynamoDB API and single-table key access patterns instead of MongoDB queries.

    Why it is wrong: DynamoDB is managed but uses a different API and data model, so adopting it forces rewriting the access layer, which breaks the explicit goal of keeping the MongoDB API.

Examworthy is not affiliated with or endorsed by Amazon Web Services. Original, blueprint-aligned practice material only.