How to build your DevOps team with Agile culture

DevOps is the modern convergence of people, processes and tools to create a continuous software delivery stream. Much like the code it produces, the concept of DevOps itself is continuously adapting to encompass new ideas, methods, and technologies. So what can we expect from the DevOps cultural shift in the future?

The delivery stream of yesterday was a segmented process, often separating key teams and concepts into silos where people focused on their individual tasks. Coders coded, testers tested, and security experts secured the app and environments. But new and evolving DevOps process have begun to merge these silos into one team where members collaborate from concept through delivery.

Agile methodologies provide perfect experience for adapting and evolving to a DevOps continuous delivery culture.

More importantly, today’s DevOps engineers don’t view the delivery process as linear, with a beginning and an end. Rather, the teams work simultaneously and in parallel on various facets of the work-stream. Continuous improvement, testing, and delivery have become the new gold standards, with production releases happening daily rather than monthly or quarterly. Below are some tips on building a DevOps culture geared toward continuous deployment.

An Agile approach to DevOps

Some have argued that Agile and DevOps approaches conflict, with some aspects of their execution interfering with or negating each other. But in reality, an evolved DevOps culture closely mirrors the practices of an Agile one, especially by prioritizing human interaction.

In particular, DevOps and Agile are compatible because of their shared emphasis on feedback loops or iterative processes. This way, necessary adjustments or corrections can be made on a continual basis.

Let’s compare the four key values from the Agile Manifesto to partner principles in DevOps.

1. Individuals and interactions over processes and tools

   This tenet of Agile merges seamlessly with the DevOps practice of focusing on the people around which the interactions and tools will orbit. Both philosophies emphasize regular and empowered interaction between team members.

2. Working software over comprehensive documentation

   Agile and DevOps environments make it harder to document each change, because change is constantly occurring. This doesn’t negate the need for thorough and accurate logging, but a circular cycle of identifying and deploying improvements makes deep documentation of each change counterproductive.

3. Customer collaboration over contract negotiation

   An often misunderstood aspect of Agile development, this principle perfectly fits the DevOps approach to treating the product as a constant work in progress, rather than one hard delivery on a predetermined schedule. This doesn’t mean teams can ignore basic business goals or principles; customers will still expect deliverables on deadlines.

   However, by approaching delivery as an interactive process where the client works with development teams to identify problems and suggest and implement improvements, DevOps practices organically layer value using an Agile approach.

4. Responding to change over following a plan

   Agile and DevOps both highlight the need to identify and fix problems rather than following a static troubleshooting flowchart that may have been last updated several releases ago and no longer reflects the active environment. In a continuous delivery model, new innovations will produce the unforeseen.

   Being agile requires listening to and responding to feedback. Agile thinking helps DevOps teams operate more fluidly, using Scrums, Sprints, and powerful DevOps tools to find and fix problems as they occur, in real-time.

The evolution of Agile: How traditional DevOps roles are changing

This is not to say that Agile practice and DevOps are the same thing. As a powerful development movement for almost two decades, Agile methodology informed and shaped DevOps philosophy. But DevOps reduces the process and information silos that exist between continuous integration at the developer level, and extending throughout the application lifecycle to include QA, production release, operational management, and more. In a successful DevOps approach, all of these roles are aligned on a single goal - serving the end user. And the team achieves this together, using an iterative and collaborative approach to modernizing their applications and practices.

Each individual in an efficient DevOps culture interacts with and depends upon other team members to move the team forward. Most agile shops have adopted three approaches for implementing DevOps and continuous delivery models.

1. Close collaboration. Rather than building silos between development and operational teams, daily communication and collaboration in all aspects of the delivery process give all team members the opportunity to walk in their colleagues’ shoes. In doing so all team members better understand individual challenges and can collaborate on fixes and improvements in each step of delivery.
2. Feedback loops. This approach goes beyond simply notifying a developer when a build fails, but addresses what happens after that fact. By keeping honest feedback flowing between all teams (end users, product management, engineering, marketing, sales) teams can respond more quickly (and more appropriately) to any changes in the market. Feedback exists at many levels - from management sharing strategic plans, to technical teams monitoring the health of an application before and after a deployment.
3. Cross-functional team. The cross-functional approach takes the power of dedicated teams but staffs them with decision-making representatives from each discipline, enhancing team autonomy and allowing them to swarm problems and make decisions in real time.

For many organizations, one or all of these team approaches will prove the most effective. The key to achieving harmony between Agile and DevOps methodology is remembering the essential principle of the elastic human interactions in both.

Pushing quality closer to the source via Agile DevOps

A latent problem in software development can and often does become an emergency in production. But by then the problem has moved one or more steps away from its origin and the people who can fix it. The farther a problem moves from the source, the harder and more expensive it is to correct.

The DevOps principle of pushing quality closer to the source is achieved through fast feedback, constant interaction and peer review between stakeholders, including:

• Development

• Quality assurance and testing

• Security

• Production

• Other assets

Agile practices like Scrums and daily standups help create group awareness and ownership of problems. This eliminates time-consuming negotiations between silos and delays for management approval and pushes quality closer to the people charged with controlling it.

Create a DevOps 2.0 culture

As classic distinctions between the development team and operations team continue to dissolve in environments that call for continuous delivery, it will take cultural change, team-building, and the right tools to adapt. Remember that no matter how sophisticated your environment, processes, and tools are, it’s the people behind them that shape change into effective, forward-looking and successful DevOps culture and best practices.