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 of how we migrated our SaaS product from dedicated Windows VMs to a scalable, containerized Kubernetes environment.

Initially, every customer ran on their own Windows VM—an expensive and inflexible setup that quickly became a bottleneck to growth. Kubernetes offered a compelling alternative, but the migration was far from simple.

We’ll walk through the whole arc of this transformation: a nine-month migration process, the hurdles of transitioning legacy workloads, and the operational challenges we faced post-migration.

This talk will discuss:
- Why we moved from EC2-hosted Windows VMs to Kubernetes and how we made it work.
- How managed services simplified our database and file storage operations.
- Lessons learned from switching to a Linux-based containerized environment.
- Deployment strategies that included internal “dogfooding” and phased release rings.
- Methods for fine-tuning CPU and memory allocation based on real-time usage patterns.

Thanks to our new Kubernetes-based architecture and managed cloud services, we can onboard hundreds of new customers weekly with minimal effort or disruption.

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.

Kubernetes at Scale: How we host 1000s of customers on 10 clusters

This is a case study. We built our SaaS platform to host 1000s of customers using fewer than 10 Kubernetes clusters.

From the start, we gave each customer a dedicated instance of our application, which included a database, file storage, and other infrastructure. This solved some problems, such as data isolation, data sovereignty, and performance impacts from noisy neighbors.

However, it introduced other challenges. In this talk, we will walk through our challenges and solutions.

- What worked and what didn’t when every customer got their copy.
- How do we scale Kubernetes and database computing resources based on usage?
- How do we upgrade clusters without customers noticing?
- How do we handle cloud region outages and disaster recovery?

By solving these challenges, we can easily add hundreds of customers per week or 1000s per month!

Baking in Strong Opinions: How We Improved Developer Experience with our AI agent

This talk is a case study of how we built and evolved our AI-powered developer extension.

Our initial goal was simple: create a natural language interface that lets developers interact with our platform directly from their IDE. This would streamline onboarding for new application teams and reduce friction for platform engineers.

But as we rolled it out and gathered feedback, we realized its potential went far beyond convenience. By deeply integrating our internal knowledge—docs, forums, support tickets—we turned the tool into a guide, a troubleshooter, and even a code reviewer. We made it opinionated on purpose.

This talk will cover:
- How we identified our initial use case and then expanded it based on real-world usage.
- Why embedding strong opinions into AI tooling helps developers fall into the “pit of success” faster.
- How to build AI integrations that are genuinely useful, not just trendy.

Whether you're thinking about adding AI to your developer tools or refining what you already have, this session will offer practical lessons and hard-earned insights.