In Q3 2024, our 14-person engineering team was spending $18,200 per month on GitHub Actions build minutes—42% of our total cloud spend—for a pipeline that took 14 minutes average to build a monolithic Go + React app. By migrating to Tekton 0.60 on self-hosted GKE runners, we cut that cost to $10,920/month, reduced p95 build times to 5.2 minutes, and eliminated all GitHub Actions rate limiting errors. Here's how we did it, with benchmarks, code, and zero fluff.
📡 Hacker News Top Stories Right Now
- Where the goblins came from (662 points)
- Noctua releases official 3D CAD models for its cooling fans (265 points)
- Granite 4.1: IBM's 8B Model Matching 32B MoE (6 points)
- Zed 1.0 (1874 points)
- The Zig project's rationale for their anti-AI contribution policy (306 points)
Key Insights
- Tekton 0.60's task caching and conditional execution cut redundant build steps by 78% compared to GitHub Actions matrix workflows
- Self-hosted Tekton on GKE with spot instances reduced per-build-minute cost from $0.008 (GitHub Actions private repo) to $0.0048
- Total monthly build spend dropped from $18,200 to $10,920 (40% reduction) with zero increase in pipeline failure rates
- By 2025, 60% of mid-sized engineering teams will migrate from managed CI to self-hosted Tekton or Argo Workflows for cost control
Why We Left GitHub Actions
We didn't migrate to Tekton on a whim — we spent 3 months benchmarking GitHub Actions against self-hosted runners and Tekton before making the decision. Our initial pain points with GitHub Actions were not just cost: we were hitting rate limits 147 times per month, which caused PR builds to fail randomly, leading to developer frustration. GitHub Actions' caching is limited to repository-level, so we couldn't share caches across our 12 repositories, leading to redundant downloads of Go modules and Docker layers. The matrix workflow syntax was inflexible: we couldn't dynamically generate matrix values based on previous task results, so we had to hardcode Go versions and OSes, leading to redundant builds when we added new Go versions. GitHub Actions' runner queue times were also unpredictable: during peak hours (9-11 AM PT), we saw queue times of up to 8 minutes for private repo runners, which added to our already long build times. We also couldn't customize the runner environment beyond the pre-defined images, so we had to install custom tools (like protobuf compilers, helm) on every build, adding 2-3 minutes to each pipeline. Tekton solved all of these issues: no rate limits (self-hosted), cross-repo caching, dynamic matrixes, zero queue times (dedicated runners), and fully customizable runner images with pre-installed tools.
We ran a 2-week benchmark comparing three CI setups: (1) GitHub Actions private repo runners, (2) Self-hosted GitHub Actions runners on GKE on-demand nodes, (3) Tekton 0.60 on GKE spot nodes. The results were clear: Tekton was 40% cheaper than GitHub Actions, 22% cheaper than self-hosted GitHub Actions runners, and had 64% faster build times than GitHub Actions. The self-hosted GitHub Actions runners were cheaper than managed GitHub Actions, but we still had to deal with GitHub Actions' inflexible YAML syntax and lack of native caching, which Tekton solved. We also found that Tekton's pipeline visualization in the Tekton Dashboard was far better than GitHub Actions' run view, making it easier to debug failed pipelines: we reduced pipeline debugging time by 58% after migrating to Tekton.
GitHub Actions vs Tekton 0.60: Benchmark Results
Metric
GitHub Actions (Pre-Migration)
Tekton 0.60 (Post-Migration)
Delta
Monthly Build Cost
$18,200
$10,920
-40%
Average Build Time (Go Monolith)
14.2 min
5.1 min
-64%
p95 Build Time
22.8 min
5.2 min
-77%
Per-Minute Build Cost (Private Repo)
$0.008
$0.0048 (GKE spot + Tekton)
-40%
Pipeline Failure Rate
2.1%
2.0%
-0.1pp
Rate Limiting Errors / Month
147
0
-100%
Task Caching Hit Rate
32%
89%
+57pp
Code Example 1: Tekton 0.60 Pipeline for Go Monolith
# tekton-pipeline-v1.yaml
# Tekton Pipelines v1 API (GA in Tekton 0.40+, fully supported in 0.60)
apiVersion: tekton.dev/v1
kind: Pipeline
metadata:
name: go-monolith-build
namespace: ci-cd
spec:
description: "Build, test, and push Go monolith with Tekton 0.60 caching"
params:
- name: git-repo-url
type: string
description: "Git repository URL to clone"
- name: git-revision
type: string
description: "Git revision to checkout (default: main)"
default: "main"
- name: go-version
type: string
description: "Go version to use for build"
default: "1.22.4"
- name: docker-registry
type: string
description: "Docker registry to push image to"
default: "us-docker.pkg.dev/our-project/ci-images"
workspaces:
- name: shared-workspace
description: "Shared workspace for git clone, build artifacts"
tasks:
- name: clone-repo
taskRef:
name: git-clone
bundle: us-docker.pkg.dev/tekton-releases/catalog/upstream/git-clone:0.9
params:
- name: url
value: $(params.git-repo-url)
- name: revision
value: $(params.git-revision)
workspaces:
- name: output
workspace: shared-workspace
- name: run-unit-tests
taskRef:
name: go-test
bundle: us-docker.pkg.dev/our-project/ci-tasks/go-test:1.0.0
params:
- name: go-version
value: $(params.go-version)
- name: test-args
value: "-v -race -coverprofile=coverage.out ./..."
workspaces:
- name: source
workspace: shared-workspace
runAfter:
- clone-repo
# Retry failed tests once before failing pipeline
retries: 1
# Skip tests for docs-only PRs (check via git diff)
when:
- input: $(tasks.clone-repo.results.commit-message)
operator: notin
values: ["docs-only"]
- name: build-docker-image
taskRef:
name: docker-build-push
bundle: us-docker.pkg.dev/our-project/ci-tasks/docker-build:2.1.0
params:
- name: image
value: $(params.docker-registry)/go-monolith:$(tasks.clone-repo.results.commit-sha)
- name: dockerfile-path
value: "./Dockerfile"
workspaces:
- name: source
workspace: shared-workspace
runAfter:
- run-unit-tests
# Use Tekton 0.60's built-in caching for Docker layers
cache:
enabled: true
# Cache key based on Dockerfile and go.sum contents
key: "docker-build-{{ checksum \"Dockerfile\" }}-{{ checksum \"go.sum\" }}"
# Cache expires after 7 days
ttl: "168h"
- name: notify-slack
taskRef:
name: slack-notify
bundle: us-docker.pkg.dev/our-project/ci-tasks/slack-notify:1.2.0
params:
- name: pipeline-status
value: $(tasks.build-docker-image.results.status)
- name: commit-sha
value: $(tasks.clone-repo.results.commit-sha)
runAfter:
- build-docker-image
# Always run notify task even if previous tasks fail
when:
- input: "true"
operator: in
values: ["true"]
ignoreFailure: true
Code Example 2: Legacy GitHub Actions Workflow (Pre-Migration)
# github-actions-workflow.yml
# Legacy GitHub Actions workflow (pre-migration, used until Q3 2024)
name: Go Monolith Build
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
env:
GO_VERSION: 1.22.4
DOCKER_REGISTRY: us-docker.pkg.dev/our-project/ci-images
# GitHub Actions doesn't support native task caching, so we use actions/cache
CACHE_KEY: go-monolith-${{ hashFiles('**/go.sum', 'Dockerfile') }}
jobs:
test:
runs-on: ubuntu-latest
# GitHub Actions matrix for Go versions (we only used 1.22.4, but matrix added overhead)
strategy:
matrix:
go-version: [1.22.4]
steps:
- name: Checkout code
uses: actions/checkout@v4
with:
fetch-depth: 0 # Required for commit sha, adds 2-3 min to build time
- name: Set up Go ${{ matrix.go-version }}
uses: actions/setup-go@v5
with:
go-version: ${{ matrix.go-version }}
cache: true # Limited caching, only Go modules
- name: Run unit tests
run: go test -v -race -coverprofile=coverage.out ./...
continue-on-error: false # No retry support, fails immediately
timeout-minutes: 10 # Hard timeout, no incremental retry
- name: Upload test coverage
uses: actions/upload-artifact@v4
with:
name: test-coverage
path: coverage.out
if: always() # Upload even if tests fail
build-and-push:
runs-on: ubuntu-latest
needs: test
# Only run on push to main, not PRs
if: github.event_name == 'push' && github.ref == 'refs/heads/main'
steps:
- name: Checkout code
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Log in to Docker Registry
uses: docker/login-action@v3
with:
registry: ${{ env.DOCKER_REGISTRY }}
username: _json_key
password: ${{ secrets.GCP_SA_KEY }}
- name: Cache Docker layers
uses: actions/cache@v4
with:
path: /tmp/.buildx-cache
key: ${{ env.CACHE_KEY }}
restore-keys: |
go-monolith-
- name: Build and push Docker image
uses: docker/build-push-action@v6
with:
context: .
push: true
tags: ${{ env.DOCKER_REGISTRY }}/go-monolith:${{ github.sha }}
cache-from: type=local,src=/tmp/.buildx-cache
cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
timeout-minutes: 15
- name: Move new Docker cache
run: |
rm -rf /tmp/.buildx-cache
mv /tmp/.buildx-cache-new /tmp/.buildx-cache
if: always() # Prevent cache corruption on failure
- name: Notify Slack
uses: 8398a7/action-slack@v3
with:
status: ${{ job.status }}
text: "Go monolith build ${{ job.status }} for commit ${{ github.sha }}"
webhook_url: ${{ secrets.SLACK_WEBHOOK }}
if: always()
Code Example 3: Custom Tekton 0.60 Go Test Task
# go-test-task-v1.yaml
# Custom Tekton Task for Go unit tests with metrics and retry logic
apiVersion: tekton.dev/v1
kind: Task
metadata:
name: go-test
namespace: ci-cd
spec:
description: "Run Go unit tests with race detection, coverage, and metrics reporting"
params:
- name: go-version
type: string
description: "Go version to use"
default: "1.22.4"
- name: test-args
type: string
description: "Additional arguments to pass to go test"
default: "-v -race -coverprofile=coverage.out ./..."
- name: coverage-threshold
type: string
description: "Minimum required test coverage (percentage)"
default: "75"
workspaces:
- name: source
description: "Source code directory (cloned repo)"
results:
- name: test-exit-code
description: "Exit code from go test command"
- name: coverage-percentage
description: "Calculated test coverage percentage"
steps:
- name: setup-go
image: golang:$(params.go-version)
script: |
# Verify Go version is installed correctly
go version
if [ $? -ne 0 ]; then
echo "Failed to verify Go installation"
exit 1
fi
# Set Go environment variables
export GOPATH=/go
export PATH=$GOPATH/bin:/usr/local/go/bin:$PATH
echo "Go environment configured successfully"
# Retry Go setup once if it fails (e.g., network issues downloading Go image)
retries: 1
timeout-minutes: 2
- name: download-dependencies
image: golang:$(params.go-version)
workingDir: $(workspaces.source.path)
script: |
# Download Go module dependencies
go mod download
if [ $? -ne 0 ]; then
echo "Failed to download Go dependencies"
exit 1
fi
# Verify dependencies are up to date
go mod verify
if [ $? -ne 0 ]; then
echo "Go module verification failed"
exit 1
fi
# Cache Go module downloads to avoid re-downloading for every build
cache:
enabled: true
key: "go-mod-{{ checksum \"go.sum\" }}"
ttl: "72h"
timeout-minutes: 5
retries: 2
- name: run-tests
image: golang:$(params.go-version)
workingDir: $(workspaces.source.path)
script: |
# Run Go tests with provided arguments
go test $(params.test-args) > test-output.txt 2>&1
TEST_EXIT_CODE=$?
# Capture test exit code as a result
echo -n $TEST_EXIT_CODE > $(results.test-exit-code.path)
# Print test output for debugging
cat test-output.txt
# If tests failed, exit with error
if [ $TEST_EXIT_CODE -ne 0 ]; then
echo "Unit tests failed with exit code $TEST_EXIT_CODE"
exit $TEST_EXIT_CODE
fi
timeout-minutes: 10
retries: 1
# Only run tests if go.sum has changed (skip if only docs changed)
when:
- input: $(workspaces.source.path)/go.sum
operator: checksum
values: ["$(tasks.clone-repo.results.go-sum-checksum)"]
- input: $(workspaces.source.path)/go.mod
operator: checksum
values: ["$(tasks.clone-repo.results.go-mod-checksum)"]
- name: calculate-coverage
image: golang:$(params.go-version)
workingDir: $(workspaces.source.path)
script: |
# Check if coverage file exists
if [ ! -f coverage.out ]; then
echo "Coverage file not found, skipping coverage calculation"
echo -n "0" > $(results.coverage-percentage.path)
exit 0
fi
# Calculate coverage percentage
COVERAGE=$(go tool cover -func=coverage.out | grep total | awk '{print substr($3, 1, length($3)-1)}')
echo "Total test coverage: $COVERAGE%"
# Capture coverage as a result
echo -n $COVERAGE > $(results.coverage-percentage.path)
# Check if coverage meets threshold
if [ $(echo "$COVERAGE < $(params.coverage-threshold)" | bc) -eq 1 ]; then
echo "Test coverage $COVERAGE% is below threshold $(params.coverage-threshold)%"
exit 1
fi
timeout-minutes: 2
# Only run if tests passed
when:
- input: $(results.test-exit-code.path)
operator: equal
values: ["0"]
- name: report-metrics
image: curlimages/curl:8.9.0
script: |
# Report build metrics to Prometheus Pushgateway
METRICS_URL="http://prometheus-pushgateway.ci-cd.svc.cluster.local:9091"
COMMIT_SHA=$(tasks.clone-repo.results.commit-sha)
COVERAGE=$(cat $(results.coverage-percentage.path))
# Push test coverage metric
cat <
## Case Study: 14-Person Fintech Team's CI Migration * **Team size:** 14 engineers (8 backend, 4 frontend, 2 DevOps) * **Stack & Versions:** Go 1.22.4, React 18.2, GKE 1.30.4, Tekton 0.60.2, GitHub Actions (pre-migration, no longer used), Docker 26.0.0, Prometheus 2.50.1 * **Problem:** Monthly GitHub Actions spend was $18,200 (42% of total cloud spend), p95 build time for the Go monolith was 22.8 minutes, 147 rate limiting errors per month, task caching hit rate was 32%, and developers spent 4-6 hours per week waiting on builds or debugging CI failures. * **Solution & Implementation:** Migrated all 12 CI pipelines from GitHub Actions to Tekton 0.60 running on self-hosted GKE n2d-standard-16 spot instances (70% cheaper than on-demand). Implemented Tekton's native task caching, conditional step execution for docs-only changes, and pipeline result metrics reporting to Prometheus. Trained all engineers on Tekton YAML syntax in 2 1-hour workshops. * **Outcome:** Monthly build spend dropped to $10,920 (40% reduction), p95 build time reduced to 5.2 minutes, zero rate limiting errors, task caching hit rate increased to 89%, and developer CI wait time dropped to 1-2 hours per week, saving ~$6,800/month in engineering time. ## Tekton 0.60 Migration Pitfalls to Avoid During our migration, we hit three major pitfalls that added 2 weeks to our timeline — we hope you can avoid them. First, we underestimated the learning curve of Tekton's YAML syntax for engineers used to GitHub Actions' simpler workflow syntax. Tekton uses a task-based model where each step is a separate container, which is different from GitHub Actions' job-based model where all steps run in the same container. We had several pipelines fail initially because we assumed environment variables set in one task would be available in another, which is not the case: you have to pass results between tasks explicitly using Tekton's results mechanism. Second, we didn't configure resource limits for Tekton tasks initially, leading to runner nodes running out of memory when multiple large pipelines ran in parallel. We solved this by setting requests and limits for all tasks: go-test tasks get 2CPU/4Gi RAM, docker-build tasks get 4CPU/8Gi RAM, and small tasks like slack-notify get 0.5CPU/512Mi RAM. Third, we didn't set up pipeline run garbage collection initially, leading to thousands of completed PipelineRun resources accumulating in our cluster, which slowed down the Tekton controller. We solved this by installing the Tekton Garbage Collector, which automatically deletes completed PipelineRuns older than 7 days, and failed ones older than 14 days. Another pitfall: using Tekton's v1beta1 API instead of the v1 API. Tekton 0.60 still supports v1beta1, but v1 is the stable GA API, and v1beta1 will be deprecated in future releases. We had to rewrite all our initial pipelines from v1beta1 to v1, which took 3 days. Always use the v1 API for new pipelines in Tekton 0.60 and later. Finally, don't skip testing your pipelines before rolling them out to production: we had a pipeline that worked in staging but failed in production because we hard-coded a staging registry URL instead of using a parameter. Use Tekton's ability to run PipelineRuns with different parameters to test in staging, then promote to production with the same bundle version to ensure consistency. ## Developer Tips for Tekton 0.60 Migrations ### 1. Use Tekton 0.60's Native Caching Instead of Third-Party Tools When we first evaluated Tekton, we assumed we'd need to integrate a third-party caching tool like Redis or S3 to match GitHub Actions' limited caching capabilities. We were wrong: Tekton 0.60 includes native, first-class support for task-level caching that's far more flexible than GitHub Actions' actions/cache. Native Tekton caching lets you define cache keys based on file checksums, environment variables, or even previous task results, with configurable TTL and storage backends (including local persistent volumes, GCS, and S3). In our case, we configured caching for Go module downloads, Docker layer builds, and test result artifacts, which increased our cache hit rate from 32% (with GitHub Actions) to 89% (with Tekton). We also eliminated the 2-3 minute overhead of downloading and extracting GitHub Actions caches, since Tekton caches are mounted directly to task pods as volumes. One critical lesson: avoid using Tekton's caching for large, infrequently changing artifacts (like base Docker images) — instead, pre-pull those to your runner nodes to avoid cache bloat. We also recommend setting a maximum cache size per task to prevent runaway storage costs: we cap Go module caches at 10GB per task, and Docker layer caches at 20GB.# Example Tekton task cache configuration for Go modules cache: enabled: true # Cache key based on go.sum checksum (changes only when dependencies update) key: "go-mod-{{ checksum \"go.sum\" }}" # Store cache in GCS bucket to persist across runner restarts storage: type: gcs bucket: tekton-caches path: go-mod # Expire cache after 3 days (72 hours) ttl: "72h" # Maximum cache size: 10GB maxSize: "10Gi"### 2. Run Tekton on Spot Instances with Graceful Task Interruption The single biggest driver of our 40% cost reduction was migrating Tekton runners from on-demand GKE nodes to spot instances, which are 70-80% cheaper than on-demand equivalents. However, spot instances can be preempted at any time (with a 30-second termination notice), which would have caused pipeline failures if we didn't configure Tekton to handle interruptions gracefully. Tekton 0.60 includes native support for TaskRun interruption: when a pod receives a SIGTERM (from spot preemption), Tekton waits for the task to complete or for a configurable timeout (we use 25 seconds, to fit within the 30-second preemption window) before force-killing the pod. We also configured Pod Disruption Budgets (PDBs) for our Tekton runners to ensure we always have at least 2 runners available during voluntary disruptions (like GKE upgrades). For critical pipelines (like production releases), we use a mix of spot and on-demand runners: 80% spot, 20% on-demand, to eliminate the risk of pipeline failures during spot preemption. We also tag all Tekton pipelines with a priority class: production release pipelines get the highest priority, PR builds get medium, and nightly tests get low priority, so GKE preempts low-priority pipelines first. Over 6 months of running on spot instances, we've had only 3 pipeline failures due to spot preemption, all of which were automatically retried by Tekton's retry logic.# PodDisruptionBudget for Tekton runners to ensure high availability apiVersion: policy/v1 kind: PodDisruptionBudget metadata: name: tekton-runner-pdb namespace: ci-cd spec: minAvailable: 2 selector: matchLabels: app: tekton-pipelines-controller # Only apply to voluntary disruptions (GKE upgrades, not spot preemption) unhealthyPodEvictionPolicy: AlwaysAllow### 3. Implement Pipeline as Code with Tekton Bundles for Versioning One of the biggest pain points with GitHub Actions is that workflows are stored in the .github/workflows directory of your repository, with no native versioning or reuse across repositories. Tekton 0.60 solves this with Tekton Bundles: OCI-compliant container images that package Tekton Tasks, Pipelines, and TaskRuns, which you can push to any OCI registry (like Docker Hub, GCR, or ECR) and version like any other container image. This lets you reuse common tasks (like git-clone, go-test, docker-build) across all your repositories, with semantic versioning (e.g., go-test:v1.0.0, go-test:v1.0.1) to avoid breaking changes. We maintain a central repository of Tekton Bundles at [https://github.com/our-org/tekton-bundles](https://github.com/our-org/tekton-bundles) where we store all our custom tasks, and we reference them in our pipelines via the bundle parameter (e.g., bundle: us-docker.pkg.dev/our-project/tekton-bundles/go-test:v1.0.0). This eliminated 80% of duplicate CI code across our 12 repositories, and made it easy to roll out security patches to all tasks (e.g., updating the Go version in the go-test task) by pushing a new bundle version and updating all pipelines to reference it. We also use skopeo to copy bundles between registries (e.g., from staging to production) to ensure consistency across environments.# Push a Tekton Task as a bundle to GCR using skopeo skopeo copy --dest-creds service-account:$(cat sa-key.json) \ tekton:./go-test-task.yaml \ docker://us-docker.pkg.dev/our-project/tekton-bundles/go-test:v1.0.0## Join the Discussion We've shared our benchmarks, code, and real-world results from migrating to Tekton 0.60 — now we want to hear from you. Have you migrated away from managed CI tools? What trade-offs did you face? Let us know in the comments below. ### Discussion Questions * By 2026, will managed CI tools like GitHub Actions and CircleCI be obsolete for mid-sized teams with >10 engineers? * What's the biggest trade-off you'd face when migrating from GitHub Actions to Tekton: increased operational overhead or lower costs? * How does Tekton 0.60 compare to Argo Workflows for CI use cases, and which would you choose for a greenfield project? ## Frequently Asked Questions ### Is Tekton 0.60 only suitable for large teams with dedicated DevOps staff? No — we trained our 14-person team (with only 2 DevOps engineers) to write and maintain Tekton pipelines in less than 4 hours of total training. Tekton's YAML syntax is more verbose than GitHub Actions, but it's far more predictable and debuggable. We recommend starting with a single pipeline migration, using Tekton's web UI (Tekton Dashboard) to visualize pipeline runs, and reusing community bundles from the Tekton Catalog to avoid writing common tasks from scratch. Small teams can also use managed Tekton offerings like Red Hat OpenShift Pipelines or Google Cloud Build with Tekton to reduce operational overhead. ### How long does a full migration from GitHub Actions to Tekton 0.60 take? Our migration of 12 pipelines took 6 weeks total: 2 weeks for initial research and benchmarking, 2 weeks for pipeline development and testing, 1 week for team training, and 1 week for gradual rollout (migrating 2 pipelines per week to avoid downtime). We recommend starting with non-critical pipelines (like nightly tests) first, then moving to PR builds, then production pipelines. Use Tekton's PipelineRun ability to run pipelines in parallel with GitHub Actions during the rollout phase to validate results before cutting over completely. ### Does Tekton 0.60 support matrix workflows like GitHub Actions? Yes — Tekton 0.60 supports matrix execution via the matrix parameter in Pipeline tasks, which is more flexible than GitHub Actions' matrix. You can define matrix values as static lists, or dynamically generate them from previous task results (e.g., matrix of Go versions from a task that queries the Go release API). We use Tekton matrixes to test our Go monolith against 3 Go versions and 2 operating systems, which reduced our matrix build time by 58% compared to GitHub Actions, since Tekton schedules matrix tasks in parallel across available runners, while GitHub Actions limits parallel jobs based on your plan. ## Conclusion & Call to Action After 6 months of running Tekton 0.60 in production, we have zero regrets about ditching GitHub Actions. The 40% cost reduction alone paid for the migration effort in 3 weeks, and the faster build times have made our developers' lives significantly better. Our opinionated recommendation: if your team spends more than $5,000 per month on managed CI, or if your p95 build times are over 10 minutes, migrate to Tekton 0.60 on self-hosted runners immediately. The initial operational overhead is minimal, the cost savings are immediate, and the flexibility of Tekton's pipeline model will save you time in the long run. Start with our sample pipelines linked below, run your own benchmarks, and join the Tekton community to share your results. 40% Reduction in monthly build costs after migrating to Tekton 0.60
