# Core Features of Argo CD: A Complete Guide to GitOps Continuous Delivery

> Explore Argo CD core features including declarative GitOps, automated sync engines, health monitoring, and RBAC for seamless Kubernetes continuous delivery. Master your deployments.

- Repository: [Argo Project/argo-cd](https://github.com/argoproj/argo-cd)
- Tags: deep-dive
- Published: 2026-07-14

---

**Argo CD is a declarative GitOps continuous delivery platform for Kubernetes that automates application deployment through Application custom resources, automated sync engines, health monitoring, and enterprise-grade RBAC controls.**

Argo CD, maintained in the `argoproj/argo-cd` repository, provides a comprehensive GitOps workflow for Kubernetes by combining declarative configuration management with automated reconciliation. Understanding the core features of Argo CD enables platform engineers to implement robust continuous delivery pipelines that maintain cluster state through version-controlled manifests.

## Declarative Application Management

At the heart of Argo CD lies the **Application Custom Resource (CR)**, defined in [`pkg/apis/application/v1alpha1/application_types.go`](https://github.com/argoproj/argo-cd/blob/main/pkg/apis/application/v1alpha1/application_types.go). This CR serves as the declarative description of a set of Kubernetes manifests stored in Git, Helm repositories, or Kustomize directories.

The Application spec defines:
- **Source**: Repository URL, path, and target revision
- **Destination**: Target cluster and namespace via `spec.destination.server`
- **Sync Policy**: Automation rules for deployment

```yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: guestbook
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/argoproj/argocd-example-apps.git
    targetRevision: HEAD
    path: guestbook
  destination:
    server: https://kubernetes.default.svc
    namespace: guestbook
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

```

## Automated GitOps Synchronization

The **GitOps sync engine** ensures drift-free reconciliation between desired and actual cluster states. Implemented in [`pkg/application/controller/application_controller.go`](https://github.com/argoproj/argo-cd/blob/main/pkg/application/controller/application_controller.go), the controller continuously watches declared sources and computes the desired state.

### Sync Policy Options

Argo CD supports sophisticated sync behaviors through `spec.syncPolicy` configuration, documented in [`docs/user-guide/sync-options.md`](https://github.com/argoproj/argo-cd/blob/main/docs/user-guide/sync-options.md):

- **Prune**: Automatically remove resources not present in Git
- **Self-Heal**: Correct drift when cluster state deviates from source
- **Automated**: Enable automatic synchronization without manual approval

## Multi-Cluster and Multi-Tenancy Support

Argo CD manages applications across multiple clusters from a single control plane. Destination clusters are referenced via `spec.destination.server` and can be added using `argocd cluster add`, as detailed in [`docs/user-guide/tracking_strategies.md`](https://github.com/argoproj/argo-cd/blob/main/docs/user-guide/tracking_strategies.md).

### RBAC and Project Isolation

Enterprise deployments rely on the **AppProject** CR ([`pkg/apis/application/v1alpha1/appproject_types.go`](https://github.com/argoproj/argo-cd/blob/main/pkg/apis/application/v1alpha1/appproject_types.go)) for fine-grained access control. The controller enforces these policies through [`controller/project_controller.go`](https://github.com/argoproj/argo-cd/blob/main/controller/project_controller.go), enabling multi-tenancy by restricting which users can deploy to specific namespaces or clusters. See [`docs/user-guide/projects.md`](https://github.com/argoproj/argo-cd/blob/main/docs/user-guide/projects.md) for implementation details.

## Health Assessment and Lifecycle Hooks

### Resource Health Monitoring

Argo CD evaluates per-resource health through hooks defined in [`resource/custom_health.go`](https://github.com/argoproj/argo-cd/blob/main/resource/custom_health.go). Health status is surfaced in the UI and through status badges documented in [`docs/user-guide/status-badge.md`](https://github.com/argoproj/argo-cd/blob/main/docs/user-guide/status-badge.md).

### Deployment Hooks and Sync Waves

Lifecycle hooks enable pre-sync, post-sync, pre-delete, and post-delete operations. Defined in Application manifests and executed as Kubernetes Jobs, these hooks are covered in [`docs/user-guide/sync-waves.md`](https://github.com/argoproj/argo-cd/blob/main/docs/user-guide/sync-waves.md).

```yaml
spec:
  hooks:
  - name: cleanup-db
    type: PreDelete
    command: ["/bin/sh", "-c"]
    args: ["./cleanup.sh"]

```

### Sync Windows

Time-based controls prevent synchronization during maintenance windows. This feature is documented in [`docs/user-guide/sync_windows.md`](https://github.com/argoproj/argo-cd/blob/main/docs/user-guide/sync_windows.md), allowing administrators to define when sync operations may execute.

## Scalability Features

### ApplicationSet

The **ApplicationSet** feature enables dynamic generation of multiple Applications from a single template, supporting "GitOps at scale" through cluster generators, directory generators, and pull-request generators. Documentation resides in [`docs/user-guide/application-set.md`](https://github.com/argoproj/argo-cd/blob/main/docs/user-guide/application-set.md).

### Source Hydration (Beta)

The source-hydrator pattern pushes hydrated manifests back to Git before applying to the cluster, documented in [`docs/user-guide/source-hydrator.md`](https://github.com/argoproj/argo-cd/blob/main/docs/user-guide/source-hydrator.md).

## Configuration Overrides

Argo CD supports runtime parameter modifications without altering source repositories. The `parameters` and `ignoreDifferences` fields allow deployment-time customization, as described in [`docs/user-guide/parameters.md`](https://github.com/argoproj/argo-cd/blob/main/docs/user-guide/parameters.md).

## Management Interfaces

### Web Dashboard

The React-based UI, bootstrapped in [`ui/src/app.tsx`](https://github.com/argoproj/argo-cd/blob/main/ui/src/app.tsx), provides visual management of Applications, resource health, and synchronization status.

### Command-Line Interface

The `argocd` CLI binary, with its entry point at [`cmd/argocd/main.go`](https://github.com/argoproj/argo-cd/blob/main/cmd/argocd/main.go), enables scriptable interactions for CI/CD pipelines:

```bash
argocd app list

```

Apply applications using standard Kubernetes tooling:

```bash
kubectl apply -f guestbook-app.yaml

```

## Summary

- **Declarative Management**: The Application CR ([`pkg/apis/application/v1alpha1/application_types.go`](https://github.com/argoproj/argo-cd/blob/main/pkg/apis/application/v1alpha1/application_types.go)) defines desired state from Git sources
- **Automated Sync**: The controller ([`pkg/application/controller/application_controller.go`](https://github.com/argoproj/argo-cd/blob/main/pkg/application/controller/application_controller.go)) continuously reconciles cluster state
- **Enterprise Security**: RBAC via AppProject ([`pkg/apis/application/v1alpha1/appproject_types.go`](https://github.com/argoproj/argo-cd/blob/main/pkg/apis/application/v1alpha1/appproject_types.go)) enables multi-tenancy
- **Advanced Controls**: Sync windows, hooks ([`docs/user-guide/sync-waves.md`](https://github.com/argoproj/argo-cd/blob/main/docs/user-guide/sync-waves.md)), and health checks provide deployment governance
- **Scalability**: ApplicationSet and multi-cluster support manage thousands of applications across environments
- **Interfaces**: React UI ([`ui/src/app.tsx`](https://github.com/argoproj/argo-cd/blob/main/ui/src/app.tsx)) and CLI ([`cmd/argocd/main.go`](https://github.com/argoproj/argo-cd/blob/main/cmd/argocd/main.go)) offer flexible management options

## Frequently Asked Questions

### What is the primary function of the Application CR in Argo CD?

The Application Custom Resource serves as the central declaration of what Argo CD should deploy, where it should deploy it, and how it should synchronize changes. Defined in [`pkg/apis/application/v1alpha1/application_types.go`](https://github.com/argoproj/argo-cd/blob/main/pkg/apis/application/v1alpha1/application_types.go), it specifies the Git source, target cluster destination via `spec.destination.server`, and sync policies that govern the deployment behavior.

### How does Argo CD handle configuration drift in Kubernetes clusters?

Argo CD employs a continuous reconciliation loop implemented in [`pkg/application/controller/application_controller.go`](https://github.com/argoproj/argo-cd/blob/main/pkg/application/controller/application_controller.go) that detects when the actual cluster state diverges from the desired state declared in Git. When `selfHeal` is enabled in the sync policy, the controller automatically re-applies the source configuration to restore the declared state.

### What is the difference between an Application and an ApplicationSet in Argo CD?

An Application represents a single deployable unit managing manifests for one environment, while an ApplicationSet is a template that dynamically generates multiple Application resources across multiple clusters or namespaces. ApplicationSets enable "GitOps at scale" by automating the creation of Applications from cluster lists, Git directories, or pull request generators as documented in [`docs/user-guide/application-set.md`](https://github.com/argoproj/argo-cd/blob/main/docs/user-guide/application-set.md).

### How does Argo CD restrict deployment permissions across teams?

Argo CD implements RBAC through the AppProject Custom Resource ([`pkg/apis/application/v1alpha1/appproject_types.go`](https://github.com/argoproj/argo-cd/blob/main/pkg/apis/application/v1alpha1/appproject_types.go)), which defines which source repositories, destinations, and clusters a group of Applications may access. The project controller ([`controller/project_controller.go`](https://github.com/argoproj/argo-cd/blob/main/controller/project_controller.go)) enforces these restrictions, allowing platform teams to isolate resources by team, environment, or compliance boundary.