Why Your Kubernetes Pod Is Stuck in Pending (and How to Fix It)
A Pending pod means the scheduler couldn't place it or the node couldn't start it. Here's how to read the events and clear the eight causes we hit most.
Key takeaways
- A Pending pod has been accepted by Kubernetes but not started, usually because the scheduler cannot find a node that fits.
- Run kubectl describe pod and read the FailedScheduling event, which names the cause per node: insufficient CPU or memory, untolerated taints, unmatched affinity, or an unbound PersistentVolumeClaim.
- Fix that exact cause.
On this page
A pod stuck in Pending has been accepted by Kubernetes but not started, almost always because the scheduler can't find a node that fits it. Run kubectl describe pod <name> and read the FailedScheduling event at the bottom: it names the cause per node (insufficient CPU or memory, a taint, affinity, an unbound PVC). Fix that exact cause.
Verified against
Kubernetes 1.37 (latest stable v1.37.2), against the kubernetes.io debug-pods, resource management, taints and tolerations, and resource quota docs. Checked October 2026.
Pending splits into two very different situations. Either the scheduler looked at every node and refused to place the pod anywhere, or the scheduler already picked a node and the kubelet on that node hasn't been able to start the containers yet. Those are separate problems with separate fixes, and the first thing you do is figure out which one you're looking at.
The good news: the pod already told you why. People burn an hour guessing at cluster capacity when the answer is sitting in the pod's event log. So before anything else, describe it.
Describe the pod and read the reason
$ kubectl describe pod checkout-api-7d9f8b6c4-x2ktp
Scroll to the bottom, to Events. The scheduler writes a FailedScheduling event with a per-node breakdown, and that breakdown names the cause. Here's a typical one from a cluster that ran out of room (the exact wording shifts a little between Kubernetes versions):
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Warning FailedScheduling 2m14s default-scheduler 0/6 nodes are available: 3 Insufficient cpu, 3 Insufficient memory. preemption: 0/6 nodes are available: 6 No preemption victims found.
Read that literally. Six nodes, none usable, and it tells you the split: three couldn't fit the CPU request, three couldn't fit the memory request. If the Events section is empty and the pod already shows a node assignment (Node: ip-10-0-3-14), you're in the second situation. That's a kubelet problem (an image pull, a volume that won't attach), and you go look at that node instead.
Below are the causes we actually hit, roughly in order of frequency.
Insufficient CPU or memory on any node
The example above. Every node has less allocatable CPU or memory than your pod requests. You have three fixes and you should pick the right one, not the loud one.
Lower the request if it's inflated. A common version of "we need bigger nodes" is a pod asking for 4 CPU when it uses 400m. Check actual usage with kubectl top pod before you scale anything.
# deployment.yaml (container spec excerpt)
resources:
requests:
cpu: 500m
memory: 512Mi
If the request is honest and the cluster is genuinely full, add capacity. With Cluster Autoscaler or Karpenter installed, an unschedulable Pending pod is the trigger, and a new node joins once the cloud provider boots it. Without an autoscaler, you're scaling the node group by hand. Our take: run an autoscaler, and size requests from real usage, as in right-sizing resource requests. A pod stuck Pending because a human hasn't noticed the node group is full is an avoidable page.
A request larger than any single node
Related but nastier: no node is big enough, full stop. A request of memory: 64Gi on a fleet of 32Gi nodes will never schedule, and no amount of autoscaling the count fixes it because scaling adds more of the same small node. The event looks identical to plain insufficiency. The tell is that scaling out doesn't help. Fix the request or add a node type that can hold it.
Taints without a matching toleration
Nodes get tainted to repel pods: GPU nodes, spot nodes, control-plane nodes. If your pod has no matching toleration, the scheduler skips those nodes:
0/4 nodes are available: 4 node(s) had untolerated taint {dedicated: gpu}.
Either add the toleration or stop targeting tainted nodes:
# deployment.yaml (pod spec excerpt)
tolerations:
- key: dedicated
operator: Equal
value: gpu
effect: NoSchedule
Node affinity or nodeSelector matches nothing
A nodeSelector or nodeAffinity rule that no node satisfies produces:
0/8 nodes are available: 8 node(s) didn't match Pod's node affinity/selector.
Usually a typo or a stale label. You asked for disktype: ssd and the nodes are labeled disk-type: ssd, or the label got dropped in a node-pool rebuild. Check kubectl get nodes --show-labels and reconcile. The scheduler-side messages for taints, affinity and resources are dissected one by one in the FailedScheduling guide.
Pod anti-affinity with nowhere left to go
Anti-affinity that requires one replica per node runs out of nodes once replicas equal nodes. The message reads node(s) didn't match pod anti-affinity rules. This one bites during scale-ups: you bump replicas past your node count and the extras sit Pending forever. Either add nodes or loosen requiredDuringScheduling to preferred.
Unbound PersistentVolumeClaim
A pod that mounts a PVC won't schedule until that claim binds. Describe the PVC, not just the pod:
Warning ProvisioningFailed storageclass.storage.k8s.io "fast-ssd" not found
Common variants: the StorageClass name is wrong, there's no default StorageClass and the PVC didn't name one, or the volume's zone is pinned and the schedulable nodes are in a different zone. That last one is sneaky on regional clusters. The volume lives in us-east-1a, every node with room is in 1b, and neither the pod nor the PVC event spells it out plainly.
ResourceQuota blocking the namespace (the pod that never appears)
This one is not technically Pending, and that is what makes it confusing. Per the Kubernetes docs, a request that would violate a ResourceQuota is rejected by the API server with 403 Forbidden, so the pod is never created. With a Deployment you see the ReplicaSet stuck short of its replica count and a FailedCreate event mentioning exceeded quota. Inspect the quota:
$ kubectl get events -n payments --field-selector reason=FailedCreate
$ kubectl describe resourcequota -n payments
Resource Used Hard
-------- ---- ----
requests.cpu 19500m 20
requests.memory 38Gi 40Gi
The cluster has room, the namespace doesn't. Raise the quota or free it up by cleaning out dead workloads. This one confuses people because every node looks healthy: capacity here is a namespace-level accounting limit, not a hardware one.
No nodes at all, or all nodes NotReady
Sometimes the humble answer is right: there are zero schedulable nodes. A node group scaled to zero, every node cordoned during maintenance, or the whole pool NotReady after a bad kubelet rollout. kubectl get nodes tells you in one line. If nodes are NotReady, the pod problem is a symptom and you go fix the nodes.
Questions people ask
How long can a pod stay in Pending?
Indefinitely. Kubernetes has no timeout for scheduling: the pod stays Pending and the scheduler keeps retrying until something changes, such as a node joining, another pod freeing resources, or you editing the spec. A Deployment rollout may report a progress-deadline failure after progressDeadlineSeconds (600 by default), but the Pending pod itself is not deleted. Read the events instead of waiting.
Why is my pod Pending with no events?
If kubectl describe pod shows no FailedScheduling events and a Node: is assigned, the scheduler is done and the kubelet is stuck, usually pulling an image or attaching a volume, so check that node. If no node is assigned and there are no events, check that the scheduler is running, that schedulerName in the pod spec names a scheduler that exists, and that events have not simply expired (about an hour by default).
Does Pending mean the cluster is out of resources?
Only sometimes. Insufficient CPU or memory is the most common cause, but taints, node affinity, anti-affinity, unbound PersistentVolumeClaims and zone mismatches produce the same Pending status on a cluster with plenty of free capacity. The FailedScheduling message states which reason applies to each node, so read it before adding nodes.
The call we'd make
Describe first, always. The scheduler's FailedScheduling message is not vague, it enumerates every node and the exact reason each was rejected, and nine times out of ten the fix is written into that text. Guessing at capacity before reading the events is how a five-minute fix turns into an afternoon. Build the reflex: pod stuck, kubectl describe, read the last event, act on what it literally says. If Pending shows up a lot under load, that's your cue to run an autoscaler and set honest resource requests, not to keep hand-scaling node groups at 2am. For the wider picture, our Kubernetes troubleshooting guide covers the failure modes beyond scheduling.
Sources
Cite this article
Kiril Urbonas (2026). Why Your Kubernetes Pod Is Stuck in Pending (and How to Fix It). DevOpsNess. Updated 2026-10-31. https://www.devopsness.com/blog/fix-pod-pending
[Why Your Kubernetes Pod Is Stuck in Pending (and How to Fix It)](https://www.devopsness.com/blog/fix-pod-pending) (Kiril Urbonas, DevOpsNess, updated 2026-10-31)
More from DevOps
Explore more articles in this category
kaniko CVE-2026-105769: Lookalike ACR Hosts Get Your Azure Token. Rebuild on v1.25.20
A FROM line pointing at a host like x.azurecr.io.attacker.com is enough to make kaniko hand the build's Entra ID token to that host. Which kaniko forks and images are affected, how to find Azure identities in your build pods, and what to rotate.
Sign Container Images With Cosign: Keyless GitHub Actions Workflow, SBOM and In-Cluster Checks
One workflow that builds, signs keylessly with GitHub OIDC, attaches an SBOM and SLSA provenance, plus the Kyverno policy that refuses anything unsigned. Copy it, change three names, ship it.
GitLab CVE-2026-110264: A Second CVSS 10 RCE in Nine Days. Patch to 19.5.1
An unauthenticated regex-compiler RCE reaching back to GitLab 7.0, no workaround, and backports on older branches that fix only the critical bug. The exact version per branch and the commands to get there.
You might have missed
Evergreen posts worth revisiting.