Why does Jenkins→GitHub Actions often show STAY rather than GO?

Because a well-run Jenkins is genuinely cheap on per-minute compute (self-hosted runners cost $0.001-$0.002/min, vs GitHub Actions' $0.006/min for Linux after the January 2026 cut). The hosting overhead ($1,800-$2,500/mo for a typical Jenkins controller cluster) is the only meaningful cost. Once you factor 14-26 hours per pipeline to rewrite Jenkinsfile DSL into GitHub Actions YAML, payback periods often run 3-5+ years. The honest verdict is: if your Jenkins works, the migration is rarely cost-justified on compute alone. The cases where it does pay back are usually around developer experience, vendor risk, or specific feature requirements rather than pure run-rate.

Where do the per-pipeline migration hours come from?

Base of 14 hours per pipeline (mid-complexity), adjusted by complexity multiplier (simple 0.55x · typical 1.00x · complex 1.85x) and source-platform complexity (Jenkins 1.40x because Jenkinsfile DSL maps poorly to YAML-native platforms; GitLab CI 1.20x for similar reasons; GitHub Actions 0.90x because YAML-to-YAML is straightforward). Calibrated against published migration retrospectives from companies who have publicly shared their CI/CD migration data, plus our own pipeline complexity audit work.

Is the 2-month parallel-run period realistic?

It is the typical safe-migration period for a non-trivial number of pipelines. Hard cutovers (0 months) work for small teams with simple pipelines but carry meaningful risk if something behaves differently on the new platform. Larger teams with regulated workloads sometimes run 4-6 months in parallel. The calculator lets you set it to match your risk tolerance. Note that parallel-run is a sunk cost, you are paying the current platform during this period whether you ultimately complete the migration or not, so a long parallel-run period materially extends payback.

Why is the team-training component so small?

Because 4 hours per developer is enough for basic workflow fluency on a modern CI/CD platform. The deeper expertise (debugging, optimisation, advanced features) gets built up over months of daily use, that is on-the-job learning, not training time billable to the migration project. If your team needs more than 4 hours of formal training, that usually signals either (a) the new platform is genuinely more complex than the old one, or (b) the migration is being treated as a major rearchitecture rather than a like-for-like swap. Both warrant extra scope.

What is included in the $8,500 fixed setup cost?

Secrets and credentials migration, IdP/SSO setup, audit logging configuration, integration with downstream systems (artifact stores, deployment targets, monitoring), runner pool provisioning if self-hosted, and the initial documentation pass. The figure is calibrated for a mid-sized organisation (25-100 developers) on a stack with typical integrations. Very small teams (under 10 devs) often come in lower; large enterprises with strict compliance regimes can run $25K-$50K. The 20% risk buffer absorbs reasonable variation around the mid figure.

Migration economics

Switching CI/CD platforms
doesn't pay for itself by default.

Vendor pitch decks compare run-rate. They never include the engineering hours to rewrite 35-120 pipelines, the parallel-run period, the training overhead, or the inevitable risk buffer. This calculator stacks the migration cost honestly against the run-rate saving, and returns a verdict: GO NOW, GO IF STRATEGIC, STAY, or TARGET IS MORE EXPENSIVE.

switch configuration

From

Pipelines to migrate

Team size (developers)

Build minutes per month

Total minutes across all pipelines, including parallel job multiplication.

Pipeline complexity

Simple: ~8 hrs/pipeline. Typical: ~14 hrs. Complex (matrix builds, custom plugins, env-specific secrets): ~26 hrs.

Parallel-run period

0 mo2 months6 mo

How long you run both platforms in parallel during cutover. 0 = hard cutover; 2 = typical safe migration.

STAY

Migration cost erases the savings.

Either payback is too long or 3-year net is negative. The current platform is fine financially. Re-evaluate when usage doubles or pricing changes materially.

Migration cost

$105,228

one-time

Annual saving

$22,080

vs current

Payback period

4.8 yr

months at current saving

migration cost stack

Pipeline engineering · 35 pipelines × 20 hrs @ $95/hr$65,170

Team training · 25 devs × 4 hrs$9,500

Parallel-run period · 2 months × $2,260/mo$4,520

Setup, secrets, integrations, audit (fixed)$8,500

Risk buffer (20% contingency)$17,538

TOTAL MIGRATION COST$105,228

run-rate comparison

Jenkins (self-hosted)

$2,260/mo

GitHub Actions

$420/mo

3-yr net

-$38,988

Migration cost = pipeline engineering (count × complexity-adjusted hours × $95/hr fully-loaded) + team training + parallel-run period + fixed setup + 20% risk buffer. Run-rate uses each vendor's published per-seat + per-build-minute pricing (verified May 2026). Self-hosted hosting overhead included for Jenkins and Buildkite. Treat the output as a planning anchor, get firm migration quotes from the target vendor or a SI partner before locking the decision.

How the verdict works

GO NOW

Payback under 18 months and 3-year net positive

The maths is decisive. Strong financial case independent of any strategic factor. Greenlight.

GO IF STRATEGIC

Payback 18-36 months, 3-year net positive

Financially defensible but not compelling on cost alone. Justify with non-cost factors: developer experience, vendor concentration risk, feature requirement (e.g. matrix builds, OIDC, ARM runners) the current platform can't deliver.

STAY

Payback over 36 months, or 3-year net negative

Migration cost erases the savings. Re-evaluate when usage doubles, pricing changes materially, or the current platform raises prices on a renewal cycle. Don't migrate just because you can.

TARGET MORE EXPENSIVE

Target platform run-rate exceeds current

No annual saving exists to recover the migration. Switching is strategic-only, justify with DX, vendor risk, or feature requirements, and accept ongoing higher spend as the trade-off.

What vendor pitches miss

Per-pipeline engineering hours. The slide that compares per-minute price never mentions that you need to rewrite every Jenkinsfile or GitLab CI YAML into the new platform's DSL. At 14 hours per typical pipeline and $95/hr fully-loaded, this is usually the largest line item by a wide margin.
Parallel-run period. Safe migrations involve running both platforms for 1-3 months during cutover. That is current-platform run-rate that you pay during the migration, not new-platform savings. The vendor's "you'll save $X/month" headline ignores this.
Source-platform complexity. Migrating from Jenkins (Groovy DSL, plugin sprawl, custom shared libraries) costs more per pipeline than migrating from GitHub Actions YAML. The calculator applies a complexity multiplier to the source platform, Jenkins 1.40x, GitLab 1.20x, GitHub Actions 0.90x.
Risk buffer. Migrations overrun their estimates roughly 30-40% of the time, usually for reasons nobody predicted (secrets-rotation that breaks deployment, runner image incompatibilities, downstream tool integrations that need updating). A 20% buffer is the minimum honest provision.

Methodology

The calculator computes two figures and a verdict:

Run-rate comparison: for each platform, monthly cost = (team_size × per-seat) + (build_minutes × per-minute) + hosting_overhead. Pricing verified May 2026 against each vendor's public pricing page (GitHub Actions, CircleCI, GitLab, Buildkite, AWS CodeBuild, Bitbucket Pipelines). Self-hosted Jenkins and Buildkite carry a fixed hosting overhead.
Migration cost: (pipelines × pipeline_hours × $95/hr) + (team_size × 4 × $95) + (parallel_months × current_monthly) + $8,500 fixed setup, then × 1.20 for risk buffer. Pipeline hours = 14 × complexity_mult × source_platform_complexity. Engineer rate ($95/hr) is US blended security/platform engineering fully-loaded.
Verdict: based on payback months and 3-year net. Under 18 months & net positive = GO NOW. 18-36 months & net positive = GO IF STRATEGIC. Otherwise STAY. Negative monthly savings overrides everything as TARGET MORE EXPENSIVE.

Treat the output as a planning anchor, not a binding number. Real migrations vary by team experience, codebase quirks, and how aggressively you can run cutover. Use the calculator to set negotiation context with vendors and to prioritise, then get firm migration quotes from the target vendor or a systems integrator before locking the decision. Last vendor-pricing verification: May 2026.

Per-platform pricing comparator GitHub Actions pricing CircleCI pricing GitLab CI pricing Buildkite pricing AWS CodeBuild cost Cheapest CI by team size

Switching CI/CD platformsdoesn't pay for itself by default.