A reports an inadequate or failed acceptance condition: The scan report blocks a reviewed and excepted informational issue without risk policy reasoning. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that a known vulnerable image is blocked while a compliant signed build passes the release gate. The underlying design requirement is scanning plus enforcement can prevent known-risk images from entering production; scan results alone do not block rollout.

B reports an inadequate or failed acceptance condition: A Dockerfile static scan succeeds, but the pushed image still has critical package vulnerabilities. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that a known vulnerable image is blocked while a compliant signed build passes the release gate. The underlying design requirement is scanning plus enforcement can prevent known-risk images from entering production; scan results alone do not block rollout.

C reports an inadequate or failed acceptance condition: A known vulnerable ECR image passes the pipeline and reaches production workloads. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that a known vulnerable image is blocked while a compliant signed build passes the release gate. The underlying design requirement is scanning plus enforcement can prevent known-risk images from entering production; scan results alone do not block rollout.

B would monitor only average database CPU and ignore top SQL and wait-event hotspots. This is not a defensible answer to the stated constraint (An application has slow database queries only under concurrent peak load but EC2 CPU is mostly idle): database wait metrics expose contention invisible in application host CPU graphs. The required design is use RDS Performance Insights or Database Insights and examine wait events and top SQL; acceptance depends on evidence that wait analysis isolates the lock or I/O bottleneck and query tuning reduces p95 latency.

C would resize the EC2 application hosts solely because SQL latency rises during peak concurrency. This is not a defensible answer to the stated constraint (An application has slow database queries only under concurrent peak load but EC2 CPU is mostly idle): database wait metrics expose contention invisible in application host CPU graphs. The required design is use RDS Performance Insights or Database Insights and examine wait events and top SQL; acceptance depends on evidence that wait analysis isolates the lock or I/O bottleneck and query tuning reduces p95 latency.

D would add arbitrary indexes to every table before inspecting lock, I/O, and query wait profiles. This is not a defensible answer to the stated constraint (An application has slow database queries only under concurrent peak load but EC2 CPU is mostly idle): database wait metrics expose contention invisible in application host CPU graphs. The required design is use RDS Performance Insights or Database Insights and examine wait events and top SQL; acceptance depends on evidence that wait analysis isolates the lock or I/O bottleneck and query tuning reduces p95 latency.

A reports an inadequate or failed acceptance condition: Average host CPU looks healthy even when critical SQL wait times spike under concurrency. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that wait analysis isolates the lock or I/O bottleneck and query tuning reduces p95 latency. The underlying design requirement is database wait metrics expose contention invisible in application host CPU graphs.

C reports an inadequate or failed acceptance condition: Database CPU stays low while slow SQL requests remain blocked on row locks. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that wait analysis isolates the lock or I/O bottleneck and query tuning reduces p95 latency. The underlying design requirement is database wait metrics expose contention invisible in application host CPU graphs.

D reports an inadequate or failed acceptance condition: Indexes are created, but the measured top-wait event and p95 latency stay unchanged. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that wait analysis isolates the lock or I/O bottleneck and query tuning reduces p95 latency. The underlying design requirement is database wait metrics expose contention invisible in application host CPU graphs.

A would raise DynamoDB table-wide throughput while retaining tenant IDs that hot-spot individual partitions. This is not a defensible answer to the stated constraint (A DynamoDB table is provisioned for high throughput but throttles a few very active tenant IDs): partition hotspots can exhaust per-partition limits even when table consumption is low. The required design is redesign the partition key using an effective high-cardinality or write-sharding scheme; acceptance depends on evidence that key-level throttles decline at the same workload level without unnecessary global capacity increases.

B would add a read-through cache expecting it to remove write throttling for skewed keys. This is not a defensible answer to the stated constraint (A DynamoDB table is provisioned for high throughput but throttles a few very active tenant IDs): partition hotspots can exhaust per-partition limits even when table consumption is low. The required design is redesign the partition key using an effective high-cardinality or write-sharding scheme; acceptance depends on evidence that key-level throttles decline at the same workload level without unnecessary global capacity increases.

D would replace tenant IDs with one common partition-key value for all tenant writes. This is not a defensible answer to the stated constraint (A DynamoDB table is provisioned for high throughput but throttles a few very active tenant IDs): partition hotspots can exhaust per-partition limits even when table consumption is low. The required design is redesign the partition key using an effective high-cardinality or write-sharding scheme; acceptance depends on evidence that key-level throttles decline at the same workload level without unnecessary global capacity increases.

A reports an inadequate or failed acceptance condition: Table-wide capacity increases but the hot tenant's partition still throttles. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that key-level throttles decline at the same workload level without unnecessary global capacity increases. The underlying design requirement is partition hotspots can exhaust per-partition limits even when table consumption is low.

B reports an inadequate or failed acceptance condition: DAX read cache metrics improve while DynamoDB write traffic remains skewed. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that key-level throttles decline at the same workload level without unnecessary global capacity increases. The underlying design requirement is partition hotspots can exhaust per-partition limits even when table consumption is low.

C reports an inadequate or failed acceptance condition: All tenants write to the same synthetic partition and throttling gets worse. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that key-level throttles decline at the same workload level without unnecessary global capacity increases. The underlying design requirement is partition hotspots can exhaust per-partition limits even when table consumption is low.

B would cache mutable rows forever and return stale business values after updates. This is not a defensible answer to the stated constraint (An interactive application performs the same SELECT statement thousands of times per minute): caching repetitive reads reduces backend work only if invalidation avoids stale business-critical values. The required design is add a cache-aside ElastiCache layer with suitable TTL and invalidation semantics; acceptance depends on evidence that database read traffic and API p95 latency decline while changed rows are refreshed correctly.

C would configure ElastiCache with a unique key per request, eliminating useful cache hits. This is not a defensible answer to the stated constraint (An interactive application performs the same SELECT statement thousands of times per minute): caching repetitive reads reduces backend work only if invalidation avoids stale business-critical values. The required design is add a cache-aside ElastiCache layer with suitable TTL and invalidation semantics; acceptance depends on evidence that database read traffic and API p95 latency decline while changed rows are refreshed correctly.

D would move all SQL queries to a different database without caching repetitive read-heavy requests. This is not a defensible answer to the stated constraint (An interactive application performs the same SELECT statement thousands of times per minute): caching repetitive reads reduces backend work only if invalidation avoids stale business-critical values. The required design is add a cache-aside ElastiCache layer with suitable TTL and invalidation semantics; acceptance depends on evidence that database read traffic and API p95 latency decline while changed rows are refreshed correctly.

A reports an inadequate or failed acceptance condition: After a product update, cache hits return stale prices with no invalidation. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that database read traffic and API p95 latency decline while changed rows are refreshed correctly. The underlying design requirement is caching repetitive reads reduces backend work only if invalidation avoids stale business-critical values.

C reports an inadequate or failed acceptance condition: ElastiCache is online but application SELECT calls never consult it. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that database read traffic and API p95 latency decline while changed rows are refreshed correctly. The underlying design requirement is caching repetitive reads reduces backend work only if invalidation avoids stale business-critical values.

D reports an inadequate or failed acceptance condition: Database read load remains high because each request gets a different cache key. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that database read traffic and API p95 latency decline while changed rows are refreshed correctly. The underlying design requirement is caching repetitive reads reduces backend work only if invalidation avoids stale business-critical values.

A would stop all workers at night even if an unpredictable upload backlog remains unfinished. This is not a defensible answer to the stated constraint (A media encoder's worker pool sits idle overnight but saturates during unpredictable uploads): queue-depth-driven scaling reflects actual work better than fixed host count or CPU alone. The required design is autoscale the workers against SQS backlog or per-task queue age rather than static EC2 schedules; acceptance depends on evidence that worker capacity tracks queue demand and queue latency remains within service objectives.

B would run the encoder fleet at peak capacity twenty-four hours a day. This is not a defensible answer to the stated constraint (A media encoder's worker pool sits idle overnight but saturates during unpredictable uploads): queue-depth-driven scaling reflects actual work better than fixed host count or CPU alone. The required design is autoscale the workers against SQS backlog or per-task queue age rather than static EC2 schedules; acceptance depends on evidence that worker capacity tracks queue demand and queue latency remains within service objectives.

D would scale worker count only by EC2 CPU even when upload queue age grows and CPUs are idle. This is not a defensible answer to the stated constraint (A media encoder's worker pool sits idle overnight but saturates during unpredictable uploads): queue-depth-driven scaling reflects actual work better than fixed host count or CPU alone. The required design is autoscale the workers against SQS backlog or per-task queue age rather than static EC2 schedules; acceptance depends on evidence that worker capacity tracks queue demand and queue latency remains within service objectives.

A reports an inadequate or failed acceptance condition: An unpredictable new upload remains pending until a rigid schedule restarts workers. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that worker capacity tracks queue demand and queue latency remains within service objectives. The underlying design requirement is queue-depth-driven scaling reflects actual work better than fixed host count or CPU alone.

B reports an inadequate or failed acceptance condition: Encoder workers remain allocated at peak count during the idle night. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that worker capacity tracks queue demand and queue latency remains within service objectives. The underlying design requirement is queue-depth-driven scaling reflects actual work better than fixed host count or CPU alone.

C reports an inadequate or failed acceptance condition: The upload queue grows while a CPU-based scaling alarm stays below its threshold. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that worker capacity tracks queue demand and queue latency remains within service objectives. The underlying design requirement is queue-depth-driven scaling reflects actual work better than fixed host count or CPU alone.

B would increase provisioned EBS volume throughput beyond the EC2 instance's bandwidth cap. This is not a defensible answer to the stated constraint (A large EBS-backed dataset produces sustained high-throughput reads but attached instance bandwidth plateaus): buying faster storage alone cannot exceed the instance's EBS throughput ceiling. The required design is check both the EBS volume throughput provision and the EC2 instance's EBS bandwidth cap before resizing; acceptance depends on evidence that i/O telemetry reaches the desired range after eliminating the measured attachment bottleneck.

C would upgrade only the EC2 instance family while retaining an undersized EBS throughput configuration. This is not a defensible answer to the stated constraint (A large EBS-backed dataset produces sustained high-throughput reads but attached instance bandwidth plateaus): buying faster storage alone cannot exceed the instance's EBS throughput ceiling. The required design is check both the EBS volume throughput provision and the EC2 instance's EBS bandwidth cap before resizing; acceptance depends on evidence that i/O telemetry reaches the desired range after eliminating the measured attachment bottleneck.

D would tune application thread counts while ignoring the measured I/O attachment bottleneck. This is not a defensible answer to the stated constraint (A large EBS-backed dataset produces sustained high-throughput reads but attached instance bandwidth plateaus): buying faster storage alone cannot exceed the instance's EBS throughput ceiling. The required design is check both the EBS volume throughput provision and the EC2 instance's EBS bandwidth cap before resizing; acceptance depends on evidence that i/O telemetry reaches the desired range after eliminating the measured attachment bottleneck.

A reports an inadequate or failed acceptance condition: The EBS volume reports higher provisioned throughput, but instance EBS attachment metrics remain capped. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that i/O telemetry reaches the desired range after eliminating the measured attachment bottleneck. The underlying design requirement is buying faster storage alone cannot exceed the instance's EBS throughput ceiling.

C reports an inadequate or failed acceptance condition: The instance has faster networking but its EBS volume provision is still the bottleneck. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that i/O telemetry reaches the desired range after eliminating the measured attachment bottleneck. The underlying design requirement is buying faster storage alone cannot exceed the instance's EBS throughput ceiling.

D reports an inadequate or failed acceptance condition: Application threads are tuned while observed storage read bandwidth stays flat. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that i/O telemetry reaches the desired range after eliminating the measured attachment bottleneck. The underlying design requirement is buying faster storage alone cannot exceed the instance's EBS throughput ceiling.