GitHub removed Node 20 from GitHub Actions runners on 23 September 2026. JavaScript actions now run on Node 24, and the temporary ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION opt-out is no longer available. Action maintainers must publish releases whose metadata uses runs.using: node24; workflow owners must move to compatible releases.

That sounds like a dependency update. For QA, it is a delivery-system migration. The application can still pass every unit test while checkout, report upload, caching, signing, or deployment fails before or after those tests. The objective is therefore broader than “make CI green”: preserve the evidence and controls the pipeline provides.

1. Establish the confirmed change

Separate vendor facts from your test hypotheses.

Confirmed by GitHub:

Do not convert those facts into invented rules such as a permanent minimum runner version. GitHub updates runner requirements over time. For self-hosted runners, check the current official documentation and release information during each migration.

One subtle but important point: a shell step that runs node -v reports the Node executable available on PATH. It does not prove which embedded runtime executed a JavaScript action. Evidence about the action runtime must come from the action metadata, runner diagnostics, annotations, or instrumentation inside the action itself.

2. Map the real impact surface

Begin with a repository-wide inventory rather than waiting for failing jobs.

Review:

  1. Every uses: reference in .github/workflows/*.yml and .yaml.
  2. Local actions under paths such as .github/actions/.
  3. Reusable workflows called with workflow_call.
  4. Composite actions and any JavaScript actions they invoke.
  5. Actions used only in release, scheduled, or manual workflows.
  6. Self-hosted runner labels, operating systems, architectures, and update policy.

For each external action, record the exact reference, the upstream release that adds Node 24 support, its source repository, and the evidence used to approve it. A moving major tag is convenient, but it is not immutable. GitHub’s secure-use guidance states that a full-length commit SHA is the immutable way to pin an action. If your team uses a tag for maintenance reasons, document that trade-off and verify what commit the tag resolves to.

Do not assume that updating the workflow’s own application setup solves the problem. For example, changing a setup-node input affects the Node version used by later shell commands. It does not rewrite another action’s action.yml.

3. Build a risk-based migration matrix

Prioritize the pipeline by consequence, not by file order.

Pipeline areaFailure modeIndependent evidence
Source checkoutRepository or submodules are incompleteExpected commit SHA and file sentinel exist
Dependency cacheStale or unreadable cache produces misleading resultsCold-cache and warm-cache runs have equivalent test outcomes
Test executionTests pass under a different environment than expectedRuntime, OS, architecture, and dependency manifest recorded
Report uploadTests finish but evidence is missingArtifact exists, opens, and matches the run ID
Release/signingCredentials or native dependencies fail lateNon-production canary produces a verifiable signed test artifact
DeploymentAn action succeeds but the target state is wrongRead-back check against the target environment
NotificationsFailure is invisible to the ownerDeliberate test failure creates the expected alert

Run this matrix across every runner class you actually use. Do not add macOS or ARM runners merely to make the matrix look complete; test the supported environments in your own fleet.

4. Guidance for action maintainers

A JavaScript action needs more than a one-line metadata edit.

The metadata must declare Node 24:

runs:
  using: node24
  main: dist/index.js

Then rebuild the committed distribution bundle using the project’s documented toolchain, run unit tests, and execute the action in a dedicated workflow. Validate its inputs, outputs, error paths, file operations, network calls, and post-action cleanup. Native modules deserve additional attention because their compatibility may depend on operating system and architecture.

Publish a new release only after the generated dist content and action.yml are consistent. Consumers should never have to guess whether an existing tag silently changed.

5. Guidance for workflow consumers

For each referenced action:

Avoid “fixing” the migration by switching every action to @main. That trades a visible runtime problem for uncontrolled supply-chain drift.

A useful canary executes the same business-relevant operation as production but targets disposable data. A checkout canary should verify the checked-out SHA. An upload canary should download and open the uploaded artifact. A deployment canary should publish to a non-production target and read the state back.

6. Prove the embedded runtime correctly

Maintainers of a local JavaScript action can create a temporary diagnostic action:

# .github/actions/runtime-probe/action.yml
name: Runtime probe
runs:
  using: node24
  main: index.js
// .github/actions/runtime-probe/index.js
console.log(JSON.stringify({
  node: process.version,
  platform: process.platform,
  arch: process.arch
}));

Call that local action from each relevant runner class and retain the log as migration evidence. This proves the runtime used by that JavaScript action. A separate run: node -v step remains useful for application commands, but it answers a different question.

For third-party actions that cannot expose their runtime directly, use the upstream metadata plus the runner’s annotations and an end-to-end check of the action’s observable result.

7. Treat self-hosted runners as a product

GitHub-hosted runners are refreshed by GitHub. Self-hosted runners add owner responsibilities.

By default, the self-hosted runner application updates itself. If automatic updates are disabled, GitHub requires regular updates; current documentation says a runner must be updated within 30 days of a new release, and critical security updates can stop job queueing until installed.

Your runner test should therefore cover:

For the Node 24 migration specifically, identify macOS 13.4-or-earlier and ARM32 hosts. The safe response is to upgrade or move the job to a supported runner—not to restore the removed Node 20 escape hatch.

8. Test failure handling and recovery

Do not create a negative test that deliberately runs an obsolete production dependency. Instead, inject controlled failures into the canary:

Verify the status, error message, retained evidence, cleanup, retry policy, and notification.

After Node 20 removal, “roll back to the Node 20 action” is not a reliable recovery plan. Recovery is a forward fix: move to a compatible release, patch and test a controlled fork, or temporarily replace the affected step with a supported implementation. Record the decision owner and expiry date for every temporary fork.

9. Five questions every reviewer should ask

  1. Which workflows and local actions were actually inventoried, including scheduled and reusable workflows?
  2. What evidence proves that each selected action release supports Node 24?
  3. Which result verifies the action’s real side effect, rather than merely its exit code?
  4. Are any self-hosted runners on unsupported operating systems or architectures, or outside their update window?
  5. If a third-party action fails, what tested forward-fix path preserves the required control?

10. Where automation helps

Automation can continuously scan workflow and action files, reject runs.using: node20, flag unapproved action references, and compare the inventory with an allowlist. Scheduled checks can report runner versions and stale self-hosted images. Canary workflows can exercise critical actions against disposable targets and store evidence.

Automation should not automatically approve a new third-party release. A human still needs to assess ownership, release notes, permissions, changed behavior, and the adequacy of the canary result.

Pre-merge checklist

Conclusion

A runtime retirement is a change to the test and delivery system itself. The safest migration combines an exact dependency inventory, current vendor evidence, risk-based canaries, verification of real side effects, and an explicit forward-fix path. Green tests matter, but only a tested pipeline can show that those green results were produced, preserved, and delivered reliably.

Sources