Jenkins to GitHub Actions Migration Checklist: Plugins, Credentials and Runners
DevOps / SRE Engineer & CEO, Cloud DevOps Solutions
Most Jenkins migrations go wrong in the same places: plugins nobody remembered, credentials that were never inventoried, agents with special software, and a cutover with no rollback. This checklist walks through the migration in phases so those items are found early. For syntax-level conversions, see how to migrate from Jenkins to GitHub Actions. For a staged plan with a parallel run, see our migration plan.
This is a checklist, not a guarantee. Adapt it to your environment, and treat every item as a question to answer rather than a box to tick.
Phase 1: Inventory
You cannot migrate what you have not listed.
- List every Jenkins job: pipelines, freestyle jobs, multibranch folders and scheduled jobs.
- Mark which jobs ran in the last 90 days. Retire the rest instead of migrating them.
- Record each job’s trigger: webhook, polling, cron, upstream job or manual.
- Identify the owner of each job. Unowned jobs are the ones that break silently.
- List Shared Libraries, with the repositories and versions that use them.
- Record downstream effects: deployments, artefact publishing, notifications, tickets and status checks.
- Note which jobs are on the critical path for releases and hotfixes.
Phase 2: Plugins
Jenkins plugins hide dependencies. Export the installed plugin list, then for each plugin that a job actually uses:
- Find the GitHub Actions equivalent, a CLI you can call, or an API.
- Mark plugins with no equivalent and decide how to replace the behaviour.
- Check plugin-provided build parameters, input prompts and approval gates.
- Review plugins that add post-build behaviour: notifications, test report publishing, coverage and static analysis.
- Identify Docker, Kubernetes and cloud plugins and note which authentication they used.
- Check third-party actions you plan to use. Pin them to a commit SHA, and review who maintains them.
Unused plugins are a good sign that the old controller can be retired entirely, and a source of risk until it is.
Phase 3: Pipeline logic
Declarative pipelines convert more directly than scripted ones.
- Separate declarative from scripted pipelines. Scripted Groovy with loops, closures or dynamic stages needs redesign, not translation.
- Map stages to jobs and steps. Use
needsfor sequencing, and run independent stages in parallel. - Rewrite conditional stages with
ifexpressions, and check how they handle branches and tags. - Replace workspace sharing with artefacts or caches, because each job starts clean.
- Check job time limits, since long-running jobs may need to be split.
- Review concurrency: Jenkins queues and executors do not map one to one to concurrency groups.
- Convert Shared Libraries into reusable workflows or composite actions.
- Preserve test report, coverage and artefact behaviour that other teams depend on.
Phase 4: Credentials and secrets
Credentials are the most common cause of delay and the most serious source of risk.
- Export a list of credential IDs and the jobs that reference each one.
- Classify each as a username and password, token, SSH key, certificate, file or cloud credential.
- Decide the scope for each secret: organisation, repository or environment.
- Prefer short-lived credentials through OpenID Connect to your cloud provider instead of copying long-lived keys.
- Rotate credentials that were stored in Jenkins when you move them. Do not copy secrets from an old system without considering who had access.
- Configure environment protection rules and required reviewers for production deployments.
- Handle multiline secrets and files carefully, since encoding rules differ.
- Check logs for accidental secret exposure during testing.
- Define who can change secrets and workflows, and use branch protection and CODEOWNERS on workflow files.
Phase 5: Agents and runners
- List agent labels and what each label guarantees: operating system, tools, network access, GPUs or licences.
- Decide for each label whether GitHub-hosted runners are enough or you need self-hosted runners.
- For self-hosted runners, decide on the isolation model. Prefer ephemeral runners, and be cautious about running untrusted pull request code on persistent machines.
- Define how runners are built, patched and scaled.
- Check network paths to internal systems, artefact stores and private registries.
- Reproduce special tool versions with setup actions, container jobs or prebuilt images.
- Estimate minutes and concurrency, so you do not meet limits or surprise bills after cutover.
Phase 6: Testing and parallel run
- Build workflows on a branch and trigger them from pull requests.
- Compare outputs between Jenkins and Actions: artefacts, test results, image digests and deployed versions.
- Run both systems in parallel for an agreed period, long enough to include a release and a hotfix if possible.
- Make only one system authoritative for deployments, so you never deploy twice.
- Record differences in build time and failure rate. Investigate flaky tests that behave differently.
- Update required status checks in branch protection, and make sure the new check names exist before you require them.
Phase 7: Cutover and rollback
- Choose a low-risk window and communicate it to all teams.
- Migrate in waves, starting with low-risk services.
- Define the rollback in advance: how to re-enable the Jenkins job, who decides, and how long it remains available.
- Check that deployment tooling, release notes, tickets and chat notifications still work.
- Watch for scheduled jobs that do not fire, and for webhooks still pointing at Jenkins.
- Keep Jenkins read-only for a defined period so build history can still be consulted.
Phase 8: Decommissioning
- Confirm that no job has run on Jenkins for the agreed period.
- Archive build history and artefacts that you must keep for audit or compliance.
- Revoke Jenkins credentials, tokens and service accounts.
- Remove webhooks, firewall rules, DNS entries and agent images.
- Shut down the controller and agents, and cancel related licences.
- Document the new pipeline standards, runner operations and ownership.
Common traps
- Hard-coded paths and hostnames inside scripts that assume a Jenkins workspace.
- Implicit environment variables such as
BUILD_NUMBERorGIT_COMMIT, which have different names in Actions. - Credentials shared across unrelated jobs, which you now have to separate.
- Unreviewed third-party actions with write access to your repositories and secrets.
- Cost surprises from long builds, large matrices or macOS and Windows runners.
- No owner for workflows after the migrating engineers move on.
When migrating may not be the right call
If your pipelines depend on deep Jenkins-specific integrations, heavy on-premises hardware or air-gapped networks, GitHub Actions may need self-hosted infrastructure that removes much of the benefit. If your code is not on GitHub, a different platform may fit better. And if Jenkins works and is maintained, the migration effort has to be justified by something concrete such as security posture, maintenance load or developer experience. We will tell you if staying put is the better answer. See our Jenkins migration approach or contact us to talk it through.
Related service
Need hands-on help? Our certified engineers deliver this as a managed service.
CI/CD Pipeline Services