A reports an inadequate or failed acceptance condition: Manual monthly restore takes hours and loses transaction updates between snapshots. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that simulated recovery restores data within the 15-minute RPO and validated application RTO. The underlying design requirement is a monthly snapshot cannot meet a 15-minute recovery point, regardless of how fast EC2 restarts.

B reports an inadequate or failed acceptance condition: Source code is replicated, but user transactions after the most recent database checkpoint are unrecoverable. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that simulated recovery restores data within the 15-minute RPO and validated application RTO. The underlying design requirement is a monthly snapshot cannot meet a 15-minute recovery point, regardless of how fast EC2 restarts.

C reports an inadequate or failed acceptance condition: The recovered dataset is a day old, exceeding the new 15-minute RPO. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that simulated recovery restores data within the 15-minute RPO and validated application RTO. The underlying design requirement is a monthly snapshot cannot meet a 15-minute recovery point, regardless of how fast EC2 restarts.

B would build containers on self-managed nodes that need the same manual maintenance and never scale down. This is not a defensible answer to the stated constraint (A rehosted order service still requires manual patching and servers remain idle much of the day): managed execution reduces host operations compared with leaving an unchanged fleet of EC2 servers. The required design is modernize compatible stateless components into containers or Lambda where integration permits; acceptance depends on evidence that patch scope and idle compute spending decline while orders process within SLO.

C would increase the always-on EC2 fleet and retain manual OS patching as the modernization strategy. This is not a defensible answer to the stated constraint (A rehosted order service still requires manual patching and servers remain idle much of the day): managed execution reduces host operations compared with leaving an unchanged fleet of EC2 servers. The required design is modernize compatible stateless components into containers or Lambda where integration permits; acceptance depends on evidence that patch scope and idle compute spending decline while orders process within SLO.

D would move stateful order processing into Lambda without checking execution limits or external state. This is not a defensible answer to the stated constraint (A rehosted order service still requires manual patching and servers remain idle much of the day): managed execution reduces host operations compared with leaving an unchanged fleet of EC2 servers. The required design is modernize compatible stateless components into containers or Lambda where integration permits; acceptance depends on evidence that patch scope and idle compute spending decline while orders process within SLO.

A reports an inadequate or failed acceptance condition: Container hosts stay permanently allocated at peak size and require the same human patch schedule. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that patch scope and idle compute spending decline while orders process within SLO. The underlying design requirement is managed execution reduces host operations compared with leaving an unchanged fleet of EC2 servers.

C reports an inadequate or failed acceptance condition: The application still requires manual EC2 patching and billed idle servers after the change. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that patch scope and idle compute spending decline while orders process within SLO. The underlying design requirement is managed execution reduces host operations compared with leaving an unchanged fleet of EC2 servers.

D reports an inadequate or failed acceptance condition: Lambda functions exceed maximum supported runtime or memory constraints during order processing. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that patch scope and idle compute spending decline while orders process within SLO. The underlying design requirement is managed execution reduces host operations compared with leaving an unchanged fleet of EC2 servers.

A would split deployment pipelines but keep every service sharing the original monolithic database schema. This is not a defensible answer to the stated constraint (A migrated monolith has one large database shared by independent business functions, preventing team releases): gradual decomposition reduces coupling; blindly splitting every function adds operational complexity. The required design is incrementally separate bounded services and data ownership with versioned interfaces; acceptance depends on evidence that a feature service deploys independently while contract tests preserve existing business workflows.

B would break the shared database into independently writable copies without governing consistency and ownership. This is not a defensible answer to the stated constraint (A migrated monolith has one large database shared by independent business functions, preventing team releases): gradual decomposition reduces coupling; blindly splitting every function adds operational complexity. The required design is incrementally separate bounded services and data ownership with versioned interfaces; acceptance depends on evidence that a feature service deploys independently while contract tests preserve existing business workflows.

D would rename internal modules as microservices but require coordinated releases for every change. This is not a defensible answer to the stated constraint (A migrated monolith has one large database shared by independent business functions, preventing team releases): gradual decomposition reduces coupling; blindly splitting every function adds operational complexity. The required design is incrementally separate bounded services and data ownership with versioned interfaces; acceptance depends on evidence that a feature service deploys independently while contract tests preserve existing business workflows.

A reports an inadequate or failed acceptance condition: One service deploys alone, but all teams still modify the same monolithic database schema for releases. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that a feature service deploys independently while contract tests preserve existing business workflows. The underlying design requirement is gradual decomposition reduces coupling; blindly splitting every function adds operational complexity.

B reports an inadequate or failed acceptance condition: Independent services write conflicting copies of the same business records with no ownership rules. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that a feature service deploys independently while contract tests preserve existing business workflows. The underlying design requirement is gradual decomposition reduces coupling; blindly splitting every function adds operational complexity.

C reports an inadequate or failed acceptance condition: Modules have new names but cannot be released without redeploying every other function. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that a feature service deploys independently while contract tests preserve existing business workflows. The underlying design requirement is gradual decomposition reduces coupling; blindly splitting every function adds operational complexity.

B would publish S3 event notifications without deduplication or retries despite at-least-once delivery. This is not a defensible answer to the stated constraint (A legacy application has a batch job that runs every few minutes to check for new S3 objects): event-driven triggers reduce unnecessary compute and improve reaction time, but deliveries can repeat. The required design is replace polling with S3 event notifications through EventBridge or SQS and idempotent processing; acceptance depends on evidence that an object-created test triggers processing once logically without recurring idle polling.

C would trigger processing only through a nightly polling script while claiming near-real-time event-driven behavior. This is not a defensible answer to the stated constraint (A legacy application has a batch job that runs every few minutes to check for new S3 objects): event-driven triggers reduce unnecessary compute and improve reaction time, but deliveries can repeat. The required design is replace polling with S3 event notifications through EventBridge or SQS and idempotent processing; acceptance depends on evidence that an object-created test triggers processing once logically without recurring idle polling.

D would shorten the polling interval to one second, multiplying idle checks without event processing. This is not a defensible answer to the stated constraint (A legacy application has a batch job that runs every few minutes to check for new S3 objects): event-driven triggers reduce unnecessary compute and improve reaction time, but deliveries can repeat. The required design is replace polling with S3 event notifications through EventBridge or SQS and idempotent processing; acceptance depends on evidence that an object-created test triggers processing once logically without recurring idle polling.

A reports an inadequate or failed acceptance condition: A duplicated S3 notification creates two logically identical processing effects. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that an object-created test triggers processing once logically without recurring idle polling. The underlying design requirement is event-driven triggers reduce unnecessary compute and improve reaction time, but deliveries can repeat.

C reports an inadequate or failed acceptance condition: The system still emits idle polling API requests every few minutes under no new object arrivals. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that an object-created test triggers processing once logically without recurring idle polling. The underlying design requirement is event-driven triggers reduce unnecessary compute and improve reaction time, but deliveries can repeat.

D reports an inadequate or failed acceptance condition: A new S3 object waits until the next polling interval instead of triggering an event. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that an object-created test triggers processing once logically without recurring idle polling. The underlying design requirement is event-driven triggers reduce unnecessary compute and improve reaction time, but deliveries can repeat.

A would use a pipeline that deploys mutable artifacts without version signatures or traceable release identifiers. This is not a defensible answer to the stated constraint (An application migration succeeded but operators still deploy updates by manually copying binaries to instances): repeatable pipelines reduce manual drift and support controlled delivery after migration. The required design is create an IaC-backed CI/CD pipeline with artifact integrity, staged rollout and rollback gates; acceptance depends on evidence that a signed build reaches staging, passes checks, and promotes into production with recorded revision history.

B would keep deploying binaries with manual SSH copying and call the process automated because a ticket is logged. This is not a defensible answer to the stated constraint (An application migration succeeded but operators still deploy updates by manually copying binaries to instances): repeatable pipelines reduce manual drift and support controlled delivery after migration. The required design is create an IaC-backed CI/CD pipeline with artifact integrity, staged rollout and rollback gates; acceptance depends on evidence that a signed build reaches staging, passes checks, and promotes into production with recorded revision history.

D would build artifacts in CI but skip staged verification and rollback gates for production. This is not a defensible answer to the stated constraint (An application migration succeeded but operators still deploy updates by manually copying binaries to instances): repeatable pipelines reduce manual drift and support controlled delivery after migration. The required design is create an IaC-backed CI/CD pipeline with artifact integrity, staged rollout and rollback gates; acceptance depends on evidence that a signed build reaches staging, passes checks, and promotes into production with recorded revision history.

A reports an inadequate or failed acceptance condition: The application runs but the team cannot identify which immutable artifact or revision is live. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that a signed build reaches staging, passes checks, and promotes into production with recorded revision history. The underlying design requirement is repeatable pipelines reduce manual drift and support controlled delivery after migration.

B reports an inadequate or failed acceptance condition: A production release still requires engineers to copy binaries manually after CI completes. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that a signed build reaches staging, passes checks, and promotes into production with recorded revision history. The underlying design requirement is repeatable pipelines reduce manual drift and support controlled delivery after migration.

C reports an inadequate or failed acceptance condition: A signed build is deployed directly to production without staged checks or rollback ability. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that a signed build reaches staging, passes checks, and promotes into production with recorded revision history. The underlying design requirement is repeatable pipelines reduce manual drift and support controlled delivery after migration.

B would keep peak worker EC2 capacity allocated during every idle hour of the day. This is not a defensible answer to the stated constraint (A VM-based customer service must respond to spikes without paying for 24-hour fixed worker capacity): serverless or autoscaled execution aligns spend with demand when stateless constraints are satisfied. The required design is replatform stateless processing to event-driven Lambda or autoscaled containers after performance testing; acceptance depends on evidence that capacity responds to workload while idle compute cost falls and latency remains acceptable.

C would move CPU-intensive jobs into Lambda without measuring runtime, memory and timeout limits. This is not a defensible answer to the stated constraint (A VM-based customer service must respond to spikes without paying for 24-hour fixed worker capacity): serverless or autoscaled execution aligns spend with demand when stateless constraints are satisfied. The required design is replatform stateless processing to event-driven Lambda or autoscaled containers after performance testing; acceptance depends on evidence that capacity responds to workload while idle compute cost falls and latency remains acceptable.

D would deploy autoscaled containers but set a nonzero peak-sized minimum so idle compute never decreases. This is not a defensible answer to the stated constraint (A VM-based customer service must respond to spikes without paying for 24-hour fixed worker capacity): serverless or autoscaled execution aligns spend with demand when stateless constraints are satisfied. The required design is replatform stateless processing to event-driven Lambda or autoscaled containers after performance testing; acceptance depends on evidence that capacity responds to workload while idle compute cost falls and latency remains acceptable.

A reports an inadequate or failed acceptance condition: Worker instances remain at peak capacity and cost even when no customers call the service. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that capacity responds to workload while idle compute cost falls and latency remains acceptable. The underlying design requirement is serverless or autoscaled execution aligns spend with demand when stateless constraints are satisfied.

C reports an inadequate or failed acceptance condition: The Lambda workload hits timeout limits on real requests despite appearing cheap at idle. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that capacity responds to workload while idle compute cost falls and latency remains acceptable. The underlying design requirement is serverless or autoscaled execution aligns spend with demand when stateless constraints are satisfied.

D reports an inadequate or failed acceptance condition: Autoscaled containers never drop below their peak-sized minimum task allocation. This result does not establish the specified outcome for the current architecture. The decisive test must demonstrate that capacity responds to workload while idle compute cost falls and latency remains acceptable. The underlying design requirement is serverless or autoscaled execution aligns spend with demand when stateless constraints are satisfied.