Skip to content
Tech Interview Prep

Top 100 Site Reliability Engineer Practice MCQs

Every question on one page: open one, choose an answer, and see why at once. Signed in, your latest answer to each question counts, and you can answer again after 24 hours.

Curated: · Written: · Reviewed:

Reviewed 100Review pending 0

Answers to reviewed questions count toward this role and the overall leaderboard; your latest answer to each one is the one that counts.

100 questions

MCQ-6A service carries a 99.9% availability SLO over a rolling 30-day window, giving a 43.2-minute error budget. The published policy freezes feature deploys once more than 90% of the window's budget is consumed. It is day 25; four Sev-2 incidents this window have burned 8 minutes in total, leaving 35.2 minutes. A team wants to ship a feature deploy today. What should the on-call do?
MCQ-11A service has a 99.9% availability SLO over 30 days, so the error budget is 43.2 minutes. A bad deploy at 00:10 on the 29th takes the service down for 14 hours. The team's dashboard uses a calendar-month window that resets at 00:00 on the 1st, and no external contract requires calendar reporting. On the 30th the dashboard shows 0 budget remaining and a freeze, and the team plans to resume launches on the 1st when the calendar resets. What does a rolling 30-day window show, and when can launches resume?
MCQ-2A checkout API runs two SLOs on the same journey over a 28-day rolling window: availability = successful responses / valid attempts, target 99.9%; latency = successful responses under 400 ms / valid attempts, target 99.9%. The window holds 4,000,000 valid attempts. 2,000 returned 5xx; 320,000 returned 2xx but took longer than 400 ms. The on-call wants to close the incident because the availability SLO is the one customers notice. Which budget is burning, and what should the on-call do?
MCQ-1Checkout at an online retailer calls the card processor, then writes the order and returns an order id. Over a 30-day window the fleet served 4,000,000 checkout_started events and wrote 3,995,000 order ids. The 5,000 that produced no order id split into 200 checkout API responses with HTTP 5xx, and 4,800 processor calls that hung to the client's 30 s timeout, which the handler catches and answers with HTTP 200 and {confirmed: false}; those buyers saw a "payment could not be confirmed" page. The API's 5xx ratio for the window was 200 / 4,000,000, CPU idle on the checkout fleet averaged 62% against a 40% floor, and the processor call's p99 latency was 1.2 s. The SLO is 99.9% of checkouts produce an order id, and the team pages on one SLI. Which SLI should they page on, and what does the window show?
MCQ-7A payments team's availability SLI counts a payment good if the gateway returns HTTP 200 within 30 s, retries included; the dashboard reads 99.97%. A 7-day sample shows 7% of payment attempts fail on the first gateway call, the client SDK retries up to 3 times with backoff, and 1 in 14 buyers abandons at an 11-second spinner. The SLI feeds the error budget that gates releases, and the team wants it to drop when buyers are unhappy. What should the SRE do?
MCQ-8A payments service has held its 99.95% availability SLO all quarter and 5xx sits at 0.04%. Finance then finds that 3.1% of the 460,000 invoices written in the last 9 days were billed with the wrong tax rate, and every one of those requests returned 200. The postmortem action item is to close this class of gap. Which change addresses the cause?
MCQ-9A Kafka→Elasticsearch pipeline indexes inventory updates. The topic has 12 partitions keyed by SKU, and the consumer commits a partition's offsets only after the bulk request for that partition returns HTTP 200. The freshness SLO is 99.9% of documents searchable within 120s. Last month a mapping conflict made Elasticsearch reject every document from partition 7 (per-item status 400) while the overall bulk request still returned HTTP 200, and the consumer committed the offsets anyway. For 47 minutes, 8,400 SKUs' updates were absent from the index. Consumer CPU stayed at 22%, the cluster's aggregate indexing rate stayed normal, and p99 end-to-end delay over records that did index successfully was 1.8s. Which SLI would have fired during this incident?
MCQ-13A checkout service's 99.9% availability SLO is a contractual commitment, and the service must return a complete order or fail. Its request path calls auth, payments, catalog and a tax API in series, payments and tax both need the auth and catalog results, and each dependency publishes a 99.90–99.95% SLO. The bad events are dependency outages lasting minutes, not transient blips, and 30 days of data show each vendor meeting its published SLO. The team proposes to accept the vendor SLOs as-is and ship. What should the review require?
MCQ-12A payments API carries a customer SLA of 99.9% per calendar month: 43.2 minutes of allowed unavailability in a 30-day month. The team is setting an internal SLO over a rolling 30-day window so that paging fires while the contract is still intact, without paging on routine blips. Their rule: any single incident of 15 minutes or more must page, and incidents under 10 minutes must not. Which internal SLO target meets both?
MCQ-3A payments service has a 30-day rolling SLO of 99.9% (43.2 minutes of error budget). With 11 days left in the window, incidents have already consumed 38 minutes. The team wants to ship a risky schema migration that touches the write path. The published error-budget policy says: >21.6 min remaining = normal deploys; 8.6–21.6 min = canary plus 2-hour soak; <8.6 min = reliability work only. What does the policy require for this migration?
MCQ-4The checkout service carries a 30-day SLO of 99.9%: a 43.2-minute error budget. For the past 8 days, 0.2% of requests have returned 500s, a flat rate with no spikes. Alerting follows the standard multi-window burn-rate rules: page when both the 1h and 5m windows exceed 14.4×, page when both the 6h and 30m windows exceed 6×, and open a ticket when both the 3d and 6h windows exceed 1×. What is the alerting doing right now?
MCQ-10A checkout endpoint runs at 4,000 requests/minute under an SLO of 99% of requests finishing under 500 ms. The weekly report calls it healthy: mean 66 ms, p50 24 ms. Traces show 96% of requests are cache hits answered in 24 ms; the other 4% miss the cache and call the pricing service, which returns in 600-850 ms, and concurrent misses queue on a shared connection pool so that the slowest 1% of all requests reach the 2,100 ms p99. Mobile conversion fell 6% that week. Which reading of these numbers is right?
MCQ-14A nightly billing job carries an SLO of 99.5% of accounts billed per run, with each run due by 06:00 UTC; a run that misses either target is a failed run. The job has exited 0 on every run for the past 30 days and the dashboard shows green. Over that window it billed 36,222,488 of 36,300,000 source rows. The last three runs: | Date | Finished | Accounts in / billed | | --- | --- | --- | | Aug 17 | 05:12 | 1,204,331 / 1,204,331 | | Aug 18 | 05:08 | 1,211,004 / 1,133,492 | | Aug 19 | 07:41 | 1,209,880 / 1,209,880 | A filter change to the source query is queued for release. What is the correct read of the SLO and the right next action?
MCQ-15An SRE is asked to justify how the team handles the availability of the default-branch pipeline: the only path to production. The pipeline has no SLO, and during the last two Sev-1s the rollback job could not run: a 4-hour Git-runner outage stretched MTTR from 22 minutes to 4.6 hours, while the services themselves stayed inside their SLOs. The product teams own the pipeline definition and its jobs; the platform team supplies the runners. Which justification is sound?
MCQ-5An SRE team logs one on-call week. The rotation's 39 hours break down as: restarting the batch worker after an OOM kill, 19 h (the same fix every time); copy-pasting a config block to 12 shards, 7 h; design review for a new SLO, 4 h; commanding a novel customer outage, 6 h; writing a one-off migration runbook, 3 h. The team's charter sets a toil ceiling of 50% of on-call time and requires an automation ticket for any recurring step run more than twice in 30 days. Which conclusion should the review accept?
MCQ-18A payments team classifies incidents with a written matrix. Rows are user-visible impact; columns are the share of users affected. | Impact | < 5% | 5–50% | > 50% or revenue path | | --- | --- | --- | --- | | No user-visible effect | Sev-4 | Sev-4 | Sev-3 | | Degraded, workaround exists | Sev-3 | Sev-2 | Sev-2 | | Hard down or wrong money | Sev-2 | Sev-1 | Sev-1 | At 14:02 a deploy makes 14% of checkout attempts return 5xx for 38 minutes. Customers who hit the error can retry and the retry succeeds; no card is charged twice; the rest of the site is healthy. The on-call declares Sev-3 because the error "looks like a client bug". What severity does the matrix assign to this incident?
MCQ-16A payments team's last 10 Sev-1s have a median timeline of 16 minutes from the first failed charge to the page, 3 minutes to diagnose, and 3 minutes to mitigate. The page comes from a host CPU alert (5-minute scrape, 3-for-3 evaluation) that fires only when a CPU spike happens to accompany the failure; in 4 of the 10 incidents no CPU spike occurred and the page came from a customer ticket. The reported MTTR of 22 minutes sits under the 30-minute SLO and is marked green. Which change most reduces the median incident duration?
MCQ-17At 02:10 a Sev-1 fires on the payments API: p99 latency jumps from 40 ms to 2.4 s and the error rate from 0.2% to 9%. The on-call SRE acknowledges at 02:12 and starts reading traces. By 02:30 three engineers are on the bridge, each debugging a different hypothesis (connection pool, GC pause, a bad deploy) and no status-page update has gone out; support has 60 tickets. At 02:41 the SRE finds the cause: a config change that halved the connection pool. The revert lands at 02:44 and p99 is back to 45 ms by 02:49. Which single change to the incident process would most have shortened this incident?
MCQ-19A Sev-1 has checkout returning HTTP 503 for 38% of requests since 14:12 UTC. The team's external comms policy is one update every 20 minutes; the last went out at 14:32. The cause is unconfirmed and a rollback of checkout@2026.09.07.1311 is in progress. Support is logging tickets at 17/min, most asking whether the customer's own payment is affected. Which update should the comms lead post at 14:52?
MCQ-20Checkout went down for 40 minutes when an engineer applied a config to the wrong cluster. The postmortem's only contributing factor is "the on-call engineer picked the wrong cluster" and its only action item is "the engineer will re-read the deploy runbook." The engineer had read the current runbook; the deploy tool applies to whatever cluster is last in the kubeconfig context and asks for no confirmation. Six weeks later a different engineer applies the same config to the wrong cluster and checkout is down for 35 minutes. What should the second review require?
MCQ-21A payments team capped postmortems at three action items each, every one with a named owner and a due date. Two quarters later an audit of the 44 items filed shows 31 with a named owner and a due date, 27 closed by the owner marking them done, and only 4 that point to a check - a test, replay or dashboard that fails without the fix. Twelve incidents occurred in those two quarters, and seven repeated a contributing factor that an already-closed item had named. Which change should the team make next?
MCQ-22Checkout runs in three zones. At 14:02 on 4 March the power feed to zone b failed and stayed down for six hours. Automatic failover moved 100% of traffic onto zones a and c, whose connection pools each admit 40% of peak load, sized for three-zone operation rather than for the loss of a peer zone; those ceilings are capacity-sizing decisions reviewed quarterly, not per-deploy config. From 14:03 to 14:50 checkout p99 went from 120 ms to 3.4 s and the error rate from 0.2% to 11%, until an engineer raised both ceilings by hand. The other 5 h 13 min of the power failure produced no customer-visible impact. Quarter standings in customer-facing minutes: Change/deploy 460, Capacity/overload 218, Dependency 205, Config 159, Hardware/zone 138, which already includes this incident, out of 1,180 total. Any class holding at least 20% of the quarter's minutes is funded for the next reliability sprint. How should the 4 March incident be filed?
MCQ-23A checkout service carries a 99.9% availability SLO measured on request success rate. Over a 14-day window the pager fired 47 times: 33 host-level resource alerts (disk, CPU, memory) on nodes that never breached the SLO; 8 checkout error-burn alerts, each tracking a user-visible failure; and 6 connection-pool saturation alerts, 5 of which preceded one of those failures within 4 minutes, with a runbook fix that takes 2 minutes to apply. Which justification for the paging policy is sound?
MCQ-24An API's only page is `p99 latency > 500 ms for 5 min`, routed to the primary on-call. Last week it fired 39 times, all between 02:00 and 02:08 while the nightly ETL held p99 at 620 ms; every one was acknowledged in under 30 s with no action taken. The one real incident (a downstream dependency returning 500s for 9 minutes, 18% of requests failing) produced no page at all, because each failure returned in 12 ms and p99 stayed at 180 ms. Users reported it 9 minutes in. Which change would have paged on the outage and stayed quiet during the ETL?
MCQ-25An 8-engineer team runs one primary on a 24-hour rotation, handing off at 09:00 with a written doc. Over the last 30 days the pager fired 190 times: 70 from a single analytics node whose CPU alert fires and clears again inside 90 seconds during the 02:00 nightly compaction job; 22 from staging deploys that a legacy alert route still sends to the production pager, all between 10:00 and 16:00; and 98 real production pages spread evenly across the 24 hours. The team wants the fewest wakeups in the 23:00-07:00 band, and it will not accept losing the page when a node saturates for real and query latency starts to climb. Which change should the team make?
MCQ-26checkout-api at 40 rps publishes each order to a queue; checkout-worker, a separate service with its own tracing SDK, consumes the message and calls the payment processor. In one 22-minute window the 5xx rate reached 4.1%, and every failure logged payments_upstream_timeout after 2104 ms in the worker. Clicking the exemplar on the bad-request counter opens a trace that stops at the publish span, with no consumer span and no processor call, and the trace id printed on the worker's timeout log line is a different string. Both services sample 100% of traces. What change makes a failed checkout readable as one trace, from the metric down to the processor timeout?
MCQ-28checkout-api serves 200,000 requests an hour. histogram_quantile(0.99, sum by (le) (rate(checkout_latency_seconds_bucket[5m]))) reads a steady 1.86 s across the whole hour. The trace backend is a managed service: head-based sampling fixed at 1 in 1000, and its collector cannot be reconfigured. An engineer pulls 30 traces at random and every one is between 25 and 30 ms. Which change makes the requests behind the 1.86 s p99 visible in traces?
MCQ-29A 24-replica OpenTelemetry Collector fleet sits behind a round-robin load balancer and runs a tail_sampling processor with a status_code ERROR policy and a 300 ms latency policy. During a 4% error window, the error traces that reach the backend average 2 spans instead of the usual 40, and most are missing the root span. What should you change?
MCQ-27checkout-api emits http_requests_total with labels code, route, region and user_id. Three days after launch the metric held 12.4M series, Prometheus scrape lag reached 90s, and the burn-rate alert that should have fired did not. Alerting aggregates by route and region, per-user detail is needed only when debugging one request, no backend limit increase is funded this quarter, and the fix must stop the next high-cardinality label from repeating the incident. Which change should the team ship?
MCQ-30A checkout platform runs 12 services emitting about 40,000 log lines per second, retained for 7 days. During a payment-hang incident, correlating one failing request across services took 90 minutes because trace ids sat inside free-text messages, and only 62% of warn+ lines contained one. The post-incident requirement is that every warn+ line be joinable to its trace with a single query, and the log index budget allows two new first-class fields per service. Which logging policy meets the requirement?
MCQ-31Two incidents hit the checkout API last quarter. In A, a bad client header drove the 5xx rate to 9% for 40 minutes while every host's CPU stayed at 0.31 and memory at 0.44. In B, a slow query filled the database connection pool to 0.98 utilization with a 240-deep wait queue, and the API's p99 rose to 1,920 ms. The team can build one dashboard first. Which single dashboard would have caught both incidents, and why?
MCQ-32A checkout service's connection pool is capped at 500 by config. At 14:00 the pool holds 400 checked-out connections and has grown at a steady 4.2 connections per minute for the past 20 minutes. Raising the cap takes a config change plus a rolling restart of the fleet, 15 minutes end to end. The on-call rule pages when time-to-exhaustion falls below twice the scale-out lead time. What should the on-call engineer do at 14:00?
MCQ-33A service passes a staging load test at 10,000 rps with p99 18 ms; staging holds a 200-row fixture and a pre-warmed cache. In production the same generator reaches only 2,100 rps before p99 hits 640 ms, with DB CPU at 96% and threads waiting on the connection pool; the catalog holds 90 million rows and the cache hit rate is 61%. The team must publish a capacity number this week. Which action should they take?
MCQ-34A payments API's last peak drove the database primary to 88% CPU, and peak CPU has risen 3 percentage points per week for the last six weeks. The primary is CPU-bound on write traffic. The team's headroom SLO is 30% at peak on the bottleneck resource, and a larger DB SKU takes 30 days to provision. The app tier ran 42 of its 80 HPA-max pods at that peak. What should the team do?
MCQ-35At 09:00 a Redis-backed job queue holds 12,000 jobs and the depth is still climbing. Producers have been adding 200 jobs/s all morning. Thirty-two consumer workers pull from the queue, each job takes 200 ms, and that service time has been stable for weeks. Which conclusion follows from these numbers?
MCQ-36Checkout, search autocomplete and analytics ingest share one fleet. A 2.4x load test under the current fair-share admission left both checkout and search at 18% 5xx. Checkout must hold 99.9% success at 3x peak. Which shedding design do you ship?
MCQ-37You are reviewing the retry policy for a service that calls a payments API. The API answers overload with 429 and a Retry-After header, and its docs describe no deduplication for POSTs. The client retries in three layers (SDK, service, edge proxy) three attempts each. During a 4-second blip with 20% failures, offered load reached 27x, p99 went from 90 ms to 8.1 s, and the dependency took 19 minutes to recover. Which statement should the review accept?
MCQ-38A dependency serves 2,000 QPS at steady state. A 40-second outage leaves 36,000 clients retrying with exponential backoff (base 1 s, cap 60 s, full jitter), each making 5 attempts on average. The retries arrive perfectly spread (a flat 4,500 QPS) and the dependency saturates and fails again the moment it recovers. Which change fixes the cause?
MCQ-39Checkout calls payments (critical, 40 rps) and recommendations (optional, 2 rps). A single global circuit breaker wraps both calls: it opens after 5 errors in a 10 s window, stays open 30 s, then half-opens with one probe. During a recommendations outage, recommendations returns 503 for every call; payments stays healthy. Checkout must keep serving payments. What is the correct diagnosis and change?
MCQ-40A postmortem action item adds a 250 ms timeout and an empty-module fallback to the optional recs call on checkout. Checkout serves 200 rps from a 200-thread pool, and every request calls recs synchronously before rendering. The recs client retries up to 5 times on timeout, each attempt capped at 250 ms; when the call finally gives up, the page renders the empty module. Recs normally answers in 30 ms. During a recs incident, recs latency climbs to 5 s and stays there. What happens to checkout?
MCQ-41Checkout runs 12 pods, 4 in each of az-a, az-b and az-c. Each pod holds p99 at 300ms up to 250 rps and climbs past it beyond that; peak traffic is 2,400 rps. The team proposes a 15-minute experiment that kills all 4 pods in az-a, aborting if the 5-minute burn rate exceeds 6 (the page threshold is 14). The hypothesis: losing one AZ keeps p99 under 300ms. What should the reviewer require?
MCQ-42A payments team's quarterly AZ-failover test is fully scripted: traffic shifts in 4 minutes, nobody is paged, and it has passed every quarter for a year. When a real AZ was lost last month, the script again failed over in 4 minutes, but the team took 28 minutes to notice, 17 minutes to name an incident commander, and 41 minutes to complete the failover. What should the team change?
MCQ-43Checkout calls the tax API through a client with a 250 ms deadline and a 20-connection pool; on timeout it serves a cached rate up to 10 minutes old. Checkout runs at ~50 req/s. A canary injects a 30-second TCP hang (no response, no reset) on 2% of traffic. Checkout success drops to 91%, p99 latency hits 30 s, and all 20 pool connections sit in ESTABLISHED with zero bytes read. Which change fixes the failure?
MCQ-44The checkout service runs on a fixed pool of 20 pods, and the node pool is at its quota, so no new pods can be scheduled. Mean service time is 100 ms, p99 service time is 400 ms, and the p99 latency SLO is 500 ms. The load balancer can enforce a per-pod in-flight request limit and return 429. During a flash sale, offered load reaches 3,000 rps, p99 latency climbs to 4 s, and CPU sits at 55% on every pod. What should the team do?
MCQ-45A checkout service's HPA scales on CPU utilization at a 70% target. Under a load ramp, CPU held between 35% and 45% while p99 rose from 180 ms to 1.4 s and the number of requests each pod was concurrently handling grew from 4 to 19; no replica was added. Request cost varies widely, one checkout can fan out to 40 downstream calls, and pods block on a shared lock while awaiting them. The mesh exports p99 as a 1-minute rolling window, and the SLO is 300 ms. Which signal set should the review accept?
MCQ-46A service is rolling out a new build behind a 5% canary. The registered abort policy reads: abort if the canary slice's error rate exceeds control's by more than 0.20 percentage points, or if the canary slice's p99 exceeds control's by more than 50 ms, evaluated on the canary slice alone after a 15-minute soak. The soak has completed. Control served 84,200 requests at 0.12% errors (101 errors) and 188 ms p99; the canary served 4,410 requests at 0.94% errors (41 errors) and 210 ms p99. Over the last 30 days the service's error rate has ranged from 0.10% to 1.1%. What should the pipeline do?
MCQ-47A release pipeline sends 5% of traffic to the new version for 10 minutes, holds if the aggregate error-rate increase across all regions exceeds 0.50 points, then promotes to 100%. The edge sets the canary header only for requests from the three highest-traffic regions; eu-west is fourth and carries 3% of total traffic. Last week's release passed the canary gate at +0.05 points and was promoted; four minutes later eu-west's error rate hit 12% and 31% of eu-west users saw failures before a manual rollback. Which change to the pipeline would have surfaced the eu-west regression before the release was promoted to 100%?
MCQ-48At 14:02 a payments API starts a canary rollout of v7.3 to 10% of its pods. By 14:06 the /v1/charge 5xx rate on the canary pods is 5.8% against 0.4% on the v7.2 pods running beside them in the same region, and p99 latency on canary pods is 1.9 s against 210 ms. Stack traces point into the new cache lookup added in v7.3, which sits behind the conversion_cache_v2 flag. The team's abort line of 1% 5xx for 5 minutes is already crossed, and the /v1/charge incident RTO is 5 minutes to restore service. Rolling the Deployment back to v7.2 takes about 6 minutes (image pull plus readiness gate), flipping conversion_cache_v2 to false takes about 40 s, and building, testing and rolling out a v7.3.1 patch takes about 22 minutes. What should the on-call do next?
MCQ-49Checkout runs at 24,000 req/min, each session evaluates ff_checkout_v2 when checkout starts, and flag state lives in the flag service rather than in the artifact. Binary v441 has served 100% of traffic for three days with the flag off: 0.40% error rate, 210 ms p99. The rollout gate for a change like this is baseline + 0.20 error-rate points, or 2x baseline p99, breached by two consecutive 10-minute cohort readings; the service separately pages at 1.00% error rate over 30 minutes. ff_checkout_v2 was enabled for 5% of sessions at 13:50 (1,200 req/min). Cohort readings: 14:00 -> 0.46% and 230 ms; 14:10 -> 0.61% and 640 ms; 14:20 -> 0.67% and 1.6 s; 14:30 -> 0.64% and 1.7 s. It is 14:32 and the flag is still at 5%. Which action does the situation call for?
MCQ-50A checkout service re-reads its vendor timeout from a mounted ConfigMap on every request. A one-line `kubectl edit` changed the timeout from 250 ms to 25,000 ms on all 40 pods at once; every checkout thread blocked on the hung vendor, p99 went from 180 ms to 30 s, and 22% of requests returned 5xx for the 14 minutes until an engineer reverted the value by hand. The team now requires that a bad config value reach no more than 5% of the fleet and be revertible in one command. Which rollout plan satisfies that requirement?
MCQ-51An Argo CD Application for `checkout` has automated sync and selfHeal enabled with a 3-minute reconcile interval. At 02:00, mid-incident, an engineer ran `kubectl set image deploy/checkout api=registry/api:v1.4.3-hotfix`; git HEAD still pins `v1.4.2`. The Deployment's `spec.replicas` is owned by an HPA that has been moving between 4 and 9 all day, and a mutating webhook injects a logging sidecar on every apply. The pipeline is back at 02:04. Which action keeps the hotfix serving traffic and leaves git and the cluster agreeing?
MCQ-52An auth integration test runs on every PR build: about 400 builds a day. The pipeline retries each failed test up to 3 times and marks the build green if any attempt passes. A token-refresh race merged in week 2 makes that test fail on roughly 15% of runs; the build still ends green, and two days later production 401s hit 6% of logins. Which change would have surfaced the regression on the day it landed?
MCQ-53A team freezes the merge queue for the 4-day Black Friday window. Every PR needs two approvals from the release-approvers group, and that group is offline 22:00–06:00 in the team's timezone; the policy has no rollback exemption. Progressive delivery ramps a canary in 5% steps every 10 minutes. At 02:00 on day 2 the canary's error rate is 8% against a 0.2% baseline, and the automated rollback job opens a revert PR. Which change does the incident justify?
MCQ-54Checkout keeps session state in a shared Redis cluster, holding 20 minutes of live sessions that cannot be reconstructed. The release changes the serialization format of those entries, and old and new code cannot parse each other's values. The SLO requires cutback within 60 s. Blue is warm and sized for 100% of traffic; scaling it to zero saves cost but reprovisioning takes 9 minutes. Which rollout should they use?
MCQ-55A payments service runs PostgreSQL 13. `orders` holds 180M rows and takes about 3,000 inserts/s. To add a per-row token, the team runs one migration: `ALTER TABLE orders ADD COLUMN token uuid NOT NULL DEFAULT gen_random_uuid();`. On this instance a full table rewrite runs at roughly 500k rows/s. Which outcome does this statement produce?
MCQ-56A checkout service warms an in-memory pricing cache for 75 s before it can serve. Its manifest sets `livenessProbe` with `periodSeconds: 10`, `failureThreshold: 3`, `timeoutSeconds: 1`, no `initialDelaySeconds`, and no startup probe; `readinessProbe` runs every 5 s. During a rolling update, no new pod ever reaches Ready and the rollout stalls. What is happening?
MCQ-57A Deployment runs 6 replicas with memory request 512Mi and limit 512Mi, no CPU limit. HPA targets 60% CPU utilization, min 4, max 40. At a steady 30 rps, each pod's working set is 780Mi, CPU sits at 55%, p99 is 1.2s, and pods are OOMKilled every ~11 minutes. Over the last hour HPA scaled the Deployment from 6 to 18 replicas, but p99 and the OOMKill rate are unchanged. What should the team do next?
MCQ-58Checkout runs 6 replicas; each sustains 250 rps and the service peaks at 1,200 rps. Its PodDisruptionBudget is `minAvailable: 4`. During a rolling node AMI update, the drain evicts pods two at a time and checkout returns 503s for 7 minutes at peak. What change fixes the outage without blocking the drain?
MCQ-59checkout-api runs 6 replicas with cpu request 100m and cpu limit 200m. Its HPA targets 70% CPU utilization with maxReplicas 30. At peak the HPA pins at 30 replicas, the node pool sits at 55% CPU, and each pod logs about 40 s/min of CPU throttling. Measured CPU demand is 280m at p95 and 620m at p99. Which change fixes both the pinning and the throttling?
MCQ-60node-7 runs all 12 replicas of the checkout Deployment. The HPA is pinned at min 12 / max 12 and the cluster autoscaler is off, so the replica count cannot change. The PDB is minAvailable: 10. Every checkout pod requests 2 CPU, and no other node has 2 CPU free. An engineer runs kubectl drain node-7 --ignore-daemonsets --delete-emptydir-data with no --timeout. What happens?
MCQ-61You are asked to review a proposal covering secrets rotation. Which statement should the review accept?
MCQ-62A production payments service injects PAYMENT_TOKEN from a Kubernetes Secret into the container environment. The token has a 1-hour TTL and rotates every hour without pod restarts. After a diagnostic child process crashes, the postmortem finds the token in two places: the core dump's copy of the child's environment, and /proc/1/environ on the running pod, readable by sibling processes running as UID 65532. Which change removes both exposures while preserving automatic 1-hour rotation and no pod restarts?
MCQ-63One Terraform state file holds all of prod: the VPC, subnets, security groups, IAM, and 14 ECS services. An engineer edits one ingress rule in the shared networking module and runs `terraform plan`. The output reads `Plan: 1 to add, 3 to change, 1 to destroy.` The destroy is `aws_route_table_association.search`; the changes include `aws_security_group.shared`, which all 14 services reference, and two ECS services the engineer did not touch. The PR is titled 'add one ingress rule to shared SG'. What does this plan output establish?
MCQ-64A payments team must apply a schema migration to the `ledger` table. The apply holds an ACCESS EXCLUSIVE lock for its full 25-minute duration, blocking all writes. Rehearsals on a production-sized copy produced: | Window | Staff on hand | Traffic | p99 latency during apply | Time to detect a bad apply | Time to roll back | | --- | --- | --- | --- | --- | --- | | 03:00 | 1 on-call | 8% of peak | 4 ms | 47 min | 19 min | | 07:00 | 1 on-call | 30% of peak | 35 ms | 41 min | 17 min | | 10:00 | on-call + 1 | 55% of peak | 70 ms | 8 min | 9 min | | 14:00 | on-call + 1 | 65% of peak | 90 ms | 3 min | 6 min | | 19:30 | full team | 100% of peak | 1,400 ms | 2 min | 5 min | The service SLO is p99 < 200 ms. The team wants the shortest possible blocked-write time if the apply goes wrong, without breaching the SLO. Which window should it schedule?
MCQ-65A payments team is reviewing a production-access design before rollout. The design: engineers log in to SSO (8-hour session), then request a 60-minute SSM session grant bound to a change ticket. The grant service checks the SSO token only when it issues a grant; a session that is already running is not terminated when the SSO session ends. Standing SSH keys are removed. In the review's worked timeline, an engineer logs in to SSO at 09:00, starts their last SSM session at 16:50, and their laptop is stolen at 17:20. Under this design, what is the latest time the stolen laptop can still run commands on production?
MCQ-66Break-glass access is a role assumed through the identity provider. The role's policy declares a 60-minute TTL, and a reconciler job runs every 15 minutes to delete role bindings whose TTL has passed. The identity provider issues a session token at assume time that is valid for 12 hours; every service authorizes each request against that token and keeps no decision cache. The reconciler writes to the same binding store the services read, with no replica, and the reconciler host and the services are NTP-synced to within 1 second. In a drill, an engineer assumed the role at 02:05 and finished mitigation at 02:11. The reconciler logs show it ran cleanly at 02:15, 02:30, 02:45, 03:00, 03:15 and deleted the 02:05 binding at 03:15. At 03:20 the engineer's session still had write access to production. What explains the 03:20 access?
MCQ-67A payments team's merge pipeline runs at p50 8 minutes, and the team has budgeted at most +3 minutes of added p50 this quarter before reviewers start batching merges. Last year's 20 change-caused Sev-1/2 incidents cost 640 minutes of customer impact: 9 locking migrations (410 min), 5 checkout auth-header regressions (150 min), 4 overly broad IAM policies (60 min), 2 committed tokens (20 min). Measured cost of each candidate gate on the merge path: expand-contract linter +2 min, checkout e2e +6 min, secret scan +0.2 min, IAM plan diff +45 min (human approval). Which gate set should the team make blocking?
MCQ-68A 40-service cluster deploys with `image: registry.acme/checkout:latest`. The registry accepts a push from any token holding push scope and verifies no signatures. A postmortem found a developer laptop pushed an unsigned debug build over `:latest` at 11:04; 30% of pods restarted within 45 minutes and ran it for 3.5 hours. Which change actually prevents a repeat?
MCQ-69Your service bakes its timeout config into the pod image and ships config changes by replacing pods. Sticky sessions keep each user on one pod. Last week a bad timeout reached 5% of pods: the users pinned to those pods saw 100% errors, but the fleet-wide error rate rose only 5 points and the canary gate passed. Which change should the review require before the next config rollout?
MCQ-70Cluster A (primary, us-east) and cluster B (warm standby, us-west) replicate asynchronously; measured replication lag p99 is 22 s against a 60 s RPO and a 15 min RTO. A's control plane goes unreachable, but A's data-plane nodes keep running and keep accepting writes from clients that pinned the old endpoint IPs. What should the operator do?
MCQ-71A service reads through Redis at 12,000 req/s with a 96% hit rate; the origin serves 480 QPS at p99 40 ms and is provisioned for 2,000 QPS. A release rotates the cache key prefix. A backfill job pre-warms the new prefix, but when the new code goes live it has pre-warmed keys carrying only 80% of the traffic; the remaining 20% of requests miss until it finishes. What does the origin see during that window, and what must the release do?
MCQ-72A product-catalog service caches 5,000 keys in Redis with a 300 s TTL. A deploy script warms every key in a tight loop, so all 5,000 expire within the same second. The origin database handles about 800 reads/s; when the keys expire together it receives 5,000 simultaneous misses, p99 jumps from 30 ms to 4 s, and it returns 5xx for roughly 6 s. This repeats every 5 minutes. Which change removes the recurring spike?
MCQ-73A Kafka consumer group reads a topic at 80 msg/s while producers publish 200 msg/s. Lag is 2.4 million messages and the freshness SLO is 30 seconds. The team deploys a policy that returns 429 to producers whenever lag divided by the consumer drain rate exceeds 30 seconds. What happens next?
MCQ-74A payments consumer group reads a 12-partition Kafka topic. One record has a null `amount`; the handler throws before the offset commits, so the consumer re-polls the same record. Over 3 hours that partition's lag reaches 40,000 while the other 11 partitions drain normally. The team must keep the partition draining and preserve the bad record for inspection. Which change does that?
MCQ-75A payments service runs active-active in two regions. Each region writes to its own Postgres and streams ledger rows to the other region asynchronously (p99 180 ms); balances are computed by summing rows. Idempotency is a read-before-write against the local region only, and there is no cross-region unique constraint on the key. An account holds $1,000. During a 5-minute inter-region partition, a client times out on a $400 transfer with key tx-9f2 and retries it against the other region; each region's local check finds no tx-9f2, so both accept the write. Replication resumes. What is the account balance, and what is the correct fix?
MCQ-76A consumer reads `order.paid` events from a queue with at-least-once delivery. For each event it calls `payments.charge(key=str(uuid4()), cents=event.cents)` and then inserts `ledger(event_id UNIQUE, charge_id)`. A test publishes 1,000 events, the broker delivers each one twice, and no process crashes. Afterwards the provider reports 2,000 charges while the ledger holds 1,000 rows. Which change makes redelivery safe?
MCQ-77Partner A's webhook contract requires our 200 response body to carry the charge result, so we cannot acknowledge before charging. Our handler authenticates, charges inline, and returns the result; p50 is 210 ms. Last Tuesday a 4-second deploy window returned 500 to every request. Partner A runs 60 workers that re-send the same event every 1 s until they see a 2xx, and its client ignores Retry-After. Our payments pool (20 connections) saturated and stayed at 100% for 17 minutes after the deploy ended. Which change on our side stops the retries from reaching the payments pool?
MCQ-78Checkout has a 300 ms p99 SLO. A request calls auth (p99 40 ms), catalog (60 ms), payments (120 ms) and tax (30 ms) sequentially, each through its own HTTP client. During a payments outage the request pool fills and p99 climbs past 30 s. The handler has spent 130 ms when it reaches the payments call; the payments client retries once on timeout, and the team reserves a 50 ms margin for writing the response. What per-attempt deadline should the payments client be given?
MCQ-79A gateway is replacing its single global 2,000 rps token bucket with per-key buckets of 200 rps each, plus a shared reserved band of 400 rps that a key may draw from once its own bucket is empty. The band is drawn first-come, and key_9f2c is the only key that exhausts its own bucket. key_9f2c runs a batch client that retries on 429 and offers 1,800 rps; the other 40 keys offer 600 rps combined, each staying under 200 rps. Buckets refill continuously and the gateway admits in arrival order. Which admitted/shed split results?
MCQ-80An inventory service keeps a full replica of the `stock` table in us-east and eu-west. Both regions accept writes locally and replicate asynchronously; on conflict the `stock` column is resolved by last-writer-wins on the write timestamp. Each order does a read-then-write that decrements `stock` by 1. When a 9-minute cross-region link cut began, `sku-4471` had 4 units. During the cut us-east accepted 3 orders and eu-west accepted 3 orders, each decrementing from its local read of 4; both regions' ledgers show all six orders as committed. The link heals and replication runs. What does the system report for `sku-4471`'s stock, and how many units were oversold?
MCQ-81A postmortem for a payments service records: single primary in us-east-1a, async replica in us-east-1b, hourly EBS snapshots, cold AMI in us-west-2. The business requires RPO ≤ 5 min and RTO ≤ 15 min. At the 14:40 primary failure, replica lag was 41 min and cold AMI restore took 3.2 h to first successful checkout. The team can make one change this quarter. Which change best meets both targets with the least added write latency?
MCQ-82A payments service has an RPO of 5 minutes and an RTO of 30 minutes. A nightly pg_dump runs at 02:00 into S3 and takes 19 minutes to restore; WAL segments are shipped to S3 every 5 minutes. The monthly drill restores the 02:00 dump into a staging host, replays WAL from the primary's local pg_wal directory, and finishes in 24 minutes with a row-count diff of 0. The primary stays up throughout the drill, and the drill is marked green. What should the team do?
MCQ-83A team must meet a 5-minute RTO for DNS failover across mobile carriers. Suppose a 60 s TTL flip left 38% of mobile users on the dead IP for 11 minutes because carrier resolvers clamped TTL to 300 s. Which change is defensible?
MCQ-84Forty pods sit behind an L4 load balancer whose health check is a TCP connect to :8080, interval 5 s, unhealthy threshold 3. A lock-ordering bug deadlocked the request-handling thread pool in 12 pods during an incident; those pods kept their listening socket open, so the balancer never removed them. They stayed in rotation for the full 22-minute incident, and fleet p99 rose from 45 ms to 8.2 s because about 20% of requests landed on a deadlocked pod. The team wants the balancer to evict a pod within 15 s the next time this deadlock occurs. Which change does that?
MCQ-85A 10-pod service behind an L7 balancer uses cookie session affinity. The cookie stores the pod's name; the balancer forwards each request to that pod and rehashes only when the cookie is absent: it does not rehash when the named pod leaves the pool. Cookie TTL is 12 hours. A rolling deploy deregisters and terminates each pod in turn, replacing it with a new pod under a new name. After each termination, the ~10% of users whose cookie names that pod get 502s until their cookies expire, up to 12 hours later. The team proposes to keep the 12-hour cookie and add a health check that removes unhealthy pods from the pool. Which outcome should the review predict?
MCQ-86An 80-pod service reads 20 hot keys. Origin steady load is 40 QPS and it sheds above 200 QPS. Each pod fetches all 20 keys at process start, and those fetches complete within 2 s. The rollout controller starts each wave of maxUnavailable pods together (all processes in a wave launch within the same second) and waits for the whole wave to become ready before starting the next; a wave takes 60 s to become ready, and the deployment must finish within 5 minutes. A restart at maxUnavailable 50% drove origin to 440 QPS and it shed. Which change keeps origin under 200 QPS and finishes the rollout within 5 minutes?
MCQ-87A service issues 30-second leases with fencing tokens and authenticates node-to-node traffic with mutual TLS. NTP is reachable from every node, but nothing alerts on offset. Last quarter a node drifted 12 minutes, rejected new certs as not-yet-valid, and served 5xx to 6% of the users hashed to it for two hours. Which change set is the right response?
MCQ-88During a traffic spike the HPA scaled a service from 10 to its maximum of 40 pods. Each pod opens a pool of 50 connections. Postgres runs with max_connections = 500, of which 20 are reserved for the migration runner and on-call. New checkouts began returning 500s while pool wait p99 passed 2 s. The DB host has 8 GB of RAM and each backend costs roughly 10 MB. The service uses session-level advisory locks and LISTEN/NOTIFY. Which change should the postmortem action item specify?
MCQ-89An order-history service reads from a gp3 EBS volume provisioned at 3,000 IOPS. After a traffic shift toward smaller, more random reads, p99 latency rose from 40 ms to 180 ms. During the spike: CPU 14%, disk await 210 ms with queue depth 32, NIC utilization 12% with zero drops, and request threads blocked in read(). Which change addresses the bottleneck?
MCQ-90A VPC spans three AZs, and every private subnet's route table sends 0.0.0.0/0 to a single NAT gateway in AZ-a. During a peak, outbound calls to an external payments API fail from all three AZs with ErrorPortAllocation, and the NAT gateway shows ~55,000 active connections to that one destination. The team's requirement is that no single AZ failure may take down egress from the other AZs. What should they do?
MCQ-91A service runs in three AZs behind an ALB and peaks at 1,200 rps; one pod sustains 250 rps. Clients hold long-lived gRPC connections, and the SLO requires surviving pods to stay at or below 70% utilization after any single AZ loss with no human in the failover path. Which plan is defensible?
MCQ-92A payments team deploys to production from GitHub Actions. The deploy job authenticates as an IAM user whose access key was created 26 months ago and lives in the repository's Actions secrets; the user's policy grants `s3:*` and `iam:PassRole`. The repo has 60 contributors and accepts fork PRs. Security requires that no credential usable from outside the runner can deploy to production. Which change meets that requirement?
MCQ-93Acme gives every CI job one role, build-runner, reachable from 40 repositories. Its inline policy allows: - s3:GetObject, s3:PutObject on arn:aws:s3:::acme-artifacts/* - ecs:* on * - iam:PassRole on arn:aws:iam::111122223333:role/app-task-role and arn:aws:iam::111122223333:role/app-execution-role The account runs 214 ECS services across 3 clusters; 6 of them run under app-task-role, which reads the nightly payments exports in arn:aws:s3:::acme-payments-exports/*. An access key for build-runner is exfiltrated from one of the 40 repositories. What is the blast radius of that key?
MCQ-94A release pipeline runs `terraform plan -out=plan.bin` in a CI job at commit 7a11e4c, uploads the artifact, and a separate prod job downloads it and runs `terraform apply plan.bin` (Terraform 1.7). During a release the upload step fails on an S3 policy change, so the prod job finds no plan.bin. Since the plan was made 3 hours ago, 12 merges have landed on main, and an on-call engineer manually raised an RDS instance class 40 minutes ago. Which action should the release take?
MCQ-95A CI job prints a 64-character hex API key (`openssl rand -hex 32`) into a build log retained 90 days and readable by all 400 engineers. The post-job log scanner uses a Shannon-entropy threshold of 4.5 bits/char with a 20-character minimum, and it did not flag the key. What is the correct diagnosis and action?
MCQ-96A 90-day TLS certificate is issued into a Kubernetes Secret on 2026-01-01T00:00Z, and cert-manager renews it on schedule when 30 days remain. The ingress controller loads the certificate from the Secret at pod start and does not watch for Secret updates; the pod has run continuously since 2026-01-01. The team adds an external probe that reads the served certificate's notAfter and pages when 21 days or fewer remain. On which date does the probe first fire?
MCQ-97Checkout's 30-day success SLO is 99.9% over 10,000,000 requests, so the service error budget is 10,000 bad events. The payments vendor hop is allocated 20% of that budget and handles 4,000,000 calls in the same window. Caller-observed payments success is 99.90%. What should the team do?
MCQ-98Checkout's payment vendor starts failing at 14:02: checkout_payments_success drops to 97.4%, and on-call flips PAYMENTS_CACHE=1 at 14:07, which serves tax and auth from cached responses. The runbook's revert condition is 'vendor success > 99.5% for 20 min'. The vendor's success readings are 99.6% at 14:40, 99.4% at 14:45, and 99.7% from 14:48 onward. At 14:52, what should on-call do?
MCQ-99A payments API is served at api.example.com through Route 53, a CDN with WAF, and an ALB into a VPC. Synthetic checks run from an EC2 instance inside the VPC, calling the ALB's private IP with a Host header and asserting HTTP 200 on /healthz every 60 s. Two incidents last month: an apex DNS change pointed api.example.com at a decommissioned load balancer, and the internal checks stayed green for 14 minutes while every checkout failed; days later a payment-provider credential rotation left /healthz returning 200 while every checkout POST returned 502 for 9 minutes. Users reported both. The team has budget for one synthetic probe per region. Where should the probe run and what should it assert?
MCQ-100A checkout service holds a 99.9% availability SLO over a 30-day window, so its error budget is 43.2 minutes. On day 12 the team has burned 21.6 minutes, almost all of it from a retry storm in the recommendations service that also produced 14 hours of on-call toil last week. A new ranking model for that same service is due to launch on day 15. The team's error-budget policy moves engineering effort from features to reliability once the current burn rate exceeds the sustainable rate (budget divided by the window length). What should the team do on day 12?