Skip to content

Top 31 Argo CD Interview Questions and Answers [2026]

November 16, 2026 31 min read
Argo CD interview guide by Second Talent
TL;DR: Argo CD interviews in 2026 test whether a candidate can explain why a sync did or did not happen, order a rollout with waves and hooks, scope access with projects and RBAC, and generate hundreds of Applications without deleting production by accident. Candidates should know Argo CD 3.6 (3.6.0 on November 3, 2026, now 3.6.1), the default changes that 3.0 shipped, and Argo Rollouts 1.10.

Argo CD 3.6 now runs Server-Side Diff automatically for any Application that uses the ServerSideApply=true sync option, after the old Structured-Merge Diff code was removed, so validating webhooks run during a diff and the kube-apiserver sees more dry-run traffic.

The current release is Argo CD 3.6.1, and the 3.5 to 3.6 upgrade notes list the rest. The questions below are for platform, DevOps and site reliability engineers who will own a GitOps setup, with four find-the-bug rounds.

Key takeaways
  1. 1Since 3.0, an update or delete grant on an Application no longer covers the resources inside it. Restarting a pod needs an explicit delete/*/Pod/*/* rule.
  2. 2Resources default to sync wave 0, and Argo CD waits 2 seconds between waves (ARGOCD_SYNC_WAVE_DELAY) before it checks health.
  3. 3An ApplicationSet with the default sync policy deletes generated Applications, and their workloads, when a generator stops returning them.
  4. 4The 3.3 series reached end of life with 3.3.19 on November 2, 2026. Supported lines are now 3.4, 3.5 and 3.6.

GitOps Model and Architecture

1. What is the GitOps model, and how does Argo CD implement it?

GitOps keeps the desired state of a system in Git, declared rather than scripted, and has an agent inside the platform pull that state and reconcile the live system toward it on a loop. Argo CD is that agent for Kubernetes.

It watches repositories, renders manifests with Helm, Kustomize, plain YAML or a config management plugin, compares the result with the live objects and reports the difference as sync status.

The contrast a candidate should draw is with push-based deployment, where a CI job runs kubectl apply or helm upgrade with cluster credentials. In the pull model:

  • The CI system never holds cluster admin credentials. It builds, tests and writes a new image tag to Git.
  • Drift is visible. A change made with kubectl edit shows up as OutOfSync, and self-heal can revert it.
  • Rollback is a Git revert, with an audit trail in the commit history.

A weak answer stops at "Git is the source of truth".

A strong one names what still lives outside Git: secrets, the Argo CD install itself unless it manages itself, and runtime fields such as HPA replica counts that must be excluded from comparison (question 19).

For how the CI half of the pipeline fits, see our CI/CD interview guide.

2. What are Argo CD's main components, and what does each one do?

Argo CD runs as a set of controllers and services in its own namespace:

  • API server (argocd-server): serves the UI, CLI and gRPC/REST API, handles SSO, enforces RBAC and receives Git webhooks.
  • Repo server (argocd-repo-server): clones repositories and generates manifests. It runs Helm, Kustomize and plugins, and it is usually the first component to run out of memory.
  • Application controller (argocd-application-controller): a StatefulSet that compares desired and live state, runs syncs and assesses health.
  • ApplicationSet controller: turns ApplicationSet resources into Application resources.
  • Redis: a cache for manifests and app state. Losing it costs time, not data.
  • Dex (optional): an identity broker for SSO connectors such as GitHub or SAML.
  • Notifications controller: sends sync and health events to Slack, email or webhooks.
  • Commit server (optional): pushes rendered manifests back to Git for the Source Hydrator (question 13).

Good candidates know where to look when something breaks: manifest generation errors and timeouts live in the repo server logs, and stuck syncs or wrong diffs live in the application controller logs.

3. How does Argo CD notice a new commit, and what is the difference between a refresh and a hard refresh?

By polling and by webhooks. Per the high availability docs, the controller polls Git every 3 minutes by default, set by timeout.reconciliation in argocd-cm, with timeout.reconciliation.jitter spreading the load.

A Git webhook to the API server triggers an immediate refresh of the Applications that use the repository.

  • A refresh compares the latest Git revision with the live state, reusing cached manifests when the revision has not changed.
  • A hard refresh drops the manifest cache and regenerates, which matters when a Helm chart dependency or a plugin output changed without a new commit.

For large monorepos, a strong candidate knows the webhook can be expensive: one push can refresh hundreds of Applications.

The docs recommend disabling manifest cache warming on webhooks for plain-YAML monorepos (webhookManifestCacheWarmDisabled: "true" on the repository Secret) and offer webhook.refresh.jitter to spread the refreshes out.

4. How does Argo CD know which live resources belong to an Application?

Through resource tracking.

Since 3.0 the default application.resourceTrackingMethod is annotation: Argo CD writes an argocd.argoproj.io/tracking-id annotation on each object it applies, encoding the Application name and the object's group, kind, namespace and name.

Before 3.0 the default was the app.kubernetes.io/instance label.

Annotation tracking fixes two problems with the label method. Labels are limited to 63 characters, so long Application names were truncated.

And other tools, Helm charts in particular, also set app.kubernetes.io/instance, which made Argo CD think it owned objects it did not create, or copied the label onto children of an operator so they showed up as prunable.

The 2.14 to 3.0 upgrade notes add the trap: Applications using ApplyOutOfSyncOnly=true with label tracking need an explicit full sync after the upgrade so the annotation gets written to resources that were already in sync.

5. How do you lay out a Git repository for several environments?

Use one branch and a directory per environment, and promote by changing files, not by merging branches. A common shape is a Kustomize base with overlays, or one Helm chart with a values file per environment:

deploy/
  apps/
    payments/
      base/
        deployment.yaml
        kustomization.yaml
      overlays/
        dev/kustomization.yaml
        staging/kustomization.yaml
        prod/kustomization.yaml
  clusters/
    prod-us-east/
      apps.yaml        # app of apps or ApplicationSet for this cluster

Branch-per-environment looks tidy and fails in practice: environments drift through cherry-picks, a merge from staging to prod carries unrelated changes, and nobody can diff prod against staging in one view.

A strong candidate also separates application source code from deployment config, so a docs commit in the app repo does not refresh every Application, and states who is allowed to merge to the prod overlay.

Ask a follow-up: how does a new image tag get into the prod overlay?

Good answers include a CI job that opens a pull request against the overlay, Argo CD Image Updater writing back to Git, or the Source Hydrator with a promotion tool on top.

A weak answer has CI run argocd app set, which leaves Git out of date.

6. How do you handle secrets with Argo CD?

Keep plaintext secrets out of Git and out of Argo CD's manifest cache. The two patterns interviewers want to hear:

  • A controller that materializes secrets in the cluster, such as External Secrets Operator reading from AWS Secrets Manager, Vault or GCP Secret Manager. Git holds only an ExternalSecret reference.
  • Encrypted secrets in Git, such as Sealed Secrets, where only the in-cluster controller can decrypt.

The secret management docs recommend against injecting secrets during manifest generation, for example with a plugin that resolves Vault paths inside the repo server.

Generated manifests sit in plaintext in Redis, Argo CD needs read access to the secrets, and secret updates get coupled to unrelated syncs.

A senior candidate also explains how a rotated secret reaches running pods, which takes a reloader or a checksum annotation, not Argo CD.

Applications, Projects and ApplicationSets

7. Walk through an Application manifest. What does the finalizer do?

An Application names a source, a destination and a project, plus an optional sync policy:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: payments-prod
  namespace: argocd
  finalizers:
    - resources-finalizer.argocd.argoproj.io
spec:
  project: payments
  source:
    repoURL: https://github.com/example/deploy.git
    targetRevision: main
    path: apps/payments/overlays/prod
  destination:
    server: https://kubernetes.default.svc
    namespace: payments
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true

The resources-finalizer.argocd.argoproj.io finalizer makes deleting the Application cascade: Argo CD deletes the managed Kubernetes objects first, then removes the Application.

Without it, deleting the Application leaves the workloads running, orphaned from GitOps. Both are valid choices, and the candidate should say which one they want for production and why.

Many teams put the finalizer on leaf Applications and leave it off the root of an app of apps (question 9) so a mistake at the top does not tear down everything below.

8. What does an AppProject control?

An AppProject is the tenancy boundary.

It restricts which repositories an Application may pull from (sourceRepos), which clusters and namespaces it may deploy to (destinations), which cluster-scoped kinds it may create (clusterResourceWhitelist), which namespaced kinds are blocked, and when syncs may run (syncWindows).

It can also define project roles with their own JWT tokens for CI.

apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: payments
  namespace: argocd
spec:
  sourceRepos:
    - https://github.com/example/deploy.git
  destinations:
    - server: https://kubernetes.default.svc
      namespace: payments
  clusterResourceWhitelist: []      # no cluster-scoped resources
  namespaceResourceBlacklist:
    - group: ""
      kind: ResourceQuota

The weak answer leaves every team in the default project, which allows any repo, any destination and any kind.

The strong answer explains why the project matters even with strict RBAC: RBAC controls who can create an Application, and the project controls what that Application can do once it exists.

A team allowed to create Applications in an open project can deploy a ClusterRoleBinding and escalate.

9. App of apps or ApplicationSet: when do you use each?

App of apps is a parent Application whose source directory contains child Application manifests. ApplicationSet is a controller that generates Applications from a template and a generator.

Use app of apps when the set of children is small, hand-written and different from each other, such as a cluster bootstrap with cert-manager, ingress and monitoring.

Use an ApplicationSet when the children follow a pattern: one app per cluster, per directory or per pull request.

Tradeoffs a senior candidate brings up:

  • App of apps children are plain manifests, so each can carry its own sync options and waves. Sync waves on child Applications order the bootstrap.
  • ApplicationSets remove copy-paste but put a lot of power in one template. A bad generator change can delete many Applications at once (question 12).
  • Creating an ApplicationSet is close to admin access in Argo CD, because the template can name any project. The docs limit ApplicationSets outside the argocd namespace for that reason.

10. Which ApplicationSet generators exist, and how would you deploy every app directory to every prod cluster?

The generators docs list ten: List, Cluster, Git, Matrix, Merge, SCM Provider, Pull Request, Cluster Decision Resource, Plugin and OCI.

Directory-per-app times cluster-per-environment is a Matrix of a Git directory generator and a Cluster generator:

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: prod-apps
  namespace: argocd
spec:
  goTemplate: true
  goTemplateOptions: ["missingkey=error"]
  generators:
    - matrix:
        generators:
          - git:
              repoURL: https://github.com/example/deploy.git
              revision: main
              directories:
                - path: apps/*/overlays/prod
          - clusters:
              selector:
                matchLabels:
                  env: prod
  template:
    metadata:
      name: '{{index .path.segments 1}}-{{.name}}'
    spec:
      project: platform
      source:
        repoURL: https://github.com/example/deploy.git
        targetRevision: main
        path: '{{.path.path}}'
      destination:
        server: '{{.server}}'
        namespace: '{{index .path.segments 1}}'

Points to listen for: missingkey=error so a typo fails the ApplicationSet instead of rendering an empty string into a name or path; the Cluster generator reads the labels on cluster Secrets, so labeling a new cluster env: prod is the whole onboarding step; and the Pull Request generator gives preview environments per open PR, which need a cleanup story for closed PRs.

11. Find the bug: an ApplicationSet that fails to render.

spec:
  goTemplate: true
  generators:
    - list:
        elements:
          - cluster: dev
            url: https://dev.example.com
          - cluster: prod
            url: https://prod.example.com
  template:
    metadata:
      name: 'web-{{cluster}}'
    spec:
      project: web
      source:
        repoURL: https://github.com/example/deploy.git
        targetRevision: main
        path: apps/web/overlays/{{cluster}}
      destination:
        server: '{{url}}'
        namespace: web

The template uses the old fasttemplate syntax, {{cluster}}, while goTemplate: true switches the renderer to Go templates.

In a Go template, {{cluster}} calls a function named cluster, which does not exist, so the ApplicationSet reports a template error and generates nothing. The fix is {{.cluster}} and {{.url}}.

A strong candidate also adds goTemplateOptions: ["missingkey=error"] and points out that the unquoted path value happens to work because YAML treats it as a string, but a value starting with {{ must be quoted or YAML parses it as a mapping.

They should check the ApplicationSet's status conditions, not the controller logs alone, to see the error.

12. How do you stop an ApplicationSet change from deleting production?

By default the ApplicationSet controller creates, updates and deletes Applications to match the generator output, and a deleted Application with the resources finalizer deletes its workloads.

A renamed directory, a removed cluster label or a SCM provider API outage that returns an empty list can therefore remove live services.

Per the resource modification docs, the guards are:

  • syncPolicy.applicationsSync: create-only, create-update, create-delete or sync (the default). create-update stops the controller from deleting Applications. A controller-wide --policy flag overrides the per-ApplicationSet field, and per-ApplicationSet policies only take effect when policy override is enabled.
  • syncPolicy.preserveResourcesOnDeletion: true: deleting a generated Application leaves its child resources in the cluster.
  • Template changes: changing the generated name deletes the old Application and creates a new one, so a name template change is a delete of everything.

The docs also warn that create-only and create-update do not stop deletion when the ApplicationSet itself is deleted; that needs the resources finalizer on the ApplicationSet and background cascading deletion.

A candidate who has been burned by this will mention a dry-run of generator output in CI before merging changes to an ApplicationSet.

13. When would you use multiple sources or the Source Hydrator?

Multiple sources (spec.sources) solve the "public Helm chart plus our own values file" case. One source is the chart, another is a Git repo with ref: values, and the chart reads $values/... paths from it:

spec:
  sources:
    - repoURL: https://prometheus-community.github.io/helm-charts
      chart: prometheus
      targetRevision: 15.7.1
      helm:
        valueFiles:
          - $values/charts/prometheus/values.yaml
    - repoURL: https://git.example.com/org/value-files.git
      targetRevision: dev
      ref: values

The multiple sources docs warn against more than two or three entries, and when two sources produce the same object, the last one wins with a RepeatedResourceWarning.

The Source Hydrator, beta since 3.5.0 per the hydrator docs, renders the "dry" Helm or Kustomize source and commits the plain manifests to a branch (syncSource.targetBranch), which Argo CD then syncs.

Reviewers see the rendered diff in Git before it reaches the cluster, and a chart upgrade that changes 400 lines is visible as 400 lines.

It needs the commit server and hydrator.enabled: "true". Since 3.2 the sync path must be a subdirectory, and since 3.3 the hydrator records state in git notes and no longer cleans the application path, so stale files need their own cleanup.

Sync, Waves, Hooks and Drift

14. What is the difference between sync status and health status?

Sync status says whether live state matches Git: Synced, OutOfSync or Unknown. Health status says whether the resources work: Healthy, Progressing, Degraded, Suspended, Missing or Unknown. They are independent.

An Application can be Synced and Degraded, when the Deployment matches Git but its pods crash-loop, or OutOfSync and Healthy, when someone scaled a Deployment by hand and it is serving traffic.

Health comes from built-in checks for core kinds and from Lua health scripts for CRDs, either bundled or set in resource.customizations.health.<group>_<kind>.

A Deployment is Progressing until its rollout finishes; a paused Argo Rollout reports Suspended.

Two recent changes are good probes: since 3.0 per-resource health is no longer persisted in the Application CR by default, so scripts that parsed .status.resources[].health broke, and since 3.4 an Application shows Missing only when all of its resources are missing.

15. How do sync waves order a sync?

Set the argocd.argoproj.io/sync-wave annotation to an integer.

Per the sync waves docs, resources default to wave 0, waves can be negative, and within a sync Argo CD sorts by phase, then wave (lowest first), then kind (namespaces, then other Kubernetes kinds, then custom resources), then name.

Argo CD applies the first wave that contains an out-of-sync or unhealthy resource, waits for that wave to become healthy, then moves on.

A 2-second delay between waves, set by ARGOCD_SYNC_WAVE_DELAY, gives other controllers time to update status so Argo CD does not read a stale "healthy" object.

# wave -1: the CRD and the namespace-scoped config the app needs
metadata:
  annotations:
    argocd.argoproj.io/sync-wave: "-1"

The consequence a strong candidate names: a resource that never becomes healthy blocks every later wave, so a missing custom health check for a CRD in wave 0 can stall the whole Application. Waves work only inside one Application.

Ordering across Applications needs an app of apps with waves on the child Application objects, or an ApplicationSet progressive sync.

16. Which resource hooks exist, and how are they cleaned up?

Hooks are resources, usually Jobs, annotated with argocd.argoproj.io/hook. The phases are PreSync, Sync, PostSync, SyncFail, PreDelete, PostDelete and Skip.

PreSync runs before any manifest is applied, PostSync runs once all resources are healthy, SyncFail runs when a sync fails, and PreDelete and PostDelete run around Application deletion. PreDelete hooks arrived in 3.3.0.

Cleanup is set by argocd.argoproj.io/hook-delete-policy:

  • HookSucceeded: delete after it succeeds.
  • HookFailed: delete after it fails.
  • BeforeHookCreation: delete the old instance before creating the new one. This is the default when no policy is set.

Hooks also take sync waves, so two PreSync Jobs can run in order.

Helm chart hooks map onto Argo CD hooks, for example helm.sh/hook: pre-install becomes PreSync, but Argo CD does not distinguish install from upgrade, so a chart that relies on a post-install-only hook runs it on every sync.

A candidate who has run database migrations as hooks will say the migration must be safe to run twice.

17. Find the bug: a migration Job that breaks the second deploy.

apiVersion: batch/v1
kind: Job
metadata:
  name: db-migrate
  annotations:
    argocd.argoproj.io/sync-wave: "-1"
spec:
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: migrate
          image: registry.example.com/payments:1.42.0
          args: ["migrate", "up"]

The first sync works. When the next release bumps the image tag, the sync fails with a "field is immutable" error, because a Job's pod template cannot be changed after creation, and the Job is a normal resource that Argo CD tries to patch.

Even when it does not fail, a completed Job that stays in the cluster does not run again.

The fix is to make it a hook: add argocd.argoproj.io/hook: PreSync so it runs before the Deployment changes, and rely on the default BeforeHookCreation policy, or set it explicitly, so the old Job is deleted before the new one is created.

Some teams add HookSucceeded too, and keep failed Jobs for their logs.

A strong candidate also asks what happens when the migration succeeds and the new Deployment then fails health: the schema has moved forward while the old pods keep running, so migrations must be backward compatible with the previous release.

18. What do prune and selfHeal do, and what are the risks of each?

Both are off by default under spec.syncPolicy.automated.

Per the automated sync docs, prune: true deletes live resources that were removed from Git, selfHeal: true re-syncs when the live state drifts, after a default 5-second wait (--self-heal-timeout-seconds), and allowEmpty: true permits a prune that leaves the Application with no resources.

Automated sync runs once per commit SHA and parameter set, and a failed sync is not retried against the same pair unless a retry policy is set.

The risks are what make this a senior question:

  • Prune plus a wrong path or a Kustomize overlay that renders nothing deletes the app; that is why allowEmpty defaults to false.
  • Self-heal fights any other controller that writes the same field, such as an HPA on replicas or a mutating webhook (question 19).
  • Self-heal also reverts the on-call engineer's emergency kubectl fix within seconds, so incident runbooks need a step to disable auto-sync.
  • Rollback through Argo CD is blocked while automated sync is on; the rollback is a Git revert.

Individual resources can opt out of pruning with argocd.argoproj.io/sync-options: Prune=false, which suits PersistentVolumeClaims and namespaces.

19. Find the bug: an HPA and Argo CD fighting over replicas.

spec:
  ignoreDifferences:
    - group: apps
      kind: Deployment
      jsonPointers:
        - /spec/replicas
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

The Deployment manifest in Git sets replicas: 3, and an HPA scales it to 12 under load. The Application now stays Synced, which looks correct.

But the next sync triggered by any other change, an image bump for example, applies the whole manifest, including replicas: 3, and the service drops to three pods at peak.

ignoreDifferences only changes the comparison. To make the sync skip the field too, add the RespectIgnoreDifferences=true sync option.

The cleaner fix is to remove replicas from the manifest so there is nothing to apply, which Kubernetes recommends anyway when an HPA owns scaling.

A strong candidate mentions jqPathExpressions for fields inside lists, and the system-level resource.customizations.ignoreDifferences in argocd-cm for patterns such as webhook-injected CA bundles.

Argo CD 3.6 also accepts an ignore-differences annotation on individual resources.

20. Which sync options do you reach for, and why?

Sync options go in spec.syncPolicy.syncOptions for the whole Application, or in the argocd.argoproj.io/sync-options annotation for one resource. The ones that come up in production:

  • ServerSideApply=true: applies with Kubernetes server-side apply. It handles objects too large for the last-applied-configuration annotation, such as big CRDs; the 3.3 ApplicationSet CRD needed it (question 29). Since 3.6 it also turns on Server-Side Diff.
  • CreateNamespace=true: creates the destination namespace if missing.
  • PruneLast=true: prunes after all other waves are healthy, so the old ConfigMap survives until new pods are up.
  • ApplyOutOfSyncOnly=true: applies only changed resources, which cuts sync time for Applications with thousands of objects.
  • Replace=true: uses kubectl replace or create instead of apply; a last resort.
  • FailOnSharedResource=true: fails the sync if another Application already tracks the resource.

A strong answer pairs each option with the failure it fixes.

21. How do ApplicationSet progressive syncs roll a change across clusters?

The RollingSync strategy syncs generated Applications in steps selected by labels, waiting for each step to become healthy before the next.

Per the progressive syncs docs, the feature is beta since 3.3.0 and off by default; enable it with applicationsetcontroller.enable.progressive.syncs: "true" in argocd-cmd-params-cm.

spec:
  strategy:
    type: RollingSync
    rollingSync:
      steps:
        - matchExpressions:
            - key: env
              operator: In
              values: [staging]
        - matchExpressions:
            - key: env
              operator: In
              values: [prod]
          maxUpdate: 25%
    deletionOrder: Reverse

Details that separate candidates: RollingSync forces automated sync off on the generated Applications, because the controller has to decide when each one syncs; Applications that match no step are never synced by the rollout; maxUpdate defaults to 100% of the step; and deletionOrder: Reverse (added in 3.2) removes prod before staging when the ApplicationSet shrinks.

In 3.6 the controller also refreshes all owned Applications and waits for them to reconcile before progressing, which can slow large sets.

Access Control and SSO

22. How does Argo CD RBAC work?

Policies are Casbin CSV lines in the argocd-rbac-cm ConfigMap. Per the RBAC docs, a p line grants or denies (p, <subject>, <resource>, <action>, <object>, <effect>) and a g line maps a user or SSO group to a role.

For Application-scoped resources the object is <project>/<app>, and a deny beats any matching allow.

policy.default: role:readonly
scopes: '[groups]'
policy.csv: |
  p, role:payments-dev, applications, get, payments/*, allow
  p, role:payments-dev, applications, sync, payments/*, allow
  p, role:payments-dev, logs, get, payments/*, allow
  g, example-org:payments, role:payments-dev

Resources include applications, applicationsets, clusters, projects, repositories, accounts, certificates, gpgkeys, logs, exec and extensions.

Applications take get, create, update, delete, sync, rollback, action and override. override lets a user sync with local parameter overrides, which bypasses Git, so it belongs only to admins.

Since 3.6, rollback can be a separate permission, enabled with server.rbac.rollback.enforce.enable; until then rollback checks sync.

The built-in roles are role:readonly and role:admin, and setting policy.default to role:readonly lets every logged-in user see every Application, which some companies do not want.

23. Find the bug: developers cannot restart their pods after the upgrade to 3.x.

p, role:payments-dev, applications, get, payments/*, allow
p, role:payments-dev, applications, sync, payments/*, allow
p, role:payments-dev, applications, update, payments/*, allow
p, role:payments-dev, applications, delete, payments/*, allow

Under Argo CD 2.x these lines let developers delete pods and edit live resources inside their Applications. Argo CD 3.0 disabled fine-grained RBAC inheritance: update and delete now apply to the Application object only.

The developers can delete the whole Application, which they should not, and cannot delete a pod, which they need.

The fix grants the sub-resource actions and drops the Application-level delete:

p, role:payments-dev, applications, delete/*/Pod/*/*, payments/*, allow
p, role:payments-dev, applications, action/apps/Deployment/*/*, payments/*, allow

The RBAC docs point out that globs do not treat / as a separator, so the sub-resource string needs all four parts (group, kind, namespace, name) to avoid matching more than intended.

The action grant covers the built-in "restart" resource action. Setting server.rbac.disableApplicationFineGrainedRBACInheritance: "false" restores the 2.x behavior, and a senior candidate will say that is a stopgap.

The same release made log access require an explicit logs, get grant, another common ticket after upgrades.

24. How do you set up SSO, and what changed with Dex in 3.0?

Two routes: the bundled Dex, configured under dex.config in argocd-cm with connectors such as GitHub, LDAP or SAML, or a direct OIDC provider under oidc.config, such as Okta, Entra ID or Keycloak.

Direct OIDC removes a component; Dex helps when the identity source is not an OIDC provider. Group claims then feed the g lines in RBAC, through the scopes setting.

Version-specific details a current candidate should know:

  • Since 3.0, RBAC subjects for Dex logins come from the federated_claims.user_id claim (requested with the federated:id scope) instead of sub, so user-level policy lines written for 2.x stopped matching.
  • Since 3.1, the server handles the OIDC authorization code flow with or without PKCE, and /auth/callback must be in the client's redirect URIs.
  • 3.3 added background OIDC token refresh, which stops the random logouts users saw with short-lived tokens.

Disable the built-in admin account (admin.enabled: "false") once SSO works, and give CI a project role token or a local account with a narrow policy instead of a person's credentials.

Multi-Cluster, Scale and Rollouts

25. How does Argo CD manage multiple clusters, and when do you run more than one Argo CD?

Each remote cluster is a Secret in the Argo CD namespace labeled argocd.argoproj.io/secret-type: cluster, with name, server and a config JSON holding a bearer token, TLS client config or a cloud auth block such as awsAuthConfig for EKS IAM roles. argocd cluster add creates a ServiceAccount in the target cluster and writes this Secret; declarative setups write it directly, usually from Terraform or External Secrets.

See our Terraform interview guide for the provisioning side.

The design tradeoff:

  • One hub controlling many clusters: one UI and one RBAC model, but the hub holds credentials to every cluster and is a single point of failure for deployments.
  • One Argo CD per cluster: smaller blast radius and no cross-cluster credentials, but more instances to upgrade and no single view.
  • Regional hubs are the usual compromise at a few dozen clusters.

Since 3.0, setting cluster.inClusterEnabled: "false" turns off the in-cluster destination; existing in-cluster Applications go Unknown, which is a useful hardening step on a hub that should only manage remote clusters.

The hub must also reach each cluster's API server, which matters for private clusters.

26. Argo CD slows down at 2,000 Applications. What do you tune?

Find the bottleneck first: repo server manifest generation, controller reconciliation, or the API server and UI. The HA docs give the levers:

  • Controller sharding: raise the argocd-application-controller replicas and set ARGOCD_CONTROLLER_REPLICAS to match. Clusters are split across shards with controller.sharding.algorithm: legacy, or the experimental round-robin and consistent-hashing. One huge cluster still lands on one shard.
  • Processors: --status-processors (default 20) and --operation-processors (default 10) set how many Applications reconcile and sync in parallel.
  • Repo server: more replicas, --parallelismlimit to cap concurrent manifest generations and avoid OOM kills, and a higher ARGOCD_EXEC_TIMEOUT (default 90 seconds) for slow Helm charts.
  • Git load: webhooks instead of short polling, shallow clones (added in 3.3) for big repos, and the manifest-paths annotation so a commit only refreshes Applications whose paths changed.
  • Noise: 3.0's default resource.exclusions and ignoreResourceUpdates already drop high-churn kinds such as Endpoints, EndpointSlice and Lease; check whether a 2.x config file overrode them.

A strong candidate reads the argocd_app_reconcile metric before changing settings.

27. How does Argo Rollouts relate to Argo CD?

They are separate projects that work together. Argo CD decides what should be in the cluster; Argo Rollouts decides how a new version replaces the old one.

Rollouts adds a Rollout CRD that replaces a Deployment and supports canary and blue-green strategies, traffic shifting through an ingress controller or service mesh, and AnalysisTemplate resources that query Prometheus, Datadog or a Job to promote or abort automatically.

The current release is Argo Rollouts 1.10.2 (November 4, 2026), with 1.11.0 in release candidate.

apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: payments
spec:
  replicas: 10
  strategy:
    canary:
      steps:
        - setWeight: 10
        - pause: {duration: 10m}
        - analysis:
            templates:
              - templateName: error-rate
        - setWeight: 50
        - pause: {}          # wait for manual promotion

Argo CD ships a health check for Rollouts: a Rollout paused at a step reports Suspended, so the Application shows Suspended rather than Healthy, and resource actions such as resume, abort, retry and promote-full appear in the UI.

The interaction to probe: a new image committed to Git mid-canary starts a fresh rollout toward the new version, and anyone who promotes or changes the Rollout by hand needs to know that self-heal compares the live object with Git.

Rollouts 1.10.1 also changed the dashboard to bind only to localhost by default, so setups exposing it need --address 0.0.0.0.

What Changed Recently

May 6, 2025
Argo CD 3.0: annotation tracking, fine-grained RBAC, logs RBAC on by default
Aug 13, 2025
Argo CD 3.1: OCI sources (beta), CLI plugins, PKCE-agnostic OIDC flow
Nov 4, 2025
Argo CD 3.2: CronJob health, ordered deletion for progressive syncs
Feb 2, 2026
Argo CD 3.3: PreDelete hooks, shallow clones, OIDC token refresh
May 5, 2026
Argo CD 3.4: full cluster versions, Missing health only when all resources are missing
Aug 4, 2026
Argo CD 3.5: Helm 4, Source Integrity, impersonation for all API operations, hydrator beta
Nov 3, 2026
Argo CD 3.6: Server-Side Diff with SSA, rollback RBAC, resources explorer; 3.6.1 followed a day later

28. What changed by default in Argo CD 3.0?

3.0 was a defaults release more than a features release. Per the upgrade notes, the changes that bite:

  • Annotation-based tracking instead of the instance label (question 4).
  • Fine-grained RBAC: update and delete no longer cover managed resources (question 23), and log viewing needs logs, get.
  • Status ignored in diffs: ignoreResourceStatusField moved from crd to all, and a default ignoreResourceUpdates drops .status churn.
  • Default exclusions for high-churn kinds such as Endpoints, EndpointSlice, Lease and several Kyverno and Cilium kinds.
  • Removed: legacy repository config in argocd-cm (use repository Secrets), the applyNestedSelectors field, and the argocd_app_sync_status, argocd_app_health_status and argocd_app_created_time metrics, whose data moved to labels on argocd_app_info.
  • Helm 3.17.1, where a null in a subchart's values.yaml now overrides the resulting value.

Ask which of these broke something in the candidate's own upgrade; removed metrics and RBAC tickets are the common answers.

29. What did 3.3 through 3.5 change that a platform engineer must handle?

Each release has one or two items that change upgrade procedure or behavior:

  • 3.3: the ApplicationSet CRD grew past the client-side apply size limit, so upgrades need server-side apply (ServerSideApply=true when Argo CD manages itself, or kubectl apply --server-side --force-conflicts); Helm upgrades are unaffected. It also added PreDelete hooks, opt-in shallow clones and KEDA pause actions, and moved progressive syncs to beta.
  • 3.4: cluster versions are stored as vMajor.Minor.Patch, so ApplicationSets that selected on the old auto-label move to argocd.argoproj.io/kubernetes-version; Missing health now means all resources are missing; bundled Dex 2.45.0.
  • 3.5: Helm 4 renders charts and helm.version: v3 is ignored; plain-HTTP OCI registries need insecureOCIForceHttp; impersonation through destinationServiceAccounts now covers all API server operations, not only sync; GnuPG verification gave way to Source Integrity; the Source Hydrator became beta.

The 3.4 to 3.5 notes also flag a React 19 UI upgrade that breaks UI extensions which do not externalize react/jsx-runtime. A candidate who maintains a UI extension or a CMP should know about it.

30. What is new in Argo CD 3.6?

3.6.0 shipped on November 3, 2026, and 3.6.1 on November 4. The items that affect day-to-day work:

  • Server-Side Diff by default with SSA: ServerSideApply=true now implies Server-Side Diff, and Structured-Merge Diff is removed. Opt out with the argocd.argoproj.io/compare-options: ServerSideDiff=false annotation. Expect more API server load and validating webhooks running during diff.
  • A separate rollback permission in RBAC (question 22).
  • An ignore-differences annotation on individual resources.
  • UI: lazy loading, virtual scrolling for large app lists and a resources explorer view.
  • Alpha features: signing of hydrated commits and redirecting login straight to a chosen Dex connector.
  • Tracing: OpenTelemetry spans with a parent-based sampler and --otlp-sample-ratio; ARGOCD_REPO_OTLP_HEADERS was renamed to ARGOCD_REPO_SERVER_OTLP_HEADERS, and otlp.insecure now fully controls TLS.

Also, argocd app diff --local --server-side-generate now includes *.tpl and Chart.lock by default, and passing --local-include replaces the defaults instead of adding to them, which can quietly change diffs in CI scripts.

31. How do you upgrade Argo CD safely across several minor versions?

One minor at a time, reading each upgrade guide, with a staging Argo CD that manages a copy of real Applications.

Argo CD supports the three most recent minor lines; the 3.3.19 release on November 2, 2026 closed the 3.3 series and points users to 3.4.13, 3.5.7 or 3.6.0. A team still on 3.3 is out of support for security fixes.

The checklist a strong candidate gives:

  • Diff the bundled tool versions (Helm, Kustomize) and render every chart with the new ones before the upgrade, since 3.5 moved to Helm 4.
  • Check custom health checks, resource customizations and RBAC lines against each release's default changes.
  • Upgrade with server-side apply when the CRDs require it, and keep Argo CD managing itself through an Application pinned to an exact version.
  • Watch reconciliation and sync duration metrics after each step, and keep the previous manifests ready for rollback.

Signs of a Strong Answer

  • They separate sync status from health status and can say which one a given symptom changes.
  • They name what happens to live workloads before they approve a prune, a finalizer change or an ApplicationSet template edit.
  • They keep secrets out of the repo server and can explain how a rotated secret reaches the pods.
  • They scope teams with AppProjects as well as RBAC, and know the sub-resource syntax that 3.0 requires.
  • They exclude fields owned by other controllers from both the diff and the sync, not only the diff.
  • They upgrade one minor at a time and can name the 3.x default changes that broke something for them.

Hiring Argo CD Engineers

Engineers who have run Argo CD across many clusters, recovered from a bad ApplicationSet change and upgraded through the 3.x defaults are hard to find from a resume keyword.

The platform engineer and site reliability engineer role guides cover the jobs, and our Kubernetes, Docker and DevOps coding guides cover the layers underneath.

Second Talent helps US startups hire vetted AI-Native Engineers from Asia, at $23 to $39 USD an hour billed monthly, with matches in 24 hours and a 90-day one-time replacement guarantee.

See Kubernetes engineers and DevOps engineers for hire, or tell us what you need.

Get developers who ship with AI agents.

Starts at $23/Hour.

Start Hiring

$0 cost until you hire