skip to content

In Argo CD, an Application reports both a sync status and a health status. What does each one tell you, and what values can each take?

level: juniorimportance: must knowfreq 78%

answer

  1. two statuses, not one
  2. one compares, the other assesses
  3. Synced says applied, not working
  4. Degraded, Progressing, Suspended, Missing, Unknown
  5. worst resource decides the Application

basics

~20 s

Argo CD tracks two independent axes. Sync status compares live cluster objects with the manifests at the target Git revision (Synced, OutOfSync). Health status judges whether those objects actually work (Healthy, Progressing, Degraded, Suspended, Missing, Unknown).

solid answer

~40 s

They answer two different questions. **Sync status** is a diff result: Argo CD renders the manifests at the Application's `targetRevision` and compares them to the live objects in the cluster, reporting `Synced` when they match and `OutOfSync` when they do not. **Health status** is an assessment of the running objects themselves — Argo CD runs a per-kind health check (built-in for common Kubernetes kinds, Lua-scriptable for others) and reports `Healthy`, `Progressing`, `Degraded`, `Suspended`, `Missing` or `Unknown`. The Application's overall health rolls up its resources, with the worst status winning. The pair matters because they move independently: `Synced` + `Degraded` is the classic case — Argo CD applied exactly what Git said, and what Git said is broken. `Synced` alone never means the software works.

go deeper

for a junior

Be able to name both statuses and say plainly that one compares the cluster with Git while the other reports whether the running resources work. Knowing the value lists (Synced/OutOfSync; Healthy/Progressing/Degraded) is enough here.

for a middle

Explain where each verdict comes from: the rendered-manifest diff for sync, and a per-kind health check reading the object's status subresource for health. Be ready to read the Synced-plus-Degraded combination correctly.

for a senior

Show you have operated this: health is an aggregate over the resource tree, custom kinds default to Healthy without a registered check, and nothing rolls back automatically. Say what you actually do when an Application goes Degraded in production.

for a principal

Own the consequence for delivery design: if Healthy is only "the objects report well", your promotion gates need a real signal — smoke tests, analysis against SLIs, or a controller that can abort — rather than treating a green Argo CD tile as proof a release succeeded.

## Two axes, not one Every Argo CD Application carries two separate verdicts, and confusing them is the single most common misunderstanding in ArgoCD interviews. - **Sync status** answers *"does the cluster match Git?"* - **Health status** answers *"is what is running actually working?"* They are computed by different machinery, they change at different times, and neither implies the other. ## Sync status Argo CD periodically fetches the Application's source (a Git repo path, a Helm chart, an OCI artifact) at `targetRevision`, renders it into plain Kubernetes manifests, and diffs that desired state against the live objects it reads from the destination cluster. The result is one of: - `Synced` — every declared object matches its rendered manifest. - `OutOfSync` — at least one object differs, is missing, or (with pruning visible) exists in the cluster but not in Git. - `Unknown` — the comparison could not be made, for example the repo could not be fetched. Sync status is about **intent delivery only**. A manifest that applies cleanly and then crash-loops is still perfectly `Synced`. ## Health status Health is assessed per resource. Argo CD ships health checks for the common built-in kinds and derives the verdict from the object's own `status` subresource — for a Deployment it looks at `status.observedGeneration`, the updated/available replica counts and the `Progressing` condition; for a Service of type `LoadBalancer` it looks for an assigned ingress address; for a Job it looks at completion. The possible values are: - `Healthy` — the resource reports itself as fully operational. - `Progressing` — it is not there yet, but it is still working on it (a rollout in flight). - `Degraded` — it failed: replicas never became available, the progress deadline was exceeded, a Job failed. - `Suspended` — deliberately paused or suspended, such as a suspended CronJob or a paused rollout. - `Missing` — declared in Git but not present in the cluster. - `Unknown` — the health check could not reach a verdict, or errored. Custom resources with no registered check are treated as `Healthy` by default, which is why a CRD-heavy Application can look green while its controller is still provisioning something. ## Rolling up to the Application The Application's health is an aggregate over the resources in its tree: any `Degraded` resource degrades the whole Application, and a `Progressing` resource keeps it `Progressing`. That aggregation is what a `Sync` operation with health checking waits on — the operation is not "done" the moment `kubectl apply` returns, it is done when the affected resources report healthy. ```bash argocd app get guestbook # Health Status: Degraded # Sync Status: Synced to main (9a64214) ``` ## The four combinations you should be able to read | Sync | Health | What happened | |------|--------|----------------| | Synced | Healthy | Steady state — the cluster matches Git and everything reports well. | | Synced | Progressing | Argo applied the new manifests and the rollout is still in flight. | | Synced | Degraded | **Argo did its job; the change is bad.** Git says X, X is running, X does not work. | | OutOfSync | Healthy | Something drifted or a new commit landed; the currently-running version is fine. | The third row is the production surprise the topic exists for. GitOps reconciliation guarantees convergence to the declared state — it makes no claim that the declared state is *good*. Argo CD does not automatically revert a `Degraded` Application; getting back to a working version means changing Git (or using a progressive-delivery controller that can abort on its own). ## Why interviewers ask Because the answer reveals whether a candidate treats the tool as a deployment button or as a reconciler. "It says Synced, so we shipped it" is a statement about YAML delivery. Knowing that health is a second, independently computed, per-kind assessment — and that it can be wrong or absent for custom kinds — is what separates someone who has operated Argo CD from someone who has clicked its UI.

  • Your Application is Synced and Degraded. Does Argo CD roll anything back for you?
    No. Argo CD converges the cluster toward Git; it has no notion of "the previous good version" to fall back to. Recovery means putting a working revision in Git (revert the commit, or sync the Application to an earlier revision), or delegating the abort decision to a progressive-delivery controller such as Argo Rollouts, which can shift traffic back to the stable ReplicaSet on its own.
  • Why can an Application show Healthy while users are getting errors?
    Health checks read the object's own reported status, not user experience. A Deployment whose pods pass their readiness checks reports Healthy even if every request returns HTTP 500. Custom resources with no registered health check default to Healthy outright. Health is a liveness-of-the-Kubernetes-object signal; correctness has to come from a smoke test or from real monitoring.
  • What does the Missing health status indicate, and how does it differ from OutOfSync?
    Missing means a resource declared in the Application's source has no live counterpart in the cluster — it is a health verdict on that one resource. OutOfSync is the Application-level diff verdict, and a missing resource is one of several things that can cause it. You can also be OutOfSync with everything present, when a live field simply differs from Git.

saying these in an interview costs you the question

  • Says Synced means the application is running correctly
  • Thinks Healthy just means the sync operation finished
  • Claims Argo CD auto-rolls-back when health turns Degraded
  • Assumes OutOfSync means the workload is broken
  • Believes health is only computed for Deployments

context