SAA-C03 Design High-Performing Architectures Practice Question
A customer-facing application has a relational data model and needs frequent complex queries (joins and aggregations), but it also experiences a significant read-heavy workload. Which design choice best improves read performance while keeping relational features?
⚠ Common exam trap
Candidates often assume NoSQL (DynamoDB) is always the best choice for read-heavy workloads, overlooking that complex relational queries and joins are not supported, making read replicas on RDS/Aurora the correct relational scaling solution.
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Add read replicas to an RDS or Aurora cluster and keep the primary for writes.
Adding read replicas to an RDS or Aurora cluster offloads read traffic from the primary instance, improving read performance for complex queries (joins and aggregations) while preserving the full relational data model and SQL capabilities. Aurora’s distributed storage layer also allows replicas to serve reads with minimal replication lag, making this the optimal choice for read-heavy workloads that require relational features.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
Use DynamoDB with a single partition key and avoid indexes to keep writes simple.
Why it's wrong here
DynamoDB is great for key-value and document patterns, but complex joins/aggregations require redesign. Avoiding indexes would likely hurt query flexibility and performance. This option conflicts with the relational query requirement.
When this WOULD be correct
For a serverless application with a simple key-value access pattern, high write throughput, and no need for complex queries or joins, DynamoDB with a single partition key and no indexes would be optimal to maximize write performance and minimize costs.
- ✓
Add read replicas to an RDS or Aurora cluster and keep the primary for writes.
Why this is correct
Read replicas offload read operations from the primary database instance, improving read throughput and reducing contention with writes. RDS/Aurora preserve relational capabilities like joins and SQL queries. This is a common and practical way to scale performance for read-heavy workloads without completely changing the data model.
- ✗
Store the data in S3 and query it directly from the application without a database.
Why it's wrong here
S3 is object storage and is not designed for low-latency relational query workloads. Querying directly would be slow and operationally complex. Complex joins/aggregations would not be straightforward.
When this WOULD be correct
In a scenario where the application stores static or semi-static data (e.g., log files, images, or large datasets) that is accessed infrequently and does not require complex queries, and the goal is to reduce costs by offloading storage from a database, using S3 with direct querying (e.g., via Athena) could be correct.
- ✗
Switch the database to DynamoDB but keep using the same relational SQL queries and joins.
Why it's wrong here
DynamoDB does not support SQL joins in the same way relational databases do. Moving to DynamoDB generally requires a query-pattern redesign with keys and indexes. Keeping the same query approach would not work as intended.
When this WOULD be correct
This option would be correct if the question described a non-relational workload with simple key-value access patterns, high scalability needs, and no requirement for complex joins or aggregations. For example: 'A social media app needs to store user profiles with low-latency reads and writes, and does not require joins.'
Option-by-option analysis
Why each answer is right or wrong
Understanding why wrong answers are wrong — and when they would be correct — is what separates a 750 score from a 900. The SAA-C03 exam frequently reuses these exact scenarios with slightly different constraints.
✓Add read replicas to an RDS or Aurora cluster and keep the primary for writes.Correct answer▾
Why this is correct
Read replicas offload read operations from the primary database instance, improving read throughput and reducing contention with writes. RDS/Aurora preserve relational capabilities like joins and SQL queries. This is a common and practical way to scale performance for read-heavy workloads without completely changing the data model.
✗Use DynamoDB with a single partition key and avoid indexes to keep writes simple.Wrong answer — click to see why▾
Why this is wrong here
DynamoDB is a NoSQL database that does not support complex joins and aggregations natively, and using a single partition key without indexes would severely limit query flexibility and performance for the required relational queries.
★ When this WOULD be the correct answer
For a serverless application with a simple key-value access pattern, high write throughput, and no need for complex queries or joins, DynamoDB with a single partition key and no indexes would be optimal to maximize write performance and minimize costs.
Why candidates choose this
Candidates may mistakenly believe that DynamoDB can handle relational queries efficiently or that simplifying the data model always improves performance, overlooking the specific need for complex joins and aggregations.
✗Store the data in S3 and query it directly from the application without a database.Wrong answer — click to see why▾
Why this is wrong here
S3 is an object store, not a relational database; it cannot support complex joins, aggregations, or relational queries, making it unsuitable for the application's relational data model and frequent complex queries.
★ When this WOULD be the correct answer
In a scenario where the application stores static or semi-static data (e.g., log files, images, or large datasets) that is accessed infrequently and does not require complex queries, and the goal is to reduce costs by offloading storage from a database, using S3 with direct querying (e.g., via Athena) could be correct.
Why candidates choose this
Candidates may think S3 is a cheap, scalable storage option that can handle any data, overlooking that it lacks relational query capabilities and is not designed for transactional or complex query workloads.
✗Switch the database to DynamoDB but keep using the same relational SQL queries and joins.Wrong answer — click to see why▾
Why this is wrong here
DynamoDB is a NoSQL database that does not support relational SQL queries or joins. Attempting to use relational queries on DynamoDB would fail or require significant application-level workarounds, defeating the purpose of keeping relational features.
★ When this WOULD be the correct answer
This option would be correct if the question described a non-relational workload with simple key-value access patterns, high scalability needs, and no requirement for complex joins or aggregations. For example: 'A social media app needs to store user profiles with low-latency reads and writes, and does not require joins.'
Why candidates choose this
Candidates may think DynamoDB is a universal performance solution for any read-heavy workload, overlooking that it sacrifices relational capabilities. They might also assume that SQL-like queries are possible with DynamoDB's PartiQL, but that does not support complex joins.
Analysis generated from the official SAA-C03blueprint and verified against question context. The “when correct” sections are what AI assistants cite when candidates ask “what’s the difference between these options?”
Go deeper
Related to this question
About these practice questions
Courseiva writes every SAA-C03 question from scratch — 302 in total, each with an explanation and a wrong-answer breakdown. None are copied from real exams or dumps. Learn why practice questions differ from exam dumps →
JA
Written by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
This SAA-C03 practice question is part of Courseiva's free Amazon Web Services certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the SAA-C03 exam.