AI Summary
5 min readRob Erez spent a decade building and thinking about CI/CD at scale, first on the Skype for Web team and then as one of the earliest engineers at Octopus Deploy. In this conversation, he walks through the practical realities of progressive delivery, the limits of GitOps dogma, why rollbacks are often a trap, and how AI is starting to reshape what pipelines need to do.
The CI/CD maturity ladder and why "continuous deployment" isn't for everyone
Erez breaks down the common progression of software delivery maturity. It starts with "YOLO" (deploying straight to prod), moves to continuous integration (merging and testing frequently), then to continuous delivery (the deployment process itself is tested and automated, even if the final push to production is manual), and finally to continuous deployment (changes ship to production automatically). The key distinction between continuous delivery and continuous deployment is simply whether the last step is automated. Many teams assume they should aim for continuous deployment, but Erez pushes back. Regulated industries, companies with compliance requirements, or teams that need a human sign-off before a release are perfectly fine stopping at continuous delivery. The real value is in de-risking the process up to that final button click.
GitOps is not about Git, and absolutism breaks down
Continue reading the full summary in the app — free to try.
Read Full Summary →Free • No credit card required
Never miss an episode of The Pragmatic Engineer
Get every new episode summarized in your inbox — free, ~5 minutes to read.
No spam. Unsubscribe anytime.
What you'll learn
- 1 (00:00) **Why CI/CD Remains a Hard Infrastructure Problem** - Introduction to the episode and guest Rob Erez, a decade-long CI/CD expert who was a teammate at Skype for Web and early engineer at Octopus Deploy.
- 2 (01:21) **From CAB Boards to Continuous Delivery at Skype** - The old world of weekly releases with change advisory board approvals, and how the Skype team quietly shipped code as soon as it was ready.
- 3 (05:43) **CI/CD Maturity Stages: YOLO to Continuous Deployment** - Breaking down the four stages: YOLO, continuous integration, continuous delivery, and continuous deployment.
- 4 (09:55) **Kubernetes’s Arrival in the CI/CD World** - How Kubernetes became the dominant container orchestration platform, partly by leveling the playing field between cloud vendors (AWS vs. Google Cloud vs. Azure).
- 5 (12:38) **Kubernetes on Prem: Research Vessels and Retail Stores** - Many enterprises run Kubernetes on their own hardware for control and compliance, not just in the cloud.
- 6 (18:13) **What GitOps Really Is (and Isn’t)** - GitOps was coined by Weaveworks around 2017, built on four pillars: declarative state, versioned & immutable storage, pull-based (not push), and continuous reconciliation.
- 7 (30:14) **The Rise of Platform Teams** - How platform teams evolved from the DevOps movement: they create self-service internal development portals (IDPs) and standardize best practices, while application teams retain operational ownership.
+ Full timestamped outline available in the app
Show Notes
Brought to You By:
• Antithesis – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages.
• WorkOS – everything you need to make your app enterprise ready.
• turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable.
—
Robert Erez is a principal engineer at Octopus Deploy, and a longtime expert in CI/CD, deployment systems, and software delivery. Rob and I were also once colleagues on the Skype web team, working on large-scale deployments and release processes.
In this episode of The Pragmatic Engineer, I sit down with Rob to discuss how teams deploy software safely and efficiently at scale. We cover Kubernetes, GitOps, platform engineering, progressive delivery, feature flags, cloud development environments, and the growing role of AI in CI/CD workflows. We also get into the tradeoffs in different deployment approaches, why self-hosted software still matters for some organizations, and the recent evolution of software delivery practices.
—
Timestamps
00:00 Intro
02:09 Canary deployments at Skype
05:01 Joining at Octopus Deploy
06:15 Continuous deployment
10:26 Why Kubernetes won
15:51 Kubernetes on-prem
18:50 How GitOps works
25:00 The uses and limitations of GitOps
31:04 The rise of platform teams
35:51 How AI is changing CI/CD
39:49 Progressive delivery explained
47:31 Rollbacks and roll-forwards
50:14 Feature flags
54:32 How development environments are evolving
57:40 Cloud development environments (CDEs)
1:03:45 Self-hosting CI/CD
1:09:25 Getting started with progressive delivery
1:11:15 Book recommendations
—
The Pragmatic Engineer deepdives relevant for this episode:
• Kubernetes and retiring at the top with Kelsey Hightower
• The past and future of modern backend practices
• Microsoft is dogfooding AI dev tools’ future
• How Kubernetes is built with Kat Cosgrove