Dependable DevOps: Reaching Real Production Goals

It seems like the dream of DevOps and CI/CD in today’s software world is to reach a point where you deploy to production 15 times a day. But, is that really feasible or necessary for your applications?

Today, automation is not about speed of release, but about ensuring a smooth, painless operation. Teams utilize automation to ensure that when the time comes, they are ready and aren’t exposing risks or accidentally creating more steps. When teams are getting ready to deploy to production, they face a number of critical considerations, including:

- Understanding dependencies between application downtimes and user frequency.
- When is the right time to deploy with legacy code and understanding what internal systems are impacted.
- Training, which adds time and resources.
- Explaining new features and functions frequently making it difficult for anyone to keep up.

In this session, we will walk through realistic goals and approaches to deploy to production faster and setting your team up for the potential to build once and deploy anywhere. We will discuss how creating smaller outage windows and only making small changes will help teams deliver faster while keeping systems and applications up and running.

In this talk, attendees will learn:
- How to successfully deploy faster
- How to automate deployments safely and efficiently
- How to align your DevOps team for CI/CD optimization

This session is targeted at anyone starting out with DevOps/Sofware Delivery or looking to refine their DevOps/Software Delivery goals. Other conferences/webinars this session has appeared is the DevOps Experience in November 2022 and internal training.

Streamlining Deployments: Lessons from Building a DevOps Paved Path for 150+ Developers

One of the primary goals of DevOps and platform engineering is to create efficient paved paths that alleviate the cognitive burden on developers and operations teams. This session will delve into the challenges and triumphs of establishing a robust database development and deployment process utilized by over 150 individuals across 12 diverse development and operations teams in a prominent banking institution.

This session will provide information on how to:
- Develop strategies to understand and address the diverse needs of different roles in the deployment process.
- Implement an iterative feedback loop to improve the deployment process continuously based on real-world experiences.
- Recognize when to set boundaries and say "no" to ensure a focused and efficient deployment process.
- Effectively communicate the benefits of the deployment process to gain support from all teams, including potential skeptics.
- Learn from past mistakes in onboarding new teams and adopt best practices for a smoother implementation.

The target audience for this session is any platform or devops engineer responsible for building processes or paved paths for their organization. The database deployments are a framing device. There is no specific technology requirements, and anyone with 1+ years of experience should benefit.

This talk is a modified version of a talk given at Redgate's SQL In the City Summit, PASS 2022, and DeliveryConf 2020.

What is this DevEx and Platform Engineering I keep hearing about?

Over the past few years, a seismic shift has occurred in the technology landscape.
It seems like everyone is moving traditional Windows and Linux application hosts to modern solutions such as Containerization, Kubernetes, PaaS, and Hybrid Cloud models. That alone is complex enough, but the success of DevOps and the "you build it, you run it" mindset has added a new layer of complexity. Each self-managing feature team is forced to make numerous micro-decisions in transforming their applications.

When updating a few applications, that is not a big deal. However when replicated across multiple teams within the same organization, it becomes complex quickly. This complexity, often underestimated, has paved the way for the emergence of Platform Engineering—a discipline that does not seek to supplant DevOps but to augment and streamline its application across a growing enterprise. At its core, Platform Engineering concentrates on enhancing the Developer Experience (DevEx), which is pivotal for leveraging the full potential of DevOps at an organizational scale.

- Understanding the key attributes that make a platform engineering team successful in navigating the challenges of digital transformation and DevOps integration.
- Emphasizing the significance of prioritizing developer experience and treating processes as products in their own right. This approach ensures a seamless and efficient workflow for feature teams.
- Examining successful patterns as well as common pitfalls in platform engineering and developer experience, providing valuable insights to help organizations make informed decisions.
- Delving into the strategies for constructing golden paths that streamline development processes, making it challenging for developers to resist or deviate. This includes practical approaches to aligning teams with organizational goals.

This is an introductory talk for platform engineering. The target audience of this talk is any developer or DevOps engineer who is undergoing a digital transformation and needs to quickly "level-up" a lot of developers.

From EC2 to Kubernetes: Takeaways from a brownfield migration

This is a case study on how we (Octopus Deploy) migrated our SaaS product from Windows VMs to Kubernetes.

When we launched our SaaS product, each customer received a dedicated Windows VM, which proved very costly and had many scalability issues. Kubernetes appeared to be the best option, but getting to Kubernetes was the real challenge.

This session will discuss the entire journey of our migration endeavor, from the nine-month conversion phase to the ongoing challenges encountered in the post-migration landscape. Topics discussed will be migrating existing customers, cloud infrastructure, creating efficient deployment strategies, and fine-tuning resource allocation to align with individual customer usage patterns.

With our new managed services architecture and Kubernetes, we are able to easily onboard 100s of new customers per month with little to no adjustments to our platform.

Key Takeaways for Attendees:
- Insights into the rationale behind transitioning from EC2 instances to Kubernetes.
- The rationale behind opting for managed services for our database and file storage needs.
- Challenges encountered during the transition from hosting on Windows to a Linux-based container environment.
- Navigating deployment challenges, leveraging "dogfooding" strategies, and implementing release rings.
- Techniques for dynamically adjusting CPU and RAM resources based on customer usage metrics.

The target audience for this talk is someone aware of kubernetes basics, such as nodes, containers, and namespaces, but not an expert. It is designed for anyone who has been a developer, operations, or platform engineer for with 2+ years of industry experience.

Multi-Tenancy Architecture Lessons Learned

Architecting a multi-tenanted application is challenging. Decisions can impact developers and operations for the life of the application, which is measured in years, if not for over a decade.

Often, the hardest decision is which of the three common multi-tenancy architecture approaches is appropriate. A unique application and database per tenant, shared application and isolated database per tenant, or shared application and database. This decision is so challenging because there is no "one true approach." Each application's scenario is different.

I've witnessed the impact of those decisions firsthand. I've been exposed to each approach during my career as a software developer and architect. I spent over 20 years supporting six different multi-tenanted applications for companies working in advertising, telemarketing, oil, finance, government, and software.

In this session, we will walk through the lessons learned from working on those applications.

In this talk, attendees will learn:
- The pros and cons of each approach; unique application and database per tenant, shared application and isolated database per tenant, and shared application and database.
- When one approach is preferred over the other.
- How to handle unique configurations and requirements per tenant.
- The hidden costs and the long-term impacts.
- How advancements in tooling and platforms have made the unique application and database per tenant easier to support.

The target audience for this talk is architects, developers, and people in operations. The session is best for someone who has been in the IT industry for 1-2 years.

Kubernetes for the rest of us

Kubernetes, often perceived as a complex "black box," is a robust platform for container orchestration. This conference session is tailored for those who may not directly manage Kubernetes clusters but seek to understand its fundamental workings. This session aims teach attendees the basics on running a container in a Kubernetes cluster, particularly with an external database backend.

- Core Kubernetes Concepts: Explore essential concepts such as services, pods, nodes, clusterIPs, ingress controllers, secrets, deployments, and more. Gain a foundational understanding of how these components interact within the Kubernetes ecosystem.
- Deployment Strategies and CI/CD Pipelines: Unpack deployment strategies and dive into (CI/CD) pipelines. Understand the role of automation in managing containerized applications and discover where the emerging GitOps methodology fits into the Kubernetes landscape.
- Hands-On Learning Strategies: Equip yourself with practical knowledge by exploring ways to advance your understanding. Learn how to install and manage a Kubernetes cluster locally, providing a hands-on experience to solidify your comprehension.

By the session's end, participants will have a foundational grasp of Kubernetes concepts, insights into deployment strategies and CI/CD pipelines. Whether you're a developer, part of an operations team, or simply curious about container orchestration, this session simplifies Kubernetes, making its powerful capabilities accessible to all.

This session is designed for anyone who is aware of kubernetes and containers but isn't directly responsible for hosting or managing the cluster.

How we progressively deliver changes to Kubernetes using Canary Deployments and Feature Flags

This is the case study of how we changed how we ship software.

With thousands of customers, each in their own Kubernetes container, deploying updates was tough. Off-hours schedules meant it took over 24 hours to push a new version. If something broke, we had to scramble. Canary deployments let us update small groups of customers at a time. We built a tool to stop rollouts fast when issues appeared, limiting the damage.

In the past, new features went to everyone at once. Rolling back wasn't an option. If something failed it'd leave customers stuck in the mess. Now, using OpenFeature, we hide new functionality behind feature flags. We release features to small groups, gather feedback, and test internally for weeks. If things go wrong, we flip the flag off and move on.

This two-pronged approach lets us avoid risky big-bang releases. We went from deploying every 10 days to every 4, with fewer than 1% high-severity defects. Most of these are resolved before customers notice them.

Canary Deployments are a myth - true progressive delivery occurs via OpenFeature

Based on two decades of deploying and rolling back software and seven years of helping customers achieve their CD goals, this session debunks myths about canary deployments. While they are viewed as essential to progressive delivery, they are far from a universal solution.

Canary deployments rarely uncover last-minute issues in strong CI/CD pipelines. They demand significant investment in deployment processes, database compatibility, and rollback strategies—often outweighing the benefits. Most importantly, they lack precision, requiring workarounds for targeting subsets of users.

This session shows that OpenFeature meets progressive delivery goals without overhauling your build and deployment processes. It allows you to separate deploying new versions from releasing functionality. Rollbacks require a simple toggle instead of redirecting to an old version. With segmentation, OpenFeature enables targeted rollouts to specific users or groups, gathering feedback over time.