A reports an inadequate or failed acceptance condition: Route 53 latency routing continues returning a failed Region that has no health check. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that probes from distinct geographies resolve to healthy intended Regions and failed Regions stop receiving traffic. The underlying design requirement is latency-based DNS needs health awareness; region-local resources must exist before routing is effective.

B reports an inadequate or failed acceptance condition: Clients near an unhealthy Region keep resolving to it despite available healthy Regions. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that probes from distinct geographies resolve to healthy intended Regions and failed Regions stop receiving traffic. The underlying design requirement is latency-based DNS needs health awareness; region-local resources must exist before routing is effective.

C reports an inadequate or failed acceptance condition: DNS returns a regional address with no deployed capacity to serve the clients. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that probes from distinct geographies resolve to healthy intended Regions and failed Regions stop receiving traffic. The underlying design requirement is latency-based DNS needs health awareness; region-local resources must exist before routing is effective.

B would use in-memory duplicate checks only, losing the dedupe set when workers restart. This is not a defensible answer to the stated constraint (An S3 event can arrive more than once and downstream inventory processing must not duplicate ledger entries): s3 event notifications are at-least-once and unordered; deduplication belongs in consumer logic. The required design is use event-idempotency keys and conditional writes in a durable state store; acceptance depends on evidence that replayed S3 notifications yield one durable logical update despite multiple deliveries.

C would apply unconditional database inserts for each replayed event instead of a conditional/idempotent update. This is not a defensible answer to the stated constraint (An S3 event can arrive more than once and downstream inventory processing must not duplicate ledger entries): s3 event notifications are at-least-once and unordered; deduplication belongs in consumer logic. The required design is use event-idempotency keys and conditional writes in a durable state store; acceptance depends on evidence that replayed S3 notifications yield one durable logical update despite multiple deliveries.

D would treat every S3 event notification as exactly-once delivery without deduplication. This is not a defensible answer to the stated constraint (An S3 event can arrive more than once and downstream inventory processing must not duplicate ledger entries): s3 event notifications are at-least-once and unordered; deduplication belongs in consumer logic. The required design is use event-idempotency keys and conditional writes in a durable state store; acceptance depends on evidence that replayed S3 notifications yield one durable logical update despite multiple deliveries.

A reports an inadequate or failed acceptance condition: Deduplication works until the worker restarts, then earlier event IDs are accepted again. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that replayed S3 notifications yield one durable logical update despite multiple deliveries. The underlying design requirement is s3 event notifications are at-least-once and unordered; deduplication belongs in consumer logic.

C reports an inadequate or failed acceptance condition: A conditional-write collision returns a second successful ledger update instead of one logical change. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that replayed S3 notifications yield one durable logical update despite multiple deliveries. The underlying design requirement is s3 event notifications are at-least-once and unordered; deduplication belongs in consumer logic.

D reports an inadequate or failed acceptance condition: Replayed object notifications insert multiple inventory transactions for the same S3 object. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that replayed S3 notifications yield one durable logical update despite multiple deliveries. The underlying design requirement is s3 event notifications are at-least-once and unordered; deduplication belongs in consumer logic.

A would replicate static HTML assets but do not externalize the server-side user session state. This is not a defensible answer to the stated constraint (A regional backend has an active-active requirement but sessions are stored only on individual web nodes): stateless horizontal scaling needs shared session state; sticky sessions alone do not survive a node loss. The required design is externalize session state into a replicated shared store and make application nodes disposable; acceptance depends on evidence that a client switches application nodes without losing an authenticated session.

B would keep authentication sessions in a single web node's local RAM and enable cross-node routing. This is not a defensible answer to the stated constraint (A regional backend has an active-active requirement but sessions are stored only on individual web nodes): stateless horizontal scaling needs shared session state; sticky sessions alone do not survive a node loss. The required design is externalize session state into a replicated shared store and make application nodes disposable; acceptance depends on evidence that a client switches application nodes without losing an authenticated session.

D would use sticky sessions alone and assume they survive a failed node or Region. This is not a defensible answer to the stated constraint (A regional backend has an active-active requirement but sessions are stored only on individual web nodes): stateless horizontal scaling needs shared session state; sticky sessions alone do not survive a node loss. The required design is externalize session state into a replicated shared store and make application nodes disposable; acceptance depends on evidence that a client switches application nodes without losing an authenticated session.

A reports an inadequate or failed acceptance condition: Static assets load correctly while authenticated state disappears after an instance is replaced. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that a client switches application nodes without losing an authenticated session. The underlying design requirement is stateless horizontal scaling needs shared session state; sticky sessions alone do not survive a node loss.

B reports an inadequate or failed acceptance condition: A sticky session works until the assigned web node fails and loses user login state. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that a client switches application nodes without losing an authenticated session. The underlying design requirement is stateless horizontal scaling needs shared session state; sticky sessions alone do not survive a node loss.

C reports an inadequate or failed acceptance condition: A client sent to a different active Region is forced to authenticate again because sessions remain local. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that a client switches application nodes without losing an authenticated session. The underlying design requirement is stateless horizontal scaling needs shared session state; sticky sessions alone do not survive a node loss.

B would add indexes to the transactional PostgreSQL instance and keep all terabyte analytical scans on the OLTP primary. This is not a defensible answer to the stated constraint (An ad-analytics workload repeatedly scans terabytes in a transactional PostgreSQL database and slows OLTP): separating OLAP workloads from OLTP databases protects transactional access paths. The required design is move analytical queries to a columnar warehouse such as Redshift with appropriate ingestion; acceptance depends on evidence that oLTP p99 latency recovers while long scans execute on the analytical platform.

C would send the analytical SQL queries to an RDS read replica but ignore massive columnar query cost and concurrency. This is not a defensible answer to the stated constraint (An ad-analytics workload repeatedly scans terabytes in a transactional PostgreSQL database and slows OLTP): separating OLAP workloads from OLTP databases protects transactional access paths. The required design is move analytical queries to a columnar warehouse such as Redshift with appropriate ingestion; acceptance depends on evidence that oLTP p99 latency recovers while long scans execute on the analytical platform.

D would move transaction writes into Redshift instead of separating analytics from the OLTP system. This is not a defensible answer to the stated constraint (An ad-analytics workload repeatedly scans terabytes in a transactional PostgreSQL database and slows OLTP): separating OLAP workloads from OLTP databases protects transactional access paths. The required design is move analytical queries to a columnar warehouse such as Redshift with appropriate ingestion; acceptance depends on evidence that oLTP p99 latency recovers while long scans execute on the analytical platform.

A reports an inadequate or failed acceptance condition: The transaction writer's SQL scan time increases despite read replication and indexing. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that oLTP p99 latency recovers while long scans execute on the analytical platform. The underlying design requirement is separating OLAP workloads from OLTP databases protects transactional access paths.

C reports an inadequate or failed acceptance condition: A reporting job finishes on a replica, but its columnar workload still consumes excessive relational capacity. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that oLTP p99 latency recovers while long scans execute on the analytical platform. The underlying design requirement is separating OLAP workloads from OLTP databases protects transactional access paths.

D reports an inadequate or failed acceptance condition: Analytics were moved away but OLTP transaction writes fail after changing their target to a read-only store. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that oLTP p99 latency recovers while long scans execute on the analytical platform. The underlying design requirement is separating OLAP workloads from OLTP databases protects transactional access paths.

A would put every request behind one RDS writer, ignoring the required distributed key-value access scale. This is not a defensible answer to the stated constraint (An IoT service has millions of uniform key-value lookups requiring predictable single-digit millisecond access at scale): dynamoDB partitions by key; poor cardinality can create bottlenecks regardless of table-level capacity. The required design is use DynamoDB with carefully chosen high-cardinality partition keys and capacity mode; acceptance depends on evidence that load tests show acceptable p95 latency without hot-partition throttling.

B would configure low provisioned throughput with no autoscaling or on-demand capacity for high traffic. This is not a defensible answer to the stated constraint (An IoT service has millions of uniform key-value lookups requiring predictable single-digit millisecond access at scale): dynamoDB partitions by key; poor cardinality can create bottlenecks regardless of table-level capacity. The required design is use DynamoDB with carefully chosen high-cardinality partition keys and capacity mode; acceptance depends on evidence that load tests show acceptable p95 latency without hot-partition throttling.

D would use a single low-cardinality partition key that sends most DynamoDB traffic to one partition. This is not a defensible answer to the stated constraint (An IoT service has millions of uniform key-value lookups requiring predictable single-digit millisecond access at scale): dynamoDB partitions by key; poor cardinality can create bottlenecks regardless of table-level capacity. The required design is use DynamoDB with carefully chosen high-cardinality partition keys and capacity mode; acceptance depends on evidence that load tests show acceptable p95 latency without hot-partition throttling.

A reports an inadequate or failed acceptance condition: A single RDS instance handles the load with degraded multi-millisecond latency. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that load tests show acceptable p95 latency without hot-partition throttling. The underlying design requirement is dynamoDB partitions by key; poor cardinality can create bottlenecks regardless of table-level capacity.

B reports an inadequate or failed acceptance condition: Partition write-throttling alarms rise because capacity is below the required traffic profile. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that load tests show acceptable p95 latency without hot-partition throttling. The underlying design requirement is dynamoDB partitions by key; poor cardinality can create bottlenecks regardless of table-level capacity.

C reports an inadequate or failed acceptance condition: High write rates focus on one hot DynamoDB partition despite sufficient overall provisioned capacity. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that load tests show acceptable p95 latency without hot-partition throttling. The underlying design requirement is dynamoDB partitions by key; poor cardinality can create bottlenecks regardless of table-level capacity.

B would assume instance store is durable through EC2 instance termination and fail to persist checkpoints. This is not a defensible answer to the stated constraint (A compute-heavy batch app uses large sequential scratch files and must maximize local I/O throughput): instance store optimizes transient local I/O but does not provide durable volume persistence. The required design is choose suitable EC2 instance-store NVMe storage with checkpointing to durable storage; acceptance depends on evidence that benchmarks show required scratch throughput and jobs recover from loss of ephemeral instance disks.

C would store uncheckpointed critical results exclusively on ephemeral instance-store NVMe disks. This is not a defensible answer to the stated constraint (A compute-heavy batch app uses large sequential scratch files and must maximize local I/O throughput): instance store optimizes transient local I/O but does not provide durable volume persistence. The required design is choose suitable EC2 instance-store NVMe storage with checkpointing to durable storage; acceptance depends on evidence that benchmarks show required scratch throughput and jobs recover from loss of ephemeral instance disks.

D would switch to a small network EBS volume with insufficient tested throughput for sequential scratch workloads. This is not a defensible answer to the stated constraint (A compute-heavy batch app uses large sequential scratch files and must maximize local I/O throughput): instance store optimizes transient local I/O but does not provide durable volume persistence. The required design is choose suitable EC2 instance-store NVMe storage with checkpointing to durable storage; acceptance depends on evidence that benchmarks show required scratch throughput and jobs recover from loss of ephemeral instance disks.

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.