Looking to improve the way your team develops and delivers software? Well, you’ve got options. As the IT industry adopts innovative ways of working, there’s now a multitude of approaches — some of which diverge from the traditional “waterfall” method. In this blog post, we’re going to cover two of the most popular practices: DevOps and Agile.
We’ll weigh up both options, while also challenging the idea that you have to choose just one. So, whether you’re an agile user who’s curious about DevOps, or vice-versa, or you’re a newcomer to both, this article will break down everything you need to know. First, let’s introduce what each methodology is on its own.
What is Agile?
Agile is an approach to software development and project management that involves working in iterations (often referred to as sprints). It’s a way of dividing something as complex and fluid as a software project into small increments — and tackling each increment bit-by-bit.
Instead of planning the entirety of the project in the very beginning, planning in Agile takes place with each iteration or on an as-needed basis (depending on the specific framework you choose). The same goes for the developing and testing stages. Each iteration is like its own mini-project, all coming together in the end. This cyclical way of working leaves room for changes in the market, shifts in the stakeholders’ priorities, and otherwise new information.
Agile is many things: a set of principles and values, a way of thinking, a methodology, and more. There’s also more than one way to implement it.
Here are the two most popular agile frameworks you’ll likely come across:
1. Scrum, in which cross-functional teams work in sprints
2. Kanban, which is a framework that emphasizes visualization and continuous workflow.
In a nutshell, the agile approach is about being able to adapt to a volatile market and produce working software through collaboration.
What is DevOps?
On the other hand, DevOps — short for development operations — is a methodology that integrates the development side and the IT operations side of a given software project. In organizations that don’t practice DevOps, there’s typically a gap in communication between development teams and operations teams. The development team is responsible for planning, designing, and building software. When the development process is complete, the developers hand the working software off to the operations team.
The operations team is in charge of delivering the software to the working environment, monitoring the software, and providing feedback back to the developers. That feedback informs any improvements (like bug fixes and updates) that end up on the developers’ plates once again.
Many professionals in the IT industry have found this to be an inefficient way of working as the gap between the two departments creates a situation where one side is always waiting on the other, resulting in delayed feedback and updates.
For example, while the operations team is deploying and maintaining software to working environments, developers may take on new projects. By the time there’s feedback available for the first project, developers may have their hands full with their latest venture.
DevOps can offer a better, more efficient solution to software development. DevOps focuses on fostering a culture of collaboration and leveraging automation to roll out software quickly without sacrificing quality. The DevOps model is typically represented as an infinity symbol, which underscores the manner in which development and operations teams prioritize working collaboratively.
As we mentioned above, automation is integral to DevOps. Under the DevOps model, the series of steps that a product goes through from development to operations and maintenance, called the delivery pipeline, is automated. This speeds up an otherwise sluggish process, which allows for continuous delivery and improvement.
Like Agile, DevOps has many definitions depending on who you ask. Many people refer to DevOps as a culture, a set of tools, and a methodology. Some even refer to it as an extension of Agile, a concept that we’ll cover in the next section.
How are Agile and DevOps related?
To better answer the question of how Agile and DevOps are related, we need to get a bird’s eye view of the software development life cycle, or SDLC for short. This understanding demonstrates how both Agile and DevOps contribute to the overarching process in ways that complement, not oppose, each other.
A brief look into the life cycle of a software project
You might see different sources break down the software development life cycle in different ways. But when you get right down to it, all software projects involve the following seven phases:
- Planning. During the planning phase, the business stakeholders and IT department work together to lay out their objectives, define the project scope, and consider resources (like time, money, people, and equipment).
- Requirements. Like the planning phase, the requirements phase involves the business side and the development side. This is where members of both sides spell out what the requirements of the software will be in order to deem a project successful. In many cases (Agile), the requirements phase is the time to create the project backlog.
- Design. Now that the project’s requirements are clear, the architects and developers can get to work on creating designs and prototypes.
- Development. Once designs are completed and approved, the developers can turn them into reality, aka functioning software!
- Testing. During this phase, the code is tested by developers for quality and security using specialized tooling. (Hint: You can browse tools for every part of this process online at the AWS Marketplace.)
- Deployment. If code passes testing, it passes into the hands of the operations team who deploys the product into the working environment.
- Operations and maintenance: Once the software is in the hands of end-users, the operations team must continuously monitor and maintain it to ensure quality and offer feedback to the developers.
As a reminder, the “waterfall” approach to project management and software development handles these stages in a linear fashion, meaning that the completion of one stage flows into the beginning of the next stage. With an agile approach, these stages take place in cycles.
Now back to our earlier question of how Agile and DevOps are related, Agile typically stops just short of the last phase, operations and management. DevOps picks up right where Agile leaves off and carries it through the operations and maintenance stage. You could say that DevOps is a continuation of Agile.
DevOps is a continuation of the agile methodology that carries the software product down the homestretch. But another way to interpret the relationship between DevOps and Agile is by envisioning a Venn diagram, where the two approaches actually overlap in the testing and deployment phases (stages 5 and 6). To take a closer look at this critical part in the software development life cycle, we’ll introduce three concepts: continuous integration, continuous delivery, and continuous deployment.
The roles of continuous integration, continuous delivery, and continuous deployment
DevOps and Agile take similar, if not the same, approaches to testing and deployment. Testing and deployment encompass three practices that are often shared by both DevOps and Agile. These practices are called continuous integration (CI), continuous delivery (CD), and continuous deployment. Let’s take a moment to talk about each of them and how they contribute to the overarching life cycle.
Continuous integration is the practice of introducing, or integrating, code changes to the main code repository (where the code is stored) as often as possible — at least once a day. Imagine that you’ve been working tirelessly at creating a large piece of code, only to find that it does not work once you integrate it. Or worse, it “breaks” the existing code, resulting in an all-hands-on-deck situation and many lost days.
That’s why continuous integration is so valuable. Instead of waiting at the very end to combine everyone’s changes, the smallest updates are added every step of the way. This makes it easier to pinpoint exactly where the mistake is, if and when something goes wrong, and correct course easily and efficiently.
Continuous delivery and continuous deployment are very similar in that they both concern a product’s progression through the testing and production stages, ultimately getting the product into the hands of users. The difference between the two is the degree of automation. While continuous deployment is fully automated, continuous delivery is mostly automated. Under continuous delivery, the product owner or project manager must press a button in order to pass the approved code onto the next phase.
All three practices — continuous integration and continuous delivery/continuous deployment — make up the testing and deployment stages in the software development life cycle, and you can find them in both Agile and DevOps.
How Agile helps DevOps
If you’re already familiar with agile development, then you know that Agile isn’t so much a prescriptive way of working — but more so, a way of thinking. Of course, there are frameworks like Scrum that lay down structure and processes. In other words, they address how to do Agile.
But at the end of the day, Agile was created as a set of principles and values that, in turn, have an effect on the way that project managers and development teams approach their work.
Here’s a quick rundown of the values of Agile, as laid out by the creators of Agile in the original manifesto:
- Individuals and interactions over processes and tools
- Working software over comprehensive documentation
- Customer collaboration over contract negotiation
- Responding to change over following a plan
After reading these values, straight from the individuals who created Agile, it becomes very clear that Agile development places more emphasis on the culture that organizations are creating within and without their development teams.
In the same way, DevOps also draws attention to the culture of a company. There’s particular emphasis on how teams are creating an environment of collaboration, open feedback, and responsiveness to that feedback.
Agile and Devops are mentalities.
This perspective doesn’t undermine the importance of having a structured process, but acknowledges that culture actually helps to inform the process. A person who has experience working on an agile team will find that their background translates into DevOps, because they understand that having a mentality of collaboration and responsiveness is more valued than processes.
Which is better: Agile or DevOps?
We’ve made the case that Agile and DevOps can complement each other, but you might be thinking if they’re so similar, why not just choose one? Why do both have to exist?
So, let’s address why one is not better than the other, why you need both. Agile was first created to address the volatility of software. And by that, we mean how rapidly changes in the market took place and the necessity of being able to respond to those changes quickly. Hence, the name “agile”. Therefore, you can think of Agile as a way to bridge the gap between customer and developers.
DevOps, on the other hand, does not inherently address that gap between the customer and developers. Instead, it addresses the relationship between the developers and operations team.
At the end of the day, neither Agile or DevOps is the stronger contender. While they both emphasize collaboration, each does so in different ways. The good news is that they’re not mutually exclusive, so it’s definitely possible to leverage both.
DevOps in Scaled Agile Framework
To scale Agile means to widen its use. For example, if one team uses Agile and has found success with the methodology, they might want to extend it to other teams and maybe even departments. Or they might want to use it for larger projects than the projects they’ve been applying Agile to.
One of the goals of scaling Agile is to bring about more cohesion between teams since they’re using the same methodology. Agile becomes embedded into the company as a whole. So how do you actually go about doing it?
Atlassian indicates five popular frameworks for scaling Agile:
- SAFe (Scaled Agile Framework)
- LeSS (Large-Scale Scrum)
- DA (Disciplined Agile)
- Scrum@Scale (S@S)
The Scaled Agile Framework, often referred to as SAFe, is one of the most popular frameworks for implementing agile at scale — and it actually builds DevOps into its model. It does so with the CALMR approach, which stands for culture, automation, lean flow, measurement, and recovery.
By incorporating DevOps into SAFe, continuous delivery at scale becomes possible.
The bottom line
DevOps and Agile are both really strong methodologies for developing — and delivering — software applications. DevOps brings together development teams and operations teams through close collaboration and automated processes, which results in higher-quality products that take less time to create and further improve. Agile bridges the gap between the development teams and the customers by literally building the unpredictability of the market into the way that they plan and develop software applications.
Both methodologies value collaboration, responsiveness, and efficiency. And the best part? You don’t have to choose both. DevOps and Agile are really meant to complement each other, fill in the missing pieces that the other doesn’t address, and create even more value for businesses, team members, and customers.