We’ve all been there. You stare at an application that was built over the last four or five years. You look at the code, which is ugly, full of all sorts of workarounds and hacks built up over time, and you say to yourself, “If we just rewrite this from scratch, it will fix a whole bunch of edge cases and be easier to maintain.” But most of the time, starting over is the wrong approach.
That’s even more true when you look at creating a team to work in a more DevOps-y manner. People think of some platonic ideal of a DevOps team and say, “If we just hire people with these skills, everything will be perfect.” They look at the current state of affairs between developers and IT and say, “There’s no way we can get from here to DevOps with the people we have. Let’s start over.”
The people with the skills and experience you need to create a DevOps team are probably already in your organization. In our 2014 State of DevOps report, 57 percent of of our 9,200+ survey respondents said they were already using DevOps practices, compared with 16 percent who said they were part of a DevOps department. It’s pretty clear that you don’t have to be in a named DevOps department to be committed to using these practices. Since the term “DevOps” is pretty recent, but the practices are not, it’s also safe to assume that these named departments weren’t formed by a super class of engineers, but by people who were practicing DevOps before it was a thing.
Starting over is a clean-slate approach
People want to replace the team for the same reason that they want to replace all of their code: “Our application is warty.” All working code has bugs, workarounds and messy encounters with reality. Sure, some of your workarounds can disappear with a new design, but it’s not likely all of them will. Most of us feel a strong temptation from time to time to chuck it all, and start from scratch as if nothing were already in place — design and build a new, clean pristine system, and move forward from there.
Bringing in a new team to support DevOps is also a clean-slate approach, and it’s one that guarantees you will lose all the accumulated domain knowledge you have built up over the years: knowledge of the code base, of the business needs that drove development of this code base, and of how to work with others across the company. All this knowledge is not only valuable, it’s critical. A team of new people, whatever their technical skills, don’t have that knowledge, and can’t obtain it instantly.
The problems you’re facing are not all due to particular individuals on your teams; often, they originate in your organizational culture. That’s what you need to change. However the odds are good that you already have at least some of the people you need to create a functional DevOps environment. After all, your team has already had some successes, otherwise you wouldn’t still be in business, and it’s likely they’ve had to work collaboratively across the dev/ops divide to achieve these. Our 2014 State of DevOps survey showed that the longer a company has been using DevOps practices, the better its IT performance. It’s likely that you have individuals and teams succeed due to practices that fall under the DevOps umbrella, even if they weren’t using that term then.
Cultural changes (especially for management)
There are cultural changes involved in bringing DevOps to an organization, and sometimes these can seem insurmountable. These changes can be harder on management than they are on staff, because they represent values that are often quite different from how management teams traditionally work, or expect their teams to work. Taking a DevOps approach requires you to be comfortable with working in the open, with a much higher degree of transparency. Managers need to enable and support different kinds of information flow, across to peers instead of, or at least in addition to, the traditional flow of information from the top of the hierarchy down, and back up through the chain of command. Managers and technical leads also need to become much more comfortable with failure on their teams, viewing it as a sign of growth and a way to learn.
How do you start building a DevOps culture? I recommend that you take a simple, easy-to-solve pain point and automate it away. Your existing staff are the ones who know what that pain point is, and you can’t automate a process without understanding what it’s meant to do.
Automating away one pain point will start the ball rolling, help staff feel more successful in their roles, and allow them to reclaim time to make further improvements. Done right, this is a self-sustaining process.
Create good interfaces between teams, and introduce reliable measurement so your team can improve day to day. That will help everyone feel greater trust in new tools and processes.
A window into what’s happening, and when
Get used to working transparently by putting in place a single and accessible ticketing system for tracking work and prioritizing it. The rest of the company should be able to see exactly what you’re doing, particularly the consumers of your services. People coming from a service desk background may have to adjust to providing more frequent updates and more details around issues, and for these updates to be visible to a much larger group than they are accustomed to.
Use your ticket system to drive buy-in across the organization. It will make prioritization of work highly visible. Anyone can go look at the ticketing system (however it is implemented), and say, “Ah, it looks like they planned to deliver this in the next two weeks but have pushed it out by a week due to an unexpected security issue.” The trust engendered by this visibility is critical when you’re trying to instill new values.
Across the silos
Get comfortable with horizontal connections in your company, with one team deciding that they need help from another, and asking for it directly. Don’t make information travel up and down a hierarchy — it’s a time-waster. Plus, remember the telephone game? The information that comes out the far end of the chain doesn’t bear much resemblance to what went in.
Encouraging people to work more laterally can be a really difficult change for a lot of managers. It doesn’t necessarily mean that they’re micromanagers; it just means they are used to information flowing up before it flows back down to another part of the organization.
Your DevOps efforts will probably fail unless your entire management team buys into the required changes, and executives recognize that they’re going to have to change the way they operate, as well.
A single source of truth
What makes large-scale system administration possible is automation and a single source of truth. That source of truth is the description of the desired state of the system.
The infrastructure-as-code movement really calls for a declarative approach: “This is the state a given machine should be in. It should have these services running, these packages installed, and configuration files that look like this.” Once you have a simple text-based description of that information, you can then check it into version control, you can create version tags, and you can cheaply maintain release discipline. At that point, you can actually start applying software engineering principles to managing infrastructure, another key DevOps principle.
What wakes you up at night?
We need to ask what causes manual work — especially work that ends up having to be done in the middle of the night — and how we can prevent it. What actually happens that makes us wake people at 3:00 AM to log onto a box and fix something? How do we prevent the change at its source? How do we test whether a given change will cause someone to be woken up at 3:00 AM to fix something?
For an operations team, these questions really matter. If you start thinking about everything framed by, “How will this behave at 3:00 AM? How will I understand what’s actually being changed?” and (better yet), “How can I stop my team from being woken up at all?” you have a pretty strong incentive to start writing effective tests.
The technical aspects of DevOps are not beyond anybody’s skills. It’s the cultural aspects that are going to make people uncomfortable up and down the line. The road to DevOps will be much smoother if you work at it incrementally to overcome these cultural discomforts, rather than throwing out all the institutional knowledge that you have, and bringing in people who are culturally comfortable with DevOps but know nothing about your business.
Just as DevOps is about incremental improvement of your infrastructure, you should be incrementally improving your people. It’s going to keep them happier, you’re going to make them more valuable employees, and it sends a really strong signal to the rest of the organization that you’re the kind of company that grows people according to organizational needs, and doesn’t just deal with change by hiring from the outside.
If you’d like to dive more into the data behind the suggestions in this article, or are looking for more concrete recommendations for managers and individual contributors, check out the 2014 State of DevOps Report
About the author
Nigel Kersten, CIO (@nigelkersten) came to Puppet Labs from Google HQ in Mountain View, where he was responsible for the design and implementation of one of the largest Puppet deployments in the world. He’s been a sysadmin for Linux and Mac deployments since before Mac OS became a UNIX, and was voted one of the 25 Most Influential People in the Mac Technical Community in 2006.