Skip to content
Tech Interview Prep
Technical interview guide

GitOps

Using a Git repository as the single source of truth for infrastructure and deployment state.

Read
30 min
Practice MCQs
25
Interview Q&A
25
Edition
v4
Editorial status
Reviewed

Scope: OpenGitOps, Argo CD, Flux, Kubernetes, and Sigstore guidance current 2026-08-31.

Curated: · Written: · Reviewed:

25 questions

MCQ-2A postmortem cites merge commit 9f3c1a2 on main as proof the fix reached production. The build for that commit failed at 14:05, no artifact was published, and the error rate only fell at 14:40 after an unrelated rollback. Which claim does the commit itself support?
MCQ-5A team gates production promotion on Argo CD reporting Synced. A release whose migration dropped a column passed the gate and broke checkout. What does the Synced condition actually establish?
MCQ-1A team runs a pull-based GitOps agent on two clusters. Both watch the same repo and the same manifests, and both poll every 3 minutes. At 10:00 an engineer edits a ConfigMap directly with kubectl on each cluster. At 10:05 the engineer commits an unrelated manifest change to the repo. By 10:10 cluster B has reverted the manual edit and applied the commit; cluster A has done neither, though its Application has reported OutOfSync on every poll since 10:00 and its sync logs contain no failed attempts. What explains cluster A?
MCQ-20A controller reconciles `AppTarget` custom resources. Each loop reads `metadata.generation` and writes `status.observedGeneration`; a Prometheus gauge `reconcile_age_seconds{target}` records seconds since that target's last successful reconcile. Fleet-wide, `reconcile_age_seconds` p99 is 6 s. For target `checkout-api` right now: - `metadata.generation` = 42 - `status.observedGeneration` = 39 - `reconcile_age_seconds{target="checkout-api"}` = 900 - controller workqueue depth = 2 - apiserver request latency p99 = 40 ms - controller error rate = 0 Which conclusion is best supported?
MCQ-7An API Deployment's manifest in Git declares `replicas: 6`. During a traffic spike, the on-call engineer runs `kubectl scale deployment/api --replicas=30` and commits nothing. The cluster runs Argo CD with automated sync and self-heal enabled, reconciling every 3 minutes. What does the engineer observe?
MCQ-16An Argo CD Application manages a `Deployment` and a `ConfigMap` with `syncPolicy.automated.selfHeal: true` and the default 3-minute reconciliation. Git declares the ConfigMap's `MAX_CONNECTIONS: "50"`. At 11:02, with the service returning 503s under load, an engineer runs `kubectl patch configmap app-config --type merge -p '{"data":{"MAX_CONNECTIONS":"200"}}'`. The 503s stop. The provider confirms the higher limit is permanent, and the team expects to keep changing this value per environment. At 11:05 the 503s return. What should the engineer do?
MCQ-6`payments-api` is a 3-replica Deployment in an Argo CD Application that also holds 30 unrelated resources; the Application has `syncPolicy.automated.selfHeal: true` and `prune: true`. During the nightly batch an HPA takes the Deployment to 24 replicas, and each time Argo CD put it back to 3 about three minutes later: four reverts last night, and the batch missed its window. The team still wants self-heal to correct manual `kubectl` edits to image tags and env vars on the other 30 resources. Which change gives them both?
MCQ-24An Argo CD application controller manages 340 Applications across 12 clusters. For five hours the UI reports every Application Synced and Healthy. A direct read on cluster-07 returns `registry.internal/payments:2.4.1` for the payments Deployment's container image, while the Git manifest declares `2.4.0`. Restarting the application controller pod makes Argo CD report that Application OutOfSync within seconds, with no change to Git or the cluster. Which explanation fits?
MCQ-3A 40-node cluster is rolling a deployment whose manifest references `registry.example.com/checkout:release`. The pipeline re-pushes that tag at 09:00, mid-roll. By 09:20, 12 nodes have pulled the pre-09:00 build and 28 the post-09:00 build; the two builds disagree on a Redis cache-key format, and 3% of reads return corrupt values. The team changes the manifest to `registry.example.com/checkout@sha256:9f2c…`. What does that change do for the next roll?
MCQ-12CI overwrites the `stable` tag on every merge to main. Staging verified `registry/app@sha256:1a2b` at 14:02. A merge at 14:40 moves `stable` to `sha256:9f0c`. The prod deploy job runs at 15:00, pulls `stable`, and reports success, so prod is now running `9f0c`, which staging never tested. Which change to the promotion path makes the next prod deploy run the revision staging verified, and only that revision?
MCQ-15Release 5.2.0 (commit 9f3c1d) is built by two runners from the same repository state, and their wheels hash differently: sha256:3b1f... on runner A, sha256:8ac4... on runner B. The logs agree on everything except one line. The base image tag base:5.2 resolved to digest sha256:7c0d... on both runners, the interpreter is 3.11.2 on both, and requirements.txt pins every wheel with == and --hash=, all of which matched. The line `acme-utils @ git+https://github.com/acme/utils.git@main` resolved to commit 4a9e77 on runner A and 1c33ab on runner B. Diffing the two wheels, every differing byte sits in acme_utils/*.py and the RECORD entry, and matches the diff between those two commits. Which change makes the two runners build the same wheel?
MCQ-17The `api` chart (Helm 3) renders cleanly with its default `values.yaml`, where `resources` is empty, and `helm lint ./charts/api` passes in CI. The deploy job runs `helm upgrade --install api ./charts/api -f values/prod.yaml`; `values/prod.yaml` sets `resources.limits.cpu: "2"` and `resources.limits.memory: 4Gi`. Last week that job failed in production with a YAML parse error in the rendered Deployment's resources block. The team wants CI to fail before the deploy job runs. Which CI change does that?
MCQ-9A Flux Kustomization reconciles `apps/prod` with `prune: true`. A pre-apply step renders the overlay with `kustomize build` and aborts the sync when the rendered object count is exactly 0. The overlay's `kustomization.yaml` lists 12 base directories; the live cluster holds 214 objects. A merge conflict resolution drops 11 of the 12 entries, leaving only the `namespace` base, which emits 1 object. `kustomize build` exits 0. What does the pipeline do, and what is the cluster's object count afterward?
MCQ-18A team runs two GitOps controllers against the same cluster, and both reconcile the same Deployment with server-side apply. Both manifests set `spec.replicas`. The next `kubectl apply --server-side` fails with `Apply failed with 1 conflict: conflict with "flux" using apps/v1: .spec.replicas`. What condition produces this conflict?
MCQ-10One Argo CD Application ships a Postgres StatefulSet, a schema-migration Job, and an API Deployment. On a fresh cluster the API pods crash-loop because they start before Postgres accepts connections. The team wants Argo CD itself to hold the Deployment back until the StatefulSet reports Healthy, and does not want to change the pod specs of the workloads. What should they do?
MCQ-23An Application's manifests carry sync-wave annotations from -1 to 5. Argo CD has applied waves -1 and 0. Which condition stops it from ever applying waves 2-5?
MCQ-11An Application declares a PreSync hook Job `db-migrate` (annotations `argocd.argoproj.io/hook: PreSync` and `argocd.argoproj.io/hook-delete-policy: HookSucceeded`) that applies a schema migration and exits 0. Sync #1 completes and the Job is no longer in the cluster. A later commit that changes only a ConfigMap value triggers sync #2. What happens to the migration during sync #2?
MCQ-8A team runs an Argo CD Application that syncs every manifest under apps/checkout into namespace checkout, with automated sync, prune: true, selfHeal: true, and the default resource tracking. Three months ago that Application deployed checkout-api from apps/checkout/deployments/checkout-api.yaml. Last Tuesday a developer moved that file to apps/archive/checkout-api.yaml, a directory no Application syncs, and changed nothing in the cluster. The following sync reported Synced and Healthy, but the Deployment was gone along with its 6 pods, and the cluster audit log attributes the delete to the argocd-application-controller service account. A Secret the team created by hand in namespace checkout with kubectl, which Argo CD has never applied, was not touched. What explains the deleted Deployment?
MCQ-22A deploy job runs `kubectl apply --prune -l app=payments -f rendered/` in the `payments` namespace. `rendered/` holds 12 objects. The label `app=payments` also matches 28 CronJobs and ConfigMaps that a separate batch pipeline applied from its own directory; all 40 objects are in the `payments` namespace, and both pipelines have used that label since they were created. What does this run do?
MCQ-13Checkout runs on Kubernetes behind Argo CD with automated sync, prune: true and the default 3-minute reconciliation poll, backed by PostgreSQL 15. The app repo holds both the Deployment manifests and plain, non-hook SQL migration Jobs, so one commit can carry code and schema together. Release v42 was a single commit: its Job copied orders.legacy_flag into a new orders.flag_v2 column, backfilled 1.4M rows, then dropped legacy_flag, and its Deployment switched pods to checkout:v42, which reads only flag_v2. Three hours later the Job has completed and checkout errors sit at 6%, so the team reverts that one commit and pushes; Argo CD reconciles two minutes later, pruning the Job and applying the v41 Deployment, whose readiness probe is a TCP check with no database access. What does the cluster do with that sync?
MCQ-19A platform team runs Argo CD in-cluster on three clusters. All 40 services' Kubernetes manifests live in one Git repo, and each cluster's Argo CD manages its own Applications. The primary cluster is destroyed in a region outage. The team installs Argo CD from its Helm chart into a fresh cluster, restores the repo-credentials Secret from the vault, and confirms the UI shows the Git repo connected with every manifest browsable. All Argo CD pods report Running and Ready, and `kubectl get applications -A` returns an empty list with no error. Nothing is deployed. What is the cause?
MCQ-25A controller-runtime controller with the default controller rate limiter and default MaxConcurrentReconciles reconciles 5,000 custom resources. A dependency starts returning HTTP 503 for every call, so each reconcile returns an error and the item is requeued. A reconcile spends 20 ms in the failing call. Once the initial burst has drained, roughly how many reconciles per second does the workqueue deliver?
MCQ-14A platform team runs one Argo CD instance for 40 product teams. Each team owns one namespace (ns-team-1 through ns-team-40) and one repository, and every Application is synced by the single argocd-application-controller ServiceAccount, which is bound to cluster-admin. A pen test committed to team 7's repository, and the controller created a ClusterRoleBinding granting cluster-admin plus a Deployment in ns-team-9. The change you make must hold three things at once: a commit in team 7's repository can only write namespaced objects in ns-team-7; the other 39 teams keep syncing exactly as before; and the platform repository keeps creating cluster-scoped objects such as CRDs and StorageClasses. Which change meets all three?
MCQ-4A payments team migrated all 40 of its CI pipelines off a shared kubeconfig that carried cluster-admin into prod, after a compromised runner used it. The kubeconfig was deleted from the CI secret store. Pipelines now hold repo tokens with write scope on the deployment repo; direct pushes to main are rejected and merging to main needs approval from one of the 30 developers with review rights. In prod, an Argo CD controller granted cluster-admin reads the repo with a read-only deploy key and reconciles main every 3 minutes over outbound HTTPS; NetworkPolicy denies ingress from the CI subnet. A month later the same runner is compromised again. What can the attacker do?
MCQ-21A deploy gate runs `cosign verify` on every image before it reaches the cluster, requiring the signing certificate's identity to match `^https://github\.com/acme/api/\.github/workflows/release\.yml@refs/heads/main$` and its OIDC issuer to be `https://token.actions.githubusercontent.com`. On Tuesday an image tagged `api:2.14.0` passed the gate and shipped with a backdoor in the binary. The signature verified, the certificate identity and issuer matched, and the signed digest equalled the digest of the image that shipped. The release workflow builds whatever commit is checked out on `main` and signs the resulting image digest; the source commit is not part of the signature. The `v2.14.0` git tag points at the reviewed release commit. Which change to the gate would have blocked this image?