Database And Compute Performance Scaling — AWS Solutions Architect Pro (SAP-C02)
Read Replicas Spread Load; ElastiCache Cuts Repeated Reads
Read replicas reduce pressure on the primary by routing reads to synchronized copies, but those reads still execute against the database engine. A product detail page querying the same top-1,000 records thousands of times per second gets diminishing returns from additional replicas once the bottleneck is query repetition rather than engine capacity. ElastiCache with a write-through strategy serves any cached record from memory, bypassing the database entirely for high-frequency reads against a hot working set. The distinction: replicas help when the query set is large and unpredictable; in-memory caching helps when a small set is queried at very high frequency. 'Same records accessed thousands of times per second' is the signal for the caching path.
What This Pattern Tests
The exam describes a performance bottleneck and tests the right scaling technique. Read replicas (RDS, Aurora up to 15 replicas) handle read-heavy workloads by distributing SELECT queries. ElastiCache Redis/Memcached handles repeated queries by serving results from memory (microsecond reads vs. millisecond database reads). DynamoDB DAX provides microsecond reads for DynamoDB-specific workloads. Write scaling requires partitioning/sharding (DynamoDB handles this automatically with partition keys). The trap is adding read replicas for a write-bottleneck (replicas only handle reads) or caching for data that changes every second (cache invalidation becomes the bottleneck).
Decision Axis
Bottleneck type determines technique: read-heavy = replicas, repeated queries = cache, write-heavy = partitioning, compute-heavy = scale out.
Associated Traps
More Top Traps on This Exam
Decision Rules
Whether to scale read capacity horizontally by adding Aurora read replicas behind the native reader endpoint combined with a managed ElastiCache tier, versus scaling the Aurora writer instance vertically or deploying self-managed caching and connection-pooling infrastructure that shifts operational and code-change burden onto the application layer.
Domain Coverage
Difficulty Breakdown