Derek Reese’s 2026 State of CI /CD Report
Report on the state of software Continuous Integration / Continuous Deployment in 2026.
Foreword
Every year I release to my clients and friends a few reports on the state of certain subjects where my opinion could help people. Most years, I focus on abstract topics like business and studio management, passions like the games industry, or deep technical dives into maintainable software.
For the first time ever, I’m also publishing a report publicly on the internet. If it makes a difference for anyone, I plan to look over my backlog and re-release others that are still relevant or that have historical interest.
Each report flows back and forth between high level, business-driven insights, and deep technical dives. I hope you can learn from the former and appreciate the work going into the latter without necessarily needing a PhD in it.
This year, I have found myself working with a large number of successful businesses on the backend, either my own, or through consulting with my incredible clients. I have been very lucky to have a mid-level view of software development as most of my day again instead of solely a bird’s eye. This has given me the opportunity to dig deep into a few annoyances on the backlog, so to speak, and one of those is Continuous Integration / Continuous Deployment of software.
And yes, in the age of AI, I still love using hand-written emdashes in my hand-written reports — I’ve used them forever and they mimic my speaking cadence. The AI can’t take them from me. Looking forward to your (AI-free) thoughts on this nuanced and intricate topic.
Thanks for reading.
Derek Reese
How We Got Where We Are Today
Audience: Those looking for a trip down memory lane.
CruiseControl was the first popular CI / CD tool back in 2001. If you remember it fondly, you must really like XML. We were first getting comfortable with the idea of automatically merging new code into programs (Continuous Integration), and slightly less comfortable with the idea of that rolling out onto the internet without a human pressing the big launch button (Continuous Deployment). Soon after, in 2005, Jenkins followed — then called Hudson, thanks Oracle for the rename. Jenkins still gives me headaches today, 21 years later, and it
just.
won’t.
die.
In the software world, that’s pretty much forever. That gives you an idea of how powerful even a basic CI/CD system can be for an organization, once it’s (mostly) working. It stays around, forever.
The open source community has driven CI / CD from the very beginning, and it was nearly impossible to unseat the lead that Jenkins and its plugin architecture pioneered. When TravisCI and similar products showed up on the scene, they were metaphorically coalescing the Jenkins auto-discovery plugin trend into a cloud platform. One anyone could deploy. You didn’t need to know DevOps anymore to get your app on the internet — just YAML.
These pipelines created both an opportunity, and, eventually, a problem. When you could make anything an automated job, sooner or later everything becomes an automated job. I still have nightmares about seeing dashboards with thousands of Jenkins runnables ticking away, getting stuck, erroring-out, and making me pull my hair.
Only by reducing the barrier to compute have cloud providers finally chipped away at the dominance, and led to the array of solutions available in the market today.
Primary CI / CD Challenges Facing Tech in 2026
Audience: Stakeholders who own or manage software deployments.
Businesses need extreme flexibility more than ever: especially in Operating Expenses (OpEx). Investors have glutted themselves on production gains since about 1978 (a topic on which others have written and is better suited for another day). This means expectations around cashflow, stock buybacks, and overhead are at the mercy of the monthly numbers more than ever. If you’re a small business, skyrocketing costs due to transportation, logistics, and marketplace monopolies have squeezed your supply chain into a nightmarish monthly subscription bill.
The pressure then falls through on the team to deliver faster with lower costs and better margins. As anyone in tech knows, your cloud compute costs can absolutely eat through all that OpEx even with an expert keeping a close eye on it. Oftentimes your only solution is to ask the team to deal with it best they can. Or cut costs elsewhere until you make headway, bring on an expensive consultant, or get time from a Fractional CTO.
All of this comes through as a need for processes that are repeatable, maintainable, and above all, cost-flexible. Much like an app that scales to meet demand, instead of hoarding expenses with always-on resources, CI / CD needs to allow teams to move between compute and resources at-will.
Unfortunately, many solutions on the market are a form of vendor lock-in. You can’t port YAML between AWS and Azure, unless you mean Terraform Plan YAML, and even then it takes effort. An Azure Visual Designer Pipeline won’t cut it for GitHub Actions. So if you ink a great deal for hybrid cloud or a server vendor today you won’t see the benefits tomorrow. You’ll see them after you’ve recovered months of time lost porting and updating legacy scripts. Any shortcuts the team takes will show up later to bite you with downtime or difficulty resolving emergency issues.
Another cost absorbed by teams is the increasing expense of development and debugging. If you can’t run the code locally, your team is spending workflow minutes (hours, days) and tedious back-and-forth builds waiting for results, often without clear visibility into issues. GitHub has the unofficial “ACT” toolkit, but that relies on the community to solve a big corporation’s expensive oversight.
To solve the cost-flexibility problem, we need to take a very technical look at what’s working and what isn’t, so we’re not throwing away 60+ years of exploration into delivering software just to dump poor implementations of good ideas.
Technical Deep Dive
Audience: Those curious about the technical cases for modern CI / CD.
Cost-flexibility is about three things: freedom to scale, freedom from overhead, and freedom to rethink and renegotiate resourcing. Translation: Avoiding tech debt and vendor lock-in.
Sites running on bare metal or VMs under active development are especially a ticking time bomb. At some point, without the highjinks of several Jenkins jobs (and in my experience, even with), versions will drift. At the same time, your expert who knows the system in and out has an emergency. Then you’ll have someone else burning midnight oil on why the latest deployment broke prod but local is fine. There’s a bunch of tech debt and overhead.
Containers eliminate that drift, or at least make it painfully obvious. They do this by decoupling software dependencies from the infrastructure. Tools like the previously mentioned ACT even let you run GitHub Actions workflows locally for idempotency and easier debugging. On top of all that, the portability frees you to swap vendors without needing anything other than container support. No specific operating systems. Some containerized setups even let you change your entire hardware stack from AMD or Intel to Qualcomm or Apple. This reduces your vendor lock-in and tech debt surface greatly.
But there are other sources of tech debt. Configuration is still tech debt. It often looks like YAML or aging Groovy scripts that are mostly lists of things. Tech debt that might as well be maintainable code. Why? Modern infrastructure code written in Go or Typescript is typed and able to be statically analyzed before you even deploy it to the cloud, saving you potentially millions (if you’re one of my enterprise clients) or at least hundreds a month.
But that doesn’t mean we should write everything in code. Docker already has a tool to solve this problem: multi-stage builds. Docker as a technology already caches each layer, so writing a good Buildkit Dockerfile puts you ahead of the game for efficient CI / CD. On top of that, you can always speed things up even more with file system mounts for cache directories.
Frameworks solve the other half of the CI issue: exactly how much boilerplate code does my team have to write to make a working CI pipeline for our app? If you’ve ever seen a CI / CD system built with Bicep or AWS CDK, plus the YAML configs for GitLab, you know it’s a hefty beast. That’s where options like Dagger come onto the scene, controlling tech debt for the team.
I’d argue about 80% of what most software needs for CI is that aforementioned boilerplate.
But what about CD? GitOps, where a tool pulls your server configuration from your Git repo every time you make updates, is the current trend here. It’s for good reason: version control of your configuration, typically as Operator code and Helm charts, makes for simpler rollback and allows static analysis of a constantly changing deployment. My personal preference is Flux2.
Real-world Analysis
Audience: Gimme the numbers people.
Docker container builds? Framework-driven CI? GitOps and Kubernetes for CD? Together they’re not just theory. I’m using my recommended process now on multiple real-world projects: several Drupal sites, my personal site built with Hugo, and a few cloud apps.
Over the last few years I’ve ported multiple client projects as well as chroniclersoftware.com and guestwi.se from Azure, to AWS, to Digital Ocean and hybrid cloud. Along the way, I’ve learned how the shape of effective CI / CD can change from each provider, along with (most importantly) where it stays the same.
Freedom to scale
GuestWise was resurrected from an ancient (relatively-speaking) open source project I wrote to give a global non-profit sustainable event ticketing and seating chart tools. I didn’t realize ten years later other nonprofits would find it useful. In order to scale from fundraisers with just 20 0 50 attendees nearly overnight, I needed a system that let me handle that by changing some knobs, not by re-architecting the whole app. The ticketing platform is served on a single Digital Ocean VM from a container, but with a config change I had it running in a full-blown Kubernetes Cluster scaling up and down automatically. And when the big event was all over, flip the switch and it’s back to the single, highly cost-effective VM. Now it’s ready for the next huge fundraiser without burning a hole in the bank account waiting around for it.
The bottom line: 50 served to 10,000+ on only $1 a day in baseline costs.
Freedom from overhead
My homelab began just like everyone else’s — a place to experiment with the latest technology and learn about it without risking production-grade resources. As time went on though, “enshittification” started showing up in my daily life. First, my cell provider updated their contract to allow selling of my data, and had the nerve to raise my plan $5 a month. One by one, from photo albums, to music collections, corporations started making their products worse to improve their margins. On top of that, my own companies and clients were struggling to reduce costs. I turned my personal hardware collection into a resource for services cost-prohibitive to run without a sweet colocation deal from a small local data center.
I’ve brought my learnings here to business operations, helping clients scale from on-site server racks to cloud burst capability and back to just the server, all automatically.
The bottom line: $4,500+/mo saved from my clients and my own collective wallets.
Freedom to rethink and negotiate resourcing
The Chronicler Software stack was originally built on Azure with my credits as an ex-Microsoft employee building a startup. The program is excellent — when it works. Unfortunately, I ran into a hitch: The overseas support team was unable to re-link my personal Microsoft account to the correct enterprise account because I was previously a Microsoft employee. I even asked a friend who is at the leadership level at Azure to look into it. The result? No dice. Not a policy problem, but a bug deep within the billing system with no resolution in sight. What was hundreds of thousands in free credits quickly turned into a terrifying potential bill with a 30 day deadline.
I had to find a new vendor, fast. Queue hitting up the inboxes of all of my investors. One of our strategics came through, blazing a path to $150,000 in AWS cloud credits. Being able to lift our entire Bicep-containerized platform and re-architect it for AWS containers using AWS CDK in TypeScript was tough but doable because it was already containerized and using no Azure-native or Windows code. With just myself working the problem, In less than two weeks and less engineering time than I originally thought, vendor lock-in was avoided.
The bottom line: $150,000+ saved.
Conclusions
- It isn’t just DevOps CI / CD Magic Sure, for the principal engineers reading, that’s obvious. Good software architecture from the get-go saves you a ton of pain. If you’ve read any of my previous reports, you’ll know I’ve learned from experience. I’m just not focusing on it in this particular write-up but it is worth acknowledging.
- Containers win out CI / CD pipelines that are containerized can be reproduced fully on a local system, including requirements around images or toolsets used. They’re easier to debug and shift the risk to split squarely between infrastructure provider and application.
- Proprietary YAML or scripts are an albatross Setup like GitHub or Azure YAML, Jenkins Groovy, or AWS CodePipelines JSON decrease portability and require specialized knowledge. Writing pipelines mainly in a single language (Golang, TypeScript, Python, PHP etc.) and then adding the wrapper decreases risk.
- Multi-stage Docker builds best parallel pipelines Most pipelines support parallelization, but in doing so require steps to be performed in a duplicative fashion. Docker-izing your app and using a multi-stage build saves thousands of hours of compute on even the simplest app build and improves parallel builds twice-over.
- Caching is non-optional And Docker multi-stage builds solve most, but not all of the issues. Mounting and caching dependencies has a massive impact on bandwidth and CI performance at the fraction of the cost in storage.
- The future is framework Modern tools like CircleCI, Tekton, Argo, and Woodpecker make huge strides in shaking up CI and taking out major pain points. But frameworks-as-a-service like Dagger or Earthly let you abstract providers away. It’s like Ansible + Terraform for CI /CD.
Aside: What do I personally use?
I get asked this a lot. My homelab* CI / CD looks like this:
flowchart TB
subgraph provisioning["1 · Infrastructure Provisioning"]
direction LR
bare_metal["Bare Metal"] --> ansible["Ansible"]
ansible --> ci_cluster["k3s Cluster<br/>CI"]
terraform["Terraform"] --> ci_cluster
end
subgraph pipeline["2 · CI Pipeline (GitLab)"]
direction LR
gitlab["GitLab<br/>Source Code"] --> ci_pipeline["CI/CD Pipeline<br/>CI Runners"]
end
subgraph gitops["3 · CD & GitOps (Flux2)"]
direction LR
gitops_repo["Artifacts & Manifests<br/>GitOps Repo"] --> flux2["Flux2<br/>GitOps CD operator"]
flux2 -->|"Helm Charts"| helm["Helm<br/>packages apps"]
end
subgraph production["4 · Production (DigitalOcean)"]
direction LR
bastion["DigitalOcean Bastion<br/>Secure Access Point"] -.->|"secure access"| prod_cluster["k3s Cluster"]
prod_cluster --> apps["Applications"]
end
%% Subgraph-to-subgraph edges keep each subgraph's LR direction;
%% node edges across subgraph borders would flatten the layout.
provisioning -->|"GitLab runners"| pipeline
pipeline --> gitops
gitops --> production
* the stack of server computers sitting in my basement
CI is mostly handled with multi-stage Dockerfile builds through Dagger on GitLab.
I also did the bootstrapping of GitLab + Flux2 with Ansible. Now, if I want to change anything (like add a new service), I just modify my Kubernetes Git repository.
Then GitLab + Ansible + Flux2 makes it all happen.
My Top CI/CD Platforms & Frameworks
- Argo CD GitOps-based continuous delivery on Kubernetes common with startups and enterprise alike. Strictly a Continuous Deployment Gitops tool for syncing cluster states with Git repos.
- AWS CodePipeline Amazon Web Services manages this CI system based around AWS CodeBuild and CodeDeploy. It handles applications hosted on AWS cloud.
- Azure DevOps Pipelines I’ve spent a lot of time deploying sites on Azure. It’s Microsoft through-and-through, with highly competitive pricing if you know which options to configure.
- Bitbucket Pipelines Built into BitBucket with deep integrations into Jira and Confluence for project tracking. Similar to other Git-embedded platforms.
- CircleCI Well-known modern CI focused on Docker and a smart testing support harness. It’s meant to be a plug-and-play with other providers.
- Dagger. Programmable CI / CD for writing deployments with their open-source Framework in Go, Python, or TypeScript. It runs the whole pipeline locally, on your existing repository runners, or even faster on their auto-caching cloud.
- GitHub Actions Mostly known for being a part of GitHub, it’s a default choice for a few good reasons, not the least of which is 20,000 plugins compatible out of the box.
- GitLab CI/CD Built into GitLab, both enterprise and self-hosted mirror similar runner setups to other repository software.
- Jenkins The OG, with bounds of plugins and heavy adoption to this day in enterprise software development. It’s rare to see a legacy Java app without it and Gradle.
- TeamCity The JetBrains offering has many developer-oriented features out of the box and is the main competitor to CircleCI both on-cloud and locally.
- Tekton An open-source project and designed from the ground up for Kubernetes, this CD-focused toolchain also handles CI and testing harnesses.
- Weave Flux2 Weave is the enterprise toolkit built on the open-source Flux2, a GitOps app for Kubernetes clusters. It scales amazingly well, letting you run it on a laptop with K3S.
- Woodpecker CI. The community fork of Drone CI focused on containers with Docker or Kubernetes. Its modern architecture and efficient resource management make it a popular companion to Forgejo Git Repository.
CI/CD Top Platform & Framework Comparison
| Platform / Framework | Primary Focus | Pipeline Definition | Hosting Model | Local Execution | Best Fit |
|---|---|---|---|---|---|
| Argo CD | Continuous Delivery (CD) | YAML / Helm | Self-hosted (Kubernetes) | No | GitOps deployments on Kubernetes |
| Argo Workflows | Container native CI & DAGs | CRDs (YAML) | Self-hosted (Kubernetes) | No (requires K8s cluster) | Heavy parallel CI, ML, and data pipelines on K8s |
| AWS CodePipeline | Continuous Delivery (CD) | JSON / YAML / CDK | AWS-managed | No | Applications deployed natively on AWS |
| Azure Pipelines | Full CI/CD | YAML & UI | Cloud & On-premises | No | Microsoft and Azure-centric organizations |
| Bitbucket Pipelines | Full CI/CD | YAML | Cloud | No | Teams integrated with Atlassian Jira |
| CircleCI | Fast CI/CD | YAML | Cloud & Self-hosted runners | Partial (via CircleCI CLI) | Multi-repo setups needing fast test execution |
| Dagger | Programmable CI/CD Engine | Go, Python, TS, etc. | Runs on any CI runner | Yes (Native) | Eliminating YAML sprawl and local/CI parity issues |
| Weave Flux2 | Container native GitOps | CRDs (YAML) | Self-hosted (Kubernetes) | With K3s | Lightweight but fully-scalable GitOps on K8s |
| GitHub Actions | Full CI/CD | YAML | Cloud & Self-hosted runners | Partial (via 3rd-party act) | Teams hosting code on GitHub |
| GitLab CI/CD | Full DevOps & CI/CD | YAML | Cloud & Self-managed | Partial (via runner CLI) | End-to-end single-application workflows |
| Jenkins | Full CI/CD | Groovy & UI | Self-hosted | No | Complex, custom enterprise pipelines |
| TeamCity | Build & CI | Kotlin, YAML, & UI | Cloud & On-premises | No | Enterprise Java/.NET teams wanting rich QA insights |
| Tekton | Cloud-native CI/CD | CRDs (YAML) | Self-hosted (Kubernetes) | No (requires K8s cluster) | Platform engineers building custom K8s pipelines |
| Woodpecker CI | Lightweight Full CI/CD | YAML | Self-hosted (Docker, K8s, local) | Yes (CLI) | Fast, low-overhead self-hosting (popular with Gitea/Forgejo) |
Key Next-Gen Takeaways
- Kubernetes-Native Orchestrators (Tekton & Argo Workflows). Pipeline steps are isolated Kubernetes pods. Tekton composes CI / CD pipelines from reusable blocks, vs Argo which uses Directed Acyclic Graphs (DAGs) to handle multiple workloads.
- Lightweight Self-Hosted CI (Woodpecker CI) Simplicity is good. So fast it runs on a Raspberry Pi and can still handle Docker or Kubernetes.
- Portable CI Engines (Dagger) Few peers measure up to Dagger in blazing the way forward for platform-agnostic automation. The SDK supports most major CI / CD systems and adding a new one is as simple as writing a new file in your favorite typed language.
Thanks for Reading
I hope you found a portion of this report helpful, whether it was a quick skim of the CI / CD tools I’ve reviewed or just to enjoy the case study type stories.
If you need any help with your Studio Operations or Dev Ops workflows, you can reach me at [email protected].
References
- The State of CI/CD in 2026 | JetBrains TeamCity
- The 2026 State of Software Delivery Report | CircleCI
- CI/CD in 2026: 20 Statistics… | Incredibuild
- The Short History of CI/CD Tools | Technology Conversations
- And a shout-out to all of the docs written for each of the listed platforms / frameworks.
No AI was used to write the content in this report, so you can blame me squarely for any disagreeable prose. Be sure to let me know on BlueSky.