Helm: another operation (install/upgrade/rollback) is in progress
Helm 3 stores the lock inside the release secret. Read the pending status, roll back to the last good revision, or clear the record deliberately.

Introduction & Quick Summary
Error: UPGRADE FAILED: another operation (install/upgrade/rollback) is in progress is Helm refusing to start because the release's recorded status is still pending-install, pending-upgrade or pending-rollback. Helm 3 has no lock server and no lease: the release Secret is the lock. If a previous operation did not write a final status, every later operation sees a release that looks busy and stops.
The status usually got stuck for one of these reasons:
- The previous command was interrupted.
Ctrl+Conhelm upgrade --wait, a cancelled CI job, or an evicted runner leaves the pending record behind. - A pre-upgrade hook never finished. A
Jobthat waits for a database that is not reachable keeps Helm inside the upgrade until the timeout expires. - Two pipelines ran at once. A push to
mainand a manual redeploy overlapped, and the second one started before the first wrote its status. - The timeout was shorter than the rollout.
--timeoutdefaults to five minutes; a slow image pull plus a readiness gate easily exceeds it.
| Status shown | What it means | Safe next action |
|---|---|---|
pending-install | A first install never completed | Fix the cause, then uninstall or delete the pending secret |
pending-upgrade | An upgrade was interrupted | Roll back to the last good revision, or clear the record |
pending-rollback | A rollback was interrupted | Roll back again after clearing, or to another revision |
failed | The operation finished and failed | helm rollback, not a delete |
deployed | Healthy | Nothing to do |
Core Mechanics, Signatures & Reproducible Setup
Every Helm 3 release is stored as a Secret named sh.helm.release.v1.<release>.v<revision> in the release namespace, labelled owner=helm. The payload is the release object, gzipped and base64-encoded, with a status field. helm upgrade reads the latest revision, refuses if its status is pending, and only writes deployed or failed when it finishes.
That design explains two behaviours people find surprising. First, the "lock" is per release name and namespace, so two releases in different namespaces never block each other. Second, deleting a pod or restarting the cluster does not clear a pending status, because there is no process to notice: the record stays until something writes over it.
A reproducible stuck release needs only a hook that sleeps longer than the timeout:
# templates/hook.yaml
apiVersion: batch/v1
kind: Job
metadata:
name: migrate
annotations:
"helm.sh/hook": pre-upgrade
"helm.sh/hook-delete-policy": before-hook-creation
spec:
template:
spec:
restartPolicy: Never
containers:
- name: migrate
image: yourorg/migrate:1.4.0
command: ["sh", "-c", "sleep 900 && ./migrate"]Then:
helm upgrade api ./charts/api -n apps --wait --timeout 2mError: UPGRADE FAILED: another operation (install/upgrade/rollback) is in progressThe next run fails immediately, before contacting the cluster, because the status from the previous run is still pending-upgrade.
Key Comparison Table
Clearing the state has three routes with different consequences, and picking the wrong one loses history or leaves resources orphaned.
| Route | Command | Keeps history | Use when |
|---|---|---|---|
| Roll back | helm rollback api <rev> -n apps | Yes, new revision | An earlier revision is known good |
| Delete pending secret | kubectl delete secret sh.helm.release.v1.api.v7 -n apps | Yes, minus that revision | The pending revision is garbage |
| Uninstall | helm uninstall api -n apps | Removed | Reinstalling from scratch is acceptable |
The lifecycle that produces a pending status in practice, compared with a healthy one:
| Situation | Status while running | Status after success | Status after interruption |
|---|---|---|---|
| First install | pending-install | deployed | Stays pending-install |
| Upgrade | pending-upgrade | deployed | Stays pending-upgrade |
| Rollback | pending-rollback | deployed | Stays pending-rollback |
Upgrade with --atomic | pending-upgrade | deployed | Rolls back automatically |
Practical Edge Cases, Error Fixes & Deep Dive Code Examples
Read the release before touching it
Two commands answer almost every case. helm status shows the current status and the last description, and helm history shows every revision with its status, which tells you which revision to roll back to.
helm status api -n apps
helm history api -n apps --max 10
kubectl get secret -n apps -l owner=helm,name=api \
--sort-by=.metadata.creationTimestampThe secret list is the ground truth: the highest v<N> is the pending revision, and its metadata.creationTimestamp tells you when the interrupted run happened. A pending revision from three weeks ago is stale; one from two minutes ago may still have a running hook.
Roll back instead of deleting
If the last deployed revision is healthy, a rollback writes a new revision with status deployed and clears the pending one. Helm allows this even while the release is pending, which is why it is the preferred first attempt.
helm rollback api 6 -n apps --wait --timeout 5m
helm history api -n apps --max 5REVISION STATUS DESCRIPTION
8 deployed Rollback to 6
7 pending-upgrade Upgrade "api" failed: context canceled
6 superseded Upgrade completeIf helm rollback also reports "another operation in progress", the pending revision cannot be superseded, and deleting the secret is the next step.
Clear a pending revision deliberately
Deleting the pending release secret removes the lock. Helm then continues from the last deployed revision, so the next upgrade works normally. Do it only when no Helm process is actually running: check kubectl get pods -n apps for a hook Job still executing, and helm list -n apps --all for the release.
kubectl delete secret sh.helm.release.v1.api.v7 -n apps
helm list -n apps # status should be deployed (revision 6)
helm upgrade api ./charts/api -n apps --wait --timeout 5mNever delete the whole sh.helm.release.v1.api.* set: that erases the release history and makes Helm treat the release as unmanaged while its resources still exist.
Stop creating the problem: atomic upgrades and CI concurrency
--atomic makes a failed upgrade roll itself back, so an interrupted rollout does not leave the release pending, and --timeout should be set from the rollout's real duration rather than the default.
helm upgrade --install api ./charts/api -n apps \
--atomic --wait --timeout 10m --history-max 10On the pipeline side, serialise the job per environment so two runs cannot overlap:
concurrency:
group: helm-${{ github.ref_name }}
cancel-in-progress: falsecancel-in-progress: true is the wrong choice here: cancelling mid-upgrade is one of the ways a release ends up pending in the first place.
When the hook itself is the lock
A pre-upgrade hook that never completes keeps the release pending, and no amount of clearing helps until the hook is fixed. Find it, then give it a deadline:
spec:
backoffLimit: 1
activeDeadlineSeconds: 300and make Helm remove it on the next attempt with "helm.sh/hook-delete-policy": before-hook-creation,hook-succeeded. Without the second policy, a completed Job stays and the next upgrade waits on it in some Helm versions.
Common Compilation/Runtime Mistakes & Version Gotchas
Running helm uninstall as the first reaction. It deletes the workloads and keeps the release record, so the reinstall starts from pending-install again. Roll back or clear the pending secret first, unless a full teardown is what you actually want.
Assuming a cluster restart clears the status. It does not; the pending status lives in the Secret. Check helm history after a node failure instead of retrying the same command.
Using --force. --force replaces resources via delete-and-recreate and is not a lock workaround. It can leave pods down and still hit the pending check.
Confusing the namespace. The release secret, the hook Job and the workloads can live in different namespaces. helm status without -n looks in the current context's namespace, which is where the "release not found" and "another operation" errors get mixed up.
Ignoring --wait semantics. Without --wait, Helm returns as soon as the API accepts the objects, so a failed rollout looks successful and the release is deployed while pods crash. With --wait, a slow rollout can exceed the timeout and leave pending-upgrade. Neither default is right for every chart; set both explicitly.
Version behaviour. Helm 3 introduced the Secret-based release storage; Helm 2 stored releases in ConfigMaps under Tiller, where the message was different. The pending-* statuses, --atomic and --history-max all behave as described on Helm 3.x.
The pending status is a record of an unfinished transaction, so the question to answer first is always whether that transaction is still running. When you edit values or hook manifests, the YAML validator catches the indentation errors that make a hook hang silently, and the Base64 encoder helps inspect a release Secret's gzipped payload.
Official references: helm rollback and helm upgrade.
Official references
primary documentationThe Kubernetes documentation that defines the behaviour this guide explains.
Try matching browser tools
All toolsSmall utilities that fit Kubernetes work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Kubernetes guides
All Kubernetes guidesKubernetes 1.35: kubelet will not start on a cgroup v1 node
A 1.35 kubelet refuses a cgroup v1 host, and the removed pod-infra flag stops custom images. Check the kernel command line before the node pool.
Kubernetes Multi-Attach error: the volume is still attached elsewhere
One claim, two nodes. Find the current holder, clear a stale attachment after a node failure, and give the volume a single writer.
Helm upgrade failed: field is immutable on Service and Job
Some fields cannot be patched at all. Here is which ones, why --force does not help, and the safe recreate procedure for Services, Jobs and StatefulSets.
Kubernetes: Pod stuck in Terminating (finalizers and grace periods)
A pod disappears only when finalizers clear and containers stop. Read deletionTimestamp, find the blocker, and force-delete only a dead node.
More in Kubernetes
All Kubernetes guidesThe guides filed next to this one in Kubernetes, in library order.