Skip to content
Tech Interview Prep
Technical interview guide

Chaos Engineering

Deliberately injecting failure into a system to verify it actually survives what you assume it survives.

Read
28 min
Practice MCQs
25
Interview Q&A
25
Edition
v5
Editorial status
Reviewed

Scope: Chaos Engineering principles and AWS, Azure, Google Cloud, Kubernetes, LitmusChaos, Chaos Mesh, and OpenTelemetry guidance current 2026-08-31.

Curated: · Written: · Reviewed:

25 questions

MCQ-1A checkout service's steady state is defined as p99 latency under 400 ms and error rate under 1%. The team injects 250 ms of latency into every call to the fraud-check dependency for 20 minutes. During the run, p99 latency is 620 ms and the error rate is 0.8%. What does this run establish?
MCQ-7A team runs a chaos experiment in staging: they kill one pod of a stateless service that runs 6 replicas behind a load balancer, and observe that requests keep succeeding with no errors. What does this experiment validate?
MCQ-2A team runs a 10-minute chaos experiment on a checkout service: three replicas behind a load balancer, each serving about 400 rps, with a steady-state hypothesis of p99 < 800 ms and a 5xx rate < 0.5% on POST /checkout. They inject 5 s of latency into one replica's calls to the inventory service. The load balancer's health check (2 s timeout, three consecutive failures) ejects that replica after about 6 s. Aggregate p99 is 1.4 s for the first 30 s and 620 ms thereafter; the 5xx rate peaks at 1.1% in the first 30 s and settles at 0.05%. All three replicas stay running and the controller reports the run completed. Which conclusion does the data support?
MCQ-5A team runs a 30-minute chaos experiment in production, injecting 500 ms of latency into the recommendations service. The steady-state hypothesis is written on the checkout API: p99 < 300 ms and error rate < 0.5%. The stop condition is evaluated every 30 seconds. At minute 6, checkout p99 is 900 ms and its error rate is 3.2%; the recommendations service's own p99 is 520 ms and its error rate is 0.1%. What should the stop condition do at the next evaluation?
MCQ-11A checkout service runs on 8 pods. A chaos experiment injects 300 ms of network latency into 2 of those pods. The steady-state hypothesis is p99 < 250 ms and error rate < 0.5%, with an abort condition that halts the experiment if the breach is sustained for 30 s. After 90 s the experiment reports p99 = 480 ms and error rate = 3.2%, and the abort has already rolled the fault back. What is the correct next step?
MCQ-6A payments team runs a 10-minute chaos experiment that injects 400 ms of latency into the card-authorization path for 20% of traffic at evening peak. The injector aborts automatically if p99 authorization latency stays above 800 ms for 60 s. The experiment owner is also the payments on-call engineer. Safety review still requires a named independent abort authority. Mid-run, p99 climbs to 700 ms and holds there while the owner watches the injector dashboard. What does the independent abort authority add to this run?
MCQ-20A 15-minute chaos experiment injected 300 ms of egress latency into the checkout-to-inventory call path by installing a traffic-shaping rule on 3 of the 8 checkout pods. The controller reports the run 'completed', the abort condition never fired, and the dashboard shows checkout p99 back at its 180 ms baseline. What must cleanup include?
MCQ-19A payments team's chaos platform is scheduled to inject 300 ms of latency into the recommendations service at 02:30. At 02:14 the on-call is paged: checkout p99 has risen from 220 ms to 1.9 s and the error rate from 0.4% to 6%, traced to a saturated connection pool in the payments database. Recommendations and checkout run on the same 12-node pool, and the experiment pins CPU on 4 of those nodes. What should the on-call do about the 02:30 experiment?
MCQ-21A restart job resolves its target selector at execution time. Its governance pipeline runs in this order: resolve the selector against live inventory; drop every resolved host that does not match one of the job's allowlist patterns; abort if the surviving count is greater than the job's cap; otherwise run on the survivors and record that exact list as the run's resolved targets. Tonight the selector matches 120 hosts. The allowlist patterns are `web-*` and `cache-*`. Tonight's inventory holds 18 `web-*` hosts, 6 `cache-*` hosts and 96 `batch-*` hosts, all of which match the selector. The cap is 25. What does tonight's run do?
MCQ-13A chaos platform terminates instances by assuming a role whose policy allows `ec2:TerminateInstances` on `Resource: "*"`. Experiments select targets with `tag:chaos:enabled=true`. An engineer edits one experiment's selector to `tag:chaos:enabled` (no value) to widen the test set; the change is approved as routine, and the run terminates 14 instances in 90 seconds, including 3 production instances that carry `chaos:enabled=false`. The role's maximum session duration is 1 hour. The team wants the role itself to be unable to terminate an instance that has not opted in. Which change achieves that?
MCQ-4A checkout service handles 5,000 requests/second at peak. A change touches the gift-card redemption path, which 1.5% of requests use. The suspected bug corrupts about 1 in 500 redemptions, so the team wants at least 1,000 redemptions through the new code, roughly an 86% chance of seeing it, before widening. They want that signal within 30 minutes, and they want the smallest blast radius that delivers it. What should they start with?
MCQ-14Checkout serves a user request with three sequential gRPC calls to inventory. Baseline checkout p99 is 120 ms. During a chaos experiment the team injects 200 ms of latency on egress from checkout to inventory, on 100% of that traffic, for 10 minutes; every call still finishes inside its 1 s deadline. What is checkout's p99 during the injection?
MCQ-10`checkout` calls `payments` synchronously on every request and blocks on the response; that call is about 120 ms of checkout's 180 ms p99. A chaos experiment injects 400 ms of latency into every checkout→payments call for 10 minutes, with the hypothesis that checkout p99 exceeds 500 ms. The tool reports the fault applied to all 8 payment pods. During the run, checkout p99 stays at 180 ms and payments' own server-side p99 stays at 40 ms; the dashboard reports per-minute p99. What does this result most likely mean?
MCQ-9A Deployment runs 6 replicas spread 2 per node across three nodes, and a PodDisruptionBudget with minAvailable: 5 selects those pods. An operator runs kubectl drain node-1 with default flags. Each replacement pod takes about 40 seconds to pull its image before it reports Ready. How does the drain proceed?
MCQ-24An API runs on four replicas, each with a fixed pool of 50 worker threads; a request holds a worker for 25 ms. Steady traffic is 7,200 rps, spread evenly. In staging with no traffic, a chaos experiment that kills one replica causes no errors. The same experiment runs in production at 7,200 rps; the load balancer removes the dead replica within a second and clients do not retry. What happens to the three surviving replicas?
MCQ-15A payments team injects 400 ms of latency into 10% of calls to the payment API, which keeps returning 200s; the calling service has a 200 ms timeout and three retries. Which result confirms that retries amplified the fault rather than the delay simply slowing callers?
MCQ-12A consumer group is paused for 10 minutes during a fault-injection test while producers keep writing at a steady 2,000 msg/s. When the fault is removed the consumers resume: 40 workers, each sustaining 20 msg/s. Queue depth at resume is 1.2M messages. Ten minutes later depth is 1.9M and end-to-end latency has doubled. Which explanation fits these numbers?
MCQ-16A nightly batch API runs its metrics export in a background loop; its only alert rule is sum(rate(http_errors_total[5m])) / sum(rate(http_requests_total[5m])) > 0.05 for 2m. In a game-day that loop is stalled for 5 minutes while the process stays up: every one of Prometheus's 15 s scrapes returns 200 with http_requests_total unchanged, and up is 1 for the whole window. No alert fires, and on-call hears about the stall from the game-day report rather than the pager. Between jobs the API can sit at zero requests for 10 minutes. What must the team add before repeating the experiment?
MCQ-23A team is testing duplicate-event handling on a staging copy of their order pipeline. The staging pipeline consumes the production Kafka topic `orders` (12 partitions, 7-day retention, 310,000 events) under its own consumer group `staging-agg` and writes to a separate staging Postgres. Both the staging and production pipelines call the same `inventory` service, which decrements stock by the event's quantity for every event it receives. The team resets `staging-agg`'s offsets to the start of the topic and replays all 310,000 events, whose quantities average 14 units each. What is the effect on production stock?
MCQ-8A team is deciding whether to run a chaos experiment that kills the checkout service's Redis cache in production. In staging (200 rps, a 99% cache hit ratio, its own Postgres instance) killing Redis raised checkout p99 from 40 ms to 55 ms. In production, checkout serves 9,000 rps at peak with a 60% cache hit ratio, and its Postgres cluster is shared: the cluster is provisioned for 4,000 qps and inventory and pricing already consume 2,500 qps at peak. Checkout's SLO is p99 < 300 ms. If the team runs the experiment at peak, what will it show?
MCQ-25A checkout team runs a chaos experiment in staging: for 20 minutes it injects a 400 ms delay into every call to the recommendations service while replaying a recorded production trace at 25% of production request rate. Checkout p99 rises from 180 ms to 610 ms, no request exceeds 900 ms, and no requests fail. Checkout calls recommendations with a 1-second timeout and falls back to an empty list on timeout. What has the run established?
MCQ-3A checkout service reports latency per 5-minute window as the p99 (99th percentile). Over a 2-hour baseline it samples 24 windows: mean 310 ms, SD 88 ms, min 180 ms, max 460 ms. A reconciliation batch job runs every 30 minutes and lifts whichever windows it overlaps; 8 baseline windows overlap it (mean 430 ms, SD 30 ms), the other 16 do not (mean 250 ms, SD 20 ms). For a fault-injection run the team adds a fixed 150 ms sleep to every payment-dependency call for two 5-minute windows that the batch does not touch; those two windows read p99 = 402 ms and 415 ms. Which estimate of the fault's effect does this run support?
MCQ-18A checkout A/B test ran three weeks with 50,000 users per arm: control converted at 12.0%, treatment at 12.25%, two-sided p = 0.22. The team calls it a failed experiment and proposes rerunning the identical test (same traffic, same three weeks) to give the 0.25-point lift a chance to reach significance. What should they do?
MCQ-22During a 90-minute tabletop for a payments API, a facilitator walks the team through a simulated loss of the primary region. No production or staging systems are touched. The runbook says failover must complete within 15 minutes. In the discussion, the on-call engineer cannot identify who may declare a regional failover, the database team says replica promotion takes about 30 minutes, and the support lead has no customer message prepared. The session ends with an action list. Which action list is best supported?
MCQ-17Payments runs chaos experiments against 8 services. Last quarter's dashboard reads: 30 experiments, 14 findings, 14 findings closed, max blast radius 3 AZs, median 6 days from finding to ticket closure. Digging into the closures: 11 of the 14 were closed when the owning team marked the ticket done, with no re-run of the experiment; the other 3 were re-run and the failure no longer reproduced. 12 of the 14 findings are recurrences of 4 failure modes first logged two quarters ago. The team's stated target is 0.3–0.5 findings per experiment. Which conclusion does this data support?