Summary of CI/CD with Robert Erez

Overview of CI/CD with Robert Erez

This episode is a deep dive into CI/CD at scale with Rob Ayres, a veteran of deployment tooling and progressive delivery. The conversation traces the evolution from “YOLO” deployments to continuous integration, continuous delivery, and continuous deployment, then moves into the modern realities of Kubernetes, GitOps, platform teams, feature flags, and AI-assisted development. A recurring theme is that shipping software safely is less about dogma and more about choosing the right level of control, automation, and rollback strategy for your team and environment.

Key Topics Discussed

CI, CD, and the maturity curve

• The episode frames delivery practices as a progression:
  • YOLO/manual deployments
  • Continuous integration: merging often and testing continuously
  • Continuous delivery: always keeping software deployable and validating the deployment pipeline
  • Continuous deployment: automatically shipping to production
• Rob emphasizes that not every company should aim for full continuous deployment, especially in regulated industries or environments that require signoff and coordinated release windows.

Progressive delivery and safer releases

• Progressive delivery is presented as the next step beyond CD: releasing changes gradually and deliberately.
• Common techniques discussed:
  • Canary deployments: releasing to a small slice of traffic/users first
  • Blue-green deployments: standing up a full new environment and switching traffic over after validation
  • Feature flags/toggles: the most practical method for many application teams
• Feature flags are highlighted as especially powerful because they:
  • decouple deployment from release
  • allow targeted rollouts
  • make rollbacks nearly instant
  • support more granular control than traffic-based deployment strategies

GitOps: useful model, often misunderstood

• A major point in the conversation is that GitOps is not really “about Git”.
• The four GitOps pillars discussed:
  1. Declarative state
  2. Versioned and immutable desired state
  3. Pull-based reconciliation
  4. Continuous reconciliation
• Rob argues that the industry often becomes too dogmatic about “everything must be in Git,” even though:
  • secrets should not simply be committed to Git
  • some operational steps are better handled imperatively
  • not every workflow fits a purely declarative model

Kubernetes in the real world

• Kubernetes is described as the dominant orchestration platform, but not only for cloud-native apps:
  • many teams use it on-prem
  • it’s common in financial services, government, and regulated environments
  • some deployments run in unusual places like retail POS systems or even research vessels
• The practical takeaway: Kubernetes won because it provides a declarative, portable control plane, not just because it lives in the cloud.

Platform teams and internal developer portals

• The rise of platform teams is framed as a response to DevOps sprawl.
• Instead of every app team reinventing deployment workflows, platform teams:
  • define standards and best practices
  • provide reusable templates and self-service tooling
  • often expose this through an internal developer portal (IDP)
• This helps application teams focus on shipping code rather than becoming pipeline experts.

AI’s impact on CI/CD

• Rob expects AI to change CI/CD, but says it’s still early.
• Likely changes include:
  • more code being generated and shipped
  • less emphasis on shaving minutes off pipeline runtime
  • more emphasis on risk reduction and automated validation
• He expects feature flags and progressive delivery to become even more important in an AI-heavy world, because they help control blast radius when code volume increases.

Important Takeaways

Roll forward, don’t obsess over rollbacks

• Rob strongly recommends thinking in terms of roll forward instead of rollback.
• True rollback is hard in stateful systems, especially when databases and schema migrations are involved.
• In practice:
  • if a bug ships, the safest move is often to fix forward quickly
  • feature flags can act as a fast “off switch”
  • hotfixes and forward fixes are usually more realistic than reverting to an older version

Feature flag hygiene matters

• Feature flags are powerful, but they create operational debt if left behind.
• Good practices include:
  • assigning ownership
  • setting expiry dates
  • tracking whether a flag is still active in code
  • removing stale toggles after rollout completes
• The team at Octopus uses internal mechanisms to notify owners when flags have outlived their purpose.

SaaS vs on-prem is not a solved “SaaS wins” story

• Octopus’s experience shows why on-prem remains relevant:
  • many customers need control for compliance, stability, or operational reasons
  • some customers upgrade very slowly, which forces long-term backward compatibility
• Supporting both SaaS and on-prem creates complexity, but also serves loyal customers who value stability over novelty.

Practical Recommendations

If you’re new to progressive delivery

• Start with one feature flag
• Use it to learn:
  • how deployment and release can be decoupled
  • how quickly you can disable a feature if it misbehaves
  • how to manage flag cleanup and ownership

If you operate at scale

• Invest in:
  • observability before progressive rollout
  • clear rollback/forward-fix procedures
  • platform abstractions that reduce duplication across teams
  • environment strategies that fit your actual operational constraints, not just industry hype

If you’re building pipelines today

• Don’t assume everything must be declarative or in Git
• Use GitOps where it fits, but keep room for:
  • notifications
  • smoke tests
  • database migrations
  • operational steps that don’t map cleanly to pure Git state

Recommended Reading

Books mentioned

• The Phoenix Project — foundational DevOps/operational thinking; useful for understanding why developers should care about delivery and operations
• Radical Candor — communication and leadership, especially useful for engineers working in cross-functional teams
• Greg Egan novels — for readers who enjoy hard science fiction; Rob recommends titles like Diaspora and Children of Time was mentioned? Actually the transcript names Diaspora and likely Children of Time was not by Greg Egan, so the clearest recommendation is Diaspora

Final Thought

The episode’s core message is pragmatic: CI/CD is hard because real systems are messy, stateful, and varied. The best teams don’t chase buzzwords blindly—they build delivery systems that reduce risk, fit their organization, and help them ship software reliably.