A reports an inadequate or failed acceptance condition: A replaced worker loses the only copy of intermediate data because no durable checkpoint exists. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that benchmarks show required scratch throughput and jobs recover from loss of ephemeral instance disks. The underlying design requirement is instance store optimizes transient local I/O but does not provide durable volume persistence.

C reports an inadequate or failed acceptance condition: Scratch NVMe throughput is high, but the job's results disappear on instance termination. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that benchmarks show required scratch throughput and jobs recover from loss of ephemeral instance disks. The underlying design requirement is instance store optimizes transient local I/O but does not provide durable volume persistence.

D reports an inadequate or failed acceptance condition: The attached EBS volume cannot sustain the measured sequential scratch I/O target. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that benchmarks show required scratch throughput and jobs recover from loss of ephemeral instance disks. The underlying design requirement is instance store optimizes transient local I/O but does not provide durable volume persistence.

A would use an NFS filesystem with inadequate throughput and one controller for highly parallel shared workloads. This is not a defensible answer to the stated constraint (Machine-learning preprocessing needs parallel shared POSIX files with high aggregate throughput): fSx for Lustre provides high-throughput parallel filesystems rather than object-store POSIX semantics. The required design is evaluate FSx for Lustre connected to S3 for the HPC-style shared filesystem workload; acceptance depends on evidence that workers read a common namespace at the target aggregate throughput and results export to S3.

B would give each worker an isolated local scratch directory with no shared POSIX namespace. This is not a defensible answer to the stated constraint (Machine-learning preprocessing needs parallel shared POSIX files with high aggregate throughput): fSx for Lustre provides high-throughput parallel filesystems rather than object-store POSIX semantics. The required design is evaluate FSx for Lustre connected to S3 for the HPC-style shared filesystem workload; acceptance depends on evidence that workers read a common namespace at the target aggregate throughput and results export to S3.

D would keep all shared input data in S3 alone while assuming direct S3 object APIs behave like POSIX files. This is not a defensible answer to the stated constraint (Machine-learning preprocessing needs parallel shared POSIX files with high aggregate throughput): fSx for Lustre provides high-throughput parallel filesystems rather than object-store POSIX semantics. The required design is evaluate FSx for Lustre connected to S3 for the HPC-style shared filesystem workload; acceptance depends on evidence that workers read a common namespace at the target aggregate throughput and results export to S3.

A reports an inadequate or failed acceptance condition: A conventional NFS gateway becomes saturated when all preprocessing workers read simultaneously. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that workers read a common namespace at the target aggregate throughput and results export to S3. The underlying design requirement is fSx for Lustre provides high-throughput parallel filesystems rather than object-store POSIX semantics.

B reports an inadequate or failed acceptance condition: Parallel jobs cannot access each other's local files as a shared POSIX namespace. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that workers read a common namespace at the target aggregate throughput and results export to S3. The underlying design requirement is fSx for Lustre provides high-throughput parallel filesystems rather than object-store POSIX semantics.

C reports an inadequate or failed acceptance condition: Workers receive S3 object keys but cannot perform required file-system metadata and rename operations. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that workers read a common namespace at the target aggregate throughput and results export to S3. The underlying design requirement is fSx for Lustre provides high-throughput parallel filesystems rather than object-store POSIX semantics.

B would set CloudFront TTL to zero for all static assets while expecting a high edge hit ratio. This is not a defensible answer to the stated constraint (An online product catalog has read spikes and a relatively static asset set across continents): cDN cache effectiveness depends on selecting safe, discriminating cache keys and expiry policies. The required design is use CloudFront caching with tuned cache keys, TTLs, and origin request policies; acceptance depends on evidence that edge hit ratio improves and origin traffic drops without serving outdated personalized responses.

C would bypass CloudFront and force every global catalog request to reach the distant origin directly. This is not a defensible answer to the stated constraint (An online product catalog has read spikes and a relatively static asset set across continents): cDN cache effectiveness depends on selecting safe, discriminating cache keys and expiry policies. The required design is use CloudFront caching with tuned cache keys, TTLs, and origin request policies; acceptance depends on evidence that edge hit ratio improves and origin traffic drops without serving outdated personalized responses.

D would cache personalized user responses under a shared CloudFront key that ignores identity or authorization. This is not a defensible answer to the stated constraint (An online product catalog has read spikes and a relatively static asset set across continents): cDN cache effectiveness depends on selecting safe, discriminating cache keys and expiry policies. The required design is use CloudFront caching with tuned cache keys, TTLs, and origin request policies; acceptance depends on evidence that edge hit ratio improves and origin traffic drops without serving outdated personalized responses.

A reports an inadequate or failed acceptance condition: CloudFront makes every static request an origin miss due to zero TTL. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that edge hit ratio improves and origin traffic drops without serving outdated personalized responses. The underlying design requirement is cDN cache effectiveness depends on selecting safe, discriminating cache keys and expiry policies.

C reports an inadequate or failed acceptance condition: Most global requests bypass edge caching and origin network RTT remains high. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that edge hit ratio improves and origin traffic drops without serving outdated personalized responses. The underlying design requirement is cDN cache effectiveness depends on selecting safe, discriminating cache keys and expiry policies.

D reports an inadequate or failed acceptance condition: One user receives another customer's personalized cached catalog response. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that edge hit ratio improves and origin traffic drops without serving outdated personalized responses. The underlying design requirement is cDN cache effectiveness depends on selecting safe, discriminating cache keys and expiry policies.

A would replace the partition key with a constant value so all writes share one logical key. This is not a defensible answer to the stated constraint (A high-write DynamoDB table hits throttles despite low aggregate table consumption): provisioning more total capacity alone cannot solve a single hot key's per-partition constraints. The required design is review CloudWatch partition behavior and redesign a skewed partition key or add write sharding; acceptance depends on evidence that hot-key throttling subsides and write consumption distributes across partitions.

B would raise table-wide capacity indefinitely while retaining a single skewed partition key. This is not a defensible answer to the stated constraint (A high-write DynamoDB table hits throttles despite low aggregate table consumption): provisioning more total capacity alone cannot solve a single hot key's per-partition constraints. The required design is review CloudWatch partition behavior and redesign a skewed partition key or add write sharding; acceptance depends on evidence that hot-key throttling subsides and write consumption distributes across partitions.

D would add a DAX read cache to solve throttling of writes to the hot partition key. This is not a defensible answer to the stated constraint (A high-write DynamoDB table hits throttles despite low aggregate table consumption): provisioning more total capacity alone cannot solve a single hot key's per-partition constraints. The required design is review CloudWatch partition behavior and redesign a skewed partition key or add write sharding; acceptance depends on evidence that hot-key throttling subsides and write consumption distributes across partitions.

A reports an inadequate or failed acceptance condition: Writes continue to hash into one partition because the new key has no cardinality. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that hot-key throttling subsides and write consumption distributes across partitions. The underlying design requirement is provisioning more total capacity alone cannot solve a single hot key's per-partition constraints.

B reports an inadequate or failed acceptance condition: Table utilization shows capacity headroom while a hot partition still returns ProvisionedThroughputExceededException. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that hot-key throttling subsides and write consumption distributes across partitions. The underlying design requirement is provisioning more total capacity alone cannot solve a single hot key's per-partition constraints.

C reports an inadequate or failed acceptance condition: DAX hit ratios improve for reads but the write-key throttle remains. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that hot-key throttling subsides and write consumption distributes across partitions. The underlying design requirement is provisioning more total capacity alone cannot solve a single hot key's per-partition constraints.

B would send all read-only queries to the existing RDS primary and increase the writer size without using readers. This is not a defensible answer to the stated constraint (A MySQL service needs to scale read-heavy requests without serializing them through its primary writer): read replicas increase read throughput; they do not automatically implement synchronous HA failover. The required design is add RDS read replicas and direct eventual-consistency-tolerant queries to reader endpoints; acceptance depends on evidence that read replica metrics show load while writer utilization and query latency fall.

C would use a read replica as the transaction writer despite its read-only replicated role. This is not a defensible answer to the stated constraint (A MySQL service needs to scale read-heavy requests without serializing them through its primary writer): read replicas increase read throughput; they do not automatically implement synchronous HA failover. The required design is add RDS read replicas and direct eventual-consistency-tolerant queries to reader endpoints; acceptance depends on evidence that read replica metrics show load while writer utilization and query latency fall.

D would route consistency-critical immediate read-after-write requests to a lagging replica without safeguards. This is not a defensible answer to the stated constraint (A MySQL service needs to scale read-heavy requests without serializing them through its primary writer): read replicas increase read throughput; they do not automatically implement synchronous HA failover. The required design is add RDS read replicas and direct eventual-consistency-tolerant queries to reader endpoints; acceptance depends on evidence that read replica metrics show load while writer utilization and query latency fall.

A reports an inadequate or failed acceptance condition: The primary writer still handles all read traffic and its CPU remains saturated. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that read replica metrics show load while writer utilization and query latency fall. The underlying design requirement is read replicas increase read throughput; they do not automatically implement synchronous HA failover.

C reports an inadequate or failed acceptance condition: A read replica rejects a required transaction write statement. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that read replica metrics show load while writer utilization and query latency fall. The underlying design requirement is read replicas increase read throughput; they do not automatically implement synchronous HA failover.

D reports an inadequate or failed acceptance condition: Read-after-write transactions return stale results from a lagging reader with no routing exception. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that read replica metrics show load while writer utilization and query latency fall. The underlying design requirement is read replicas increase read throughput; they do not automatically implement synchronous HA failover.

A would share a single mutex lock across every distributed worker, serializing otherwise parallel units. This is not a defensible answer to the stated constraint (A batch job has CPU-bound processing and negligible shared filesystem dependencies but needs rapid scale-out): queue-driven parallelism works when work units are independent and consumers safely handle retries. The required design is distribute units using SQS and a scalable compute fleet sized for the job profile; acceptance depends on evidence that worker count increases with backlog and completion time falls without shared-lock contention.

B would launch workers without a durable work queue or task ownership so jobs are lost or duplicated. This is not a defensible answer to the stated constraint (A batch job has CPU-bound processing and negligible shared filesystem dependencies but needs rapid scale-out): queue-driven parallelism works when work units are independent and consumers safely handle retries. The required design is distribute units using SQS and a scalable compute fleet sized for the job profile; acceptance depends on evidence that worker count increases with backlog and completion time falls without shared-lock contention.

D would process the entire batch on one larger EC2 instance instead of distributing independent tasks. This is not a defensible answer to the stated constraint (A batch job has CPU-bound processing and negligible shared filesystem dependencies but needs rapid scale-out): queue-driven parallelism works when work units are independent and consumers safely handle retries. The required design is distribute units using SQS and a scalable compute fleet sized for the job profile; acceptance depends on evidence that worker count increases with backlog and completion time falls without shared-lock contention.

A reports an inadequate or failed acceptance condition: Distributed workers all block on a shared lock, so completion time does not improve. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that worker count increases with backlog and completion time falls without shared-lock contention. The underlying design requirement is queue-driven parallelism works when work units are independent and consumers safely handle retries.

B reports an inadequate or failed acceptance condition: Multiple workers acknowledge the same task or lose tasks because queue ownership is not durable. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that worker count increases with backlog and completion time falls without shared-lock contention. The underlying design requirement is queue-driven parallelism works when work units are independent and consumers safely handle retries.

C reports an inadequate or failed acceptance condition: One large EC2 instance remains the bottleneck for every independent batch work unit. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that worker count increases with backlog and completion time falls without shared-lock contention. The underlying design requirement is queue-driven parallelism works when work units are independent and consumers safely handle retries.