We use a lot of automation at Redgate. As a company that builds software, we want to ensure that all the changes from our teams get integrated and tested in a timely manner. We have multiple teams on some products, and while we do have regular meetings between them, it can be easy for a developer to miss some update or change that others are making and break something. Worse, they could cause a regression or security issue, which we work hard to avoid.

Recently I saw a post from one of your lead software engineers about our build process. While we have lots of pipelines, the general process hasn't changed in many years. In some sense that's good, because we focus on building better software, not the process. We don't change just for the sake of change, or because a new team or division lead likes one tool over another. I've seen customers where they move from Jenkins to Azure DevOps because someone in charge "likes one better." Not a good use of time.

However, you do need to evaluate whether your process is meeting your needs. In our case, we surveyed lots of developers to get their thoughts on pain points and issues. The build and release process was consistently listed as a pain point, with releases often requiring a dev to manage it from their workstation, preventing them from spending time building software for customers.

That might be the big lesson I saw in the write-up. We realized that a non-negligible amount of time was being spent by developers on the process of moving bits rather than building the software. This led us to re-examine how things are done. In particular, we looked at the agent OS (Linux v Windows) and containers. Both of these are more viable technologies now than in years past, and they can reduce costs while smoothing the process. As a result, we are developing a general contract that helps us decide how to change our process. This is similar to an API, that doesn't specify the tool to use, but rather the inputs, outputs, and what the effect should be. From this, we'll start to help teams move forward is changing their process as we have time.

The big takeaway right now is that this is pushing us to use containers, which simplify the steps and allow us to easily move from Azure to AWS to on-premises, or really any environment. We can switch build cross-platform, and more easily scale up or down as needed. It will take some time, and some of our software will be more challenging in containers. However, we are also seeing benefits from customers, and at some point, I expect we'll provide containers for certain functions that make it easier for the end-users of our software to also deploy and upgrade their tools.

DevOps is an ongoing process. Not a set of tools that you change just because, or a way of building software that matches what another organization does. Instead, it's learning, experimenting, and evaluating how you can be more effective. Then adopting what you've learned and repeating the process. Keep improving, and you'll find that you can produce software quicker and at a higher level of quality while improving the skills of your engineers.