Skip to main content
Argo CD is a leading GitOps continuous delivery tool in the cloud-native ecosystem. The core idea is simple and powerful: declare the desired cluster state in Git, then let Argo CD continuously watch that repository and reconcile your Kubernetes cluster to match it. Any drift is detected and corrected automatically. This guide walks you through the Argo CD web UI to build a mental model of how Argo CD operates, and also demonstrates equivalent CLI checks. You will:
  • Inspect Argo CD controllers and pods.
  • Create Applications from a Git repo (manifest- and Helm-based).
  • Sync Applications, observe Argo CD applying manifests, and watch drift detection and reconciliation.
  • See how to enable Auto-Sync (self-heal) for Helm-based apps.

​
Prerequisite

Ensure Argo CD controllers are deployed and running in the argocd namespace:
Example output:
If you installed Argo CD using the official manifests, the default admin user is admin. The initial admin password is typically the name of the argocd-server pod (or a password you set). In this demo we used admin123 for convenience — replace that with your real initial password.
Access the Argo CD Web UI and sign in with your admin credentials.

​
Create a Manifest-Based Application (guestbook)

An Argo CD Application object connects a Git source to a destination cluster/namespace. We’ll create a manifest-based frontend application named web-frontend that points at the argoproj example repo.
  1. In the Argo CD UI click “New App”.
  2. Name: web-frontend.
  3. Project: default.
  4. Sync policy: choose Manual for an interactive demo.
  5. Source: set repository to https://github.com/argoproj/argocd-example-apps.git, revision HEAD, and path guestbook.
  6. Destination: use the in-cluster API server https://kubernetes.default.svc and namespace applications (Argo CD can also create this namespace for you).
Below is the repo folder we’ll use (guestbook):
A dark-mode GitHub repository page for argo/argocd-example-apps showing the guestbook folder and files (guestbook-ui-deployment.yaml, guestbook-ui-svc.yaml). The top shows a recent commit message "fix: invalid image for guestbook."
The Create Application form should look like this (repo, path, revision, destination):
A screenshot of the Argo CD web UI showing the "Create Application" form. It displays SOURCE fields (repo URL https://github.com/argoproj/argocd-example-apps.git, revision HEAD, path "guestbook") and DESTINATION fields (cluster URL https://kubernetes.default.svc).
Before creating the Application, ensure the applications namespace exists (or allow Argo CD to auto-create it). After creating the Application, it will appear in the Applications list. Initially it will be OutOfSync because the cluster does not yet have the resources defined in Git.
Screenshot of the Argo CD web UI showing the "Applications" view with a single "web-frontend" application card marked Missing / OutOfSync. The left sidebar shows navigation (Applications, Settings, Documentation) and the card includes details and action buttons for Sync, Refresh, and Delete.

​
Inspect and Sync the Application

Click the application to open the resource tree. The tree shows Service, Deployment, ReplicaSet and Pods that are declared in Git. Yellow / OutOfSync indicates the resources are missing or differ from the cluster. Click “Sync” → “Synchronize” to have Argo CD apply the manifests. Argo CD will create the namespace (if requested) and apply the resources. After syncing, Argo CD should report the application as Synced and Healthy. Verify cluster resources:
Example output:

​
Drift Detection and Reconciliation

Argo CD continuously compares the live cluster state with the desired state in Git. To demonstrate drift detection, make a manual change on the cluster: scale the guestbook-ui Deployment to 5 replicas.
Verify the cluster now shows 5 replicas:
Example output:
Click “Refresh” in the Argo CD UI — the application will move to OutOfSync. Click “Diff” to see the exact difference between live and desired states; the diff will show replicas: 5 on the cluster vs replicas: 1 in Git. To view resource status and the tree while OutOfSync:
A screenshot of the Argo CD web UI showing the "web-frontend" application details tree with resource boxes (service, deployment, replica set and multiple pods). Status panels at the top show sync and health information (OutOfSync / Sync OK) and a left sidebar lists filters and health/status counts.
Click “Sync” again to reconcile. Argo CD will apply the desired manifests and scale the Deployment back to 1 replica. Confirm on the cluster:
Example output after reconciliation:
Argo CD has self-healed the drift and the app is Synced and Healthy again.

​
Creating a Helm-Based Application

Argo CD supports multiple generators: raw manifests, Kustomize, Helm charts, and many more. As an example, create a backend application from a Helm chart in the same example repository. The repo contains a Helm chart for the guestbook:
A dark-mode GitHub repository page for "argoproj/argocd-example-apps" showing the helm-guestbook directory and a list of files and folders (e.g., templates, Chart.yaml, values.yaml).
Create a new Application in Argo CD:
  • Name: web-backend
  • Sync policy: enable Auto-Sync (self-heal), enable Prune Resources, and optionally Auto-Create Namespace.
  • Source: https://github.com/argoproj/argocd-example-apps.git
  • Path: applications-helm/guestbook (Argo CD auto-detects the chart as Helm)
  • Destination: same cluster, namespace applications-helm (or let Argo CD create it)
Argo CD’s UI exposes Helm values so you can override chart settings (for example set replicaCount: 2) before syncing the app.
A screenshot of the Argo CD web UI showing the application creation/settings panel for an app named "web-backend." The sync policy options (Enable Auto-Sync, Prune Resources, Self Heal, Auto-Create Namespace) are visible and checked, with a dark navigation sidebar on the left.
Once created, Argo CD will deploy the Helm chart and keep it reconciled automatically. The resource tree will display Service, Deployment, ReplicaSet and Pods for the Helm release:
A screenshot of the Argo CD web UI showing the "web-backend" application with status indicators (Healthy, Synced) and sync details at the top. Below is a visual resource tree/graph showing a service, deployment, replica set, and two running pods for the web-backend-helm-guestbook.
Verify pods on the cluster:
Example output:

​
Quick Reference: What an Argo CD Application Maps To

If you enable Auto-Sync with “Auto-Prune” and “Self Heal”, Argo CD will automatically remove resources not declared in Git and reconcile live state to match Git. Use these options only when your Git repo is the single source of truth.

​
Summary

In this walkthrough you learned how to:
  • Inspect Argo CD controllers and pods and log into the web UI.
  • Create Argo CD Applications from a Git repository (manifest-based).
  • Sync Applications and observe Argo CD applying manifests to the cluster.
  • Trigger drift manually and watch Argo CD detect and reconcile differences.
  • Create a Helm-based Application and enable Auto-Sync for self-healing.
You can perform similar operations using the Argo CD CLI (argocd) and automate these patterns in CI/CD pipelines or GitOps workflows.

Watch Video