Episode 68: DevOps / ZeroOps

The latest episode of the Acima Development Podcast takes a deep dive into the evolution of DevOps, platform engineering, and the concept of ZeroOps. Host Mike, along with panelists Justin Caldwell, Kyle, Justin Ellis, Will Archer, and Eddy, discuss how infrastructure should function like a well-designed vending machine—providing a seamless interface where developers don’t need to worry about the internal mechanics. The team explores how DevOps has transformed over the years, moving from traditional sysadmin roles to cloud-driven automation, enabling developers to focus on delivering code while minimizing manual operational tasks. The discussion introduces ZeroOps, a modern approach that seeks to eliminate the need for infrastructure management by automating processes and providing a frictionless experience for development teams.

Justin Ellis provides historical context on IT infrastructure, explaining how organizations transitioned from manual punch card systems to today’s highly automated cloud environments. The panel highlights best practices in infrastructure management, emphasizing the importance of standardization, automation, and observability. They discuss the shift from managing infrastructure as “pets”—custom, hand-configured systems—to treating it as “cattle”—standardized, scalable, and disposable resources. Tools like Terraform, Kubernetes, Docker, and Prometheus play a key role in creating resilient systems that support modern software deployment strategies. By implementing these practices, companies like Acima have been able to scale deployments from quarterly releases to multiple times per day, improving reliability and developer efficiency.

The episode wraps up with a discussion on future innovations in DevOps, particularly the pursuit of fully dynamic environments where developers can spin up isolated test environments on demand. The team acknowledges challenges like managing stateful applications, dealing with legacy infrastructure, and ensuring effective observability, but remains optimistic about advances in AI, cloud-native tooling, and automation frameworks. As organizations continue to refine their DevOps strategies, the goal is to build systems that are not only scalable and efficient but also reduce complexity and operational overhead, allowing developers to focus on building great software.

Transcript:

MIKE: Hello and welcome to another episode of the Acima Development Podcast. I'm Mike. I am hosting again today, and I've got a panel with me here today of Justin Caldwell, who's coming to us from the cloud engineering DevOps side. Kyle who has been on here a lot before also from DevOps. We've got Justin, Justin Ellis, who has been here before, and we've got Will Archer. And we've got Eddy.

As usual, I'm going to tell a story to lead us in here to kind of launch our discussion. Oh, I don't know how many years ago, a lot of years ago [laughs], I worked at a sheet metal shop where we made bubble gum machines. You've probably seen a vending machine where you put in a quarter, and the bubble gum ball does a lot of things before it makes it down. We made, like, roller coaster-type things. So, the bubble gum ball would drop in the top, and it would roll around and do some loops and stuff, and it would come out.

And it's interesting to actually make one of those. There's a sheet metal around the side. We'd use the wire, and we'd actually stretch it out so it would bend better [chuckles] and curl it around a jig. Anyway, there was a lot of work that went into it. And then when you run it, you go through all the work to see that bubble gum ball roll all the way down the machine and come out the end. It's exciting to watch. People do it not so much for the bubblegum ball, or maybe, but to watch all of the machinery going on inside because it's fun, right? People like to watch that.

And the interesting thing about this is what you get out at the end is exactly the same as if you didn't see the machinery at all [laughs]. In either case, you got a mechanism that drops a bubblegum ball, and it comes out. And the interface is exactly the same. They probably don't have that many coin-operated [chuckles] vending machines anywhere, you know, a lot of times, you put in a card, but same deal, right?

You have a mechanism. You press the button or turn the dial, and bubblegum ball comes out. It really doesn't matter what happens in the machine. What you want to have, and this is really important, you don't want to have a weird vending machine where you have to put in something other than the quarter, right [laughs? You don't want to have some vending machine where it asks you for something in a foreign currency, for example. Like, well, that's kind of cool, but I don't carry pesos, right [laughs]?

And this is kind of the hard thing about switching over to cards, like a lot of things have done. Well, do I have a card with me? Do I have a coin? And now it's kind of flipped to the other side. Like, who carries cash [laughs]? So, it's flipped. You want to have that common interface because, otherwise, it's awkward, and nobody knows how to use it, and then you have to know what's going on inside.

If you have to know how the machine works, you've failed. The idea is to have this as a simple interface. You don't care what's going on inside. Of course, with a bubblegum machine, you care a lot because that's the main reason you're looking at is to watch the ball come down. But in the end, if it doesn't work inside, then that's a fail. What you want to do is have this simple interface that never changes. You just want that bubblegum ball to come out.

And I say this because it applies directly to how, well, to a lot of things, the interfaces between systems and software. Today we're specifically going to talk about the integration with DevOps. You may call it by different names, whatever interface that you interface with to get your infrastructure. Because there's different ways of handling this. There's times when we have people embedded into the team, so each team has their own person, and they build their own stuff. There's a way of approaching this. It's something that's called ZeroOps, where you just press the button and the thing comes out [chuckles].

DevOps provides a common interface that everybody needs to use, and nobody needs to know how that bubblegum makes it down the track because it simplifies systems so much. And we've got Justin here who's been passionate about this idea for...we were just talking on the pre-call. I've worked with Justin for 15 years [laughs], so he's been passionate about this for a long time and has built this more than once and made multiple companies really successful in terms of infrastructure because of this idea.

And I'd maybe ask Justin first to take over from here and give some thoughts, kind of launching from [chuckles] that introduction. And tell us what you think the interface with a cloud infrastructure, however your infrastructure is, maybe you have an onsite infrastructure, what is that interface supposed to look like? And why is that important?

JUSTIN ELLIS: Yeah. Thanks for the introduction. I have thought about this problem really for the past 15 years about how to build systems better, how to make software development easier. On the system side, you're thinking about availability, reliability. You're thinking about security. You've got to think about a lot of different aspects of it.

But at the end of the day, really, our main job is to enable software developers to be able to deploy code, push code out, manage their code. And they don't really care about the mechanics underneath, right? They have a job to do, and then we have a job to do. And I think about if you go back to the very first instances of kind of our field, in the '70s, people used to write on punch cards. And they'd basically create their punch cards. And then, they would create a huge stack of all these punch cards, and then they would pass these punch cards to someone called an operator.

And that operator had a very specific job. They had to, A, keep those punch cards in a very specific order. And then, they had to feed them to the machine very carefully and keep the order. You couldn't drop them. You couldn't have any of those issues. And then, the program would get executed, and then they would get the output, and then they would help return that output back to the user.

Things have changed quite a bit, and I think there's been some major movements. There's kind of those traditional IT systems where you'd have sysadmins. And then, that kind of moved into the cloud world when AWS was introduced to the world. And that also kicked off this new movement called DevOps, where it was like, hey, instead of passing it to the operator and then having the operator do everything, let's get everybody kind of involved in this process and enable developers to be able to pass this code and then also understand what's happening, what's getting tested, kind of move that forward, right?

And then, since the DevOps kind of movement mindset idea, however you want to call that, that's kind of moved into, you know, SRE is still a big style of managing systems, site reliability engineering. And then, that's kind of moved into now this new model which is very similar and kind of inherits from a lot of the previous models, which is kind of platform engineering.

And the goal on platform engineering is to create kind of a standardized platform that developers can interact with. They can put the gumball machine in. They can put the quarter in, and then their code gets built, tested, make sure everything goes well, and then that gets output to a system that you run.

So, long story short, we've gone through a lot of different movements, and I think that we'