> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Configure Node Pool scheduling priority

> Set the relative order in which your Node Pools receive available capacity

Node Pool scheduling priority controls which of your Node Pools receives available capacity first when multiple pools have outstanding requests. Set `spec.schedulingPriority.value` to prioritize a small dedicated pool while a larger pool continues to request capacity.

In CoreWeave Kubernetes Service (CKS), the priority applies to Node allocation to Node Pools. To control how Pods are placed on Nodes, see [Workload scheduling on CKS](https://docs.coreweave.com/products/cks/clusters/scheduling/workload-scheduling.md).

Priorities apply within your organization when the following match:

* Instance type
* Availability Zone
* Network fabric
* Compute class

Node Pools in different clusters can compete within that scope. Reserved, On-Demand, and Spot capacity rules and CoreWeave scheduling rules still take precedence.

## Prerequisites

Confirm that you have the following:

* Existing [Node Pools](https://docs.coreweave.com/products/cks/nodes/create.md) whose allocation order you want to control.
* [Cluster access](https://docs.coreweave.com/products/cks/auth-access/managed-auth/kubeconfig.md) with permission to read and update those Node Pools.
* `kubectl` installed and configured for each cluster that contains a competing Node Pool.

## Choose priority values

Higher values give a Node Pool higher priority. Values are signed 32-bit integers. An unset priority is treated as `0`. Use a positive value to prioritize a pool over the default, or a negative value to give it lower priority. For otherwise equivalent requests, equal values use first-in, first-out (FIFO) order based on when capacity was requested.

For example, for otherwise equivalent requests, these values prioritize a dedicated pool ahead of a development pool and a larger general-purpose pool:

| Node Pool purpose | Priority | Relative order |
| - | - | - |
| Dedicated team capacity | `200` | First |
| Development capacity | `100` | Second |
| General-purpose capacity | `0` or unset | Third |

The values express order, not queue positions or capacity shares. A value of `200` doesn't allocate twice as many Nodes as `100`.

Once a higher-priority pool's outstanding demand is satisfied, lower-priority pools can receive capacity. If the higher-priority pool continually requests more Nodes, lower-priority pools can wait indefinitely. Priority doesn't guarantee capacity or a delivery time, so coordinate values across all competing pools, including those in other clusters.

## Set or change scheduling priority

Update each Node Pool through the workflow that manages its configuration:

1. Open the Node Pool's configuration:

   * If you manage the Node Pool with GitOps, open its source manifest.
   * Otherwise, open the Node Pool in your editor. Replace `CONTEXT_NAME` with the Kubernetes context for its cluster and `NODE_POOL_NAME` with its name:

     ```bash theme={"system"}
     kubectl --context="CONTEXT_NAME" edit nodepool "NODE_POOL_NAME"
     ```

   > [!NOTE]
   >
   > You can also update the Node Pool's YAML in the [Cloud Console](https://console.coreweave.com).

2. Under `spec`, add `schedulingPriority` or change its existing `value`. This manifest excerpt sets the priority to `200`:

   ```yaml theme={"system"}
   spec:
     schedulingPriority:
       value: 200
   ```

3. Apply the change through your configuration workflow:

   * For GitOps, commit the source-manifest change and sync it through your usual deployment workflow.
   * If you used `kubectl edit`, save the change and exit the editor.

4. Repeat for the other Node Pools, using the appropriate cluster context and priority for each.

CKS applies priority changes to outstanding allocation requests when it next evaluates their order. You don't need to change the pool's target size to update its priority. Priority changes don't move Nodes already assigned to your Node Pools.

### Restore the default priority

To restore the default priority, set `spec.schedulingPriority.value` to `0` or remove `spec.schedulingPriority` from the configuration.

For the field's type and supported range, see [Scheduling priority](https://docs.coreweave.com/products/cks/reference/node-pool.md#scheduling-priority).

## Check the configuration

To inspect configured priorities in a cluster, replace `CONTEXT_NAME` with its Kubernetes context and run:

```bash theme={"system"}
kubectl --context="CONTEXT_NAME" get nodepools \
  -o custom-columns='NAME:.metadata.name,PRIORITY:.spec.schedulingPriority.value,QUEUED:.status.queuedNodes,CURRENT:.status.currentNodes'
```

Confirm that each updated pool's `PRIORITY` matches the value you chose. A pool with no `schedulingPriority` field displays `<none>` in the `PRIORITY` column and is treated as priority `0`. Repeat the command for each cluster that contains competing Node Pools.

This output shows configured values and Node counts, not the allocation queue's order or positions. `QUEUED` is the number of Nodes waiting for assignment, and `CURRENT` is the number present in the cluster. These remain Node counts for rack-based pools. Use the separate rack counts when comparing against `targetRacks`.

If a pool continues to wait, review the priorities of your other competing pools and check its capacity and quota conditions. For condition meanings, rack counts, and troubleshooting steps, see [Node Pool status](https://docs.coreweave.com/products/cks/nodes/nodepool-status.md).
