Agile vs DevOps: Merging Fail-Fast Agile with Well-Planned DevOps
Fail-fast Agile and well-planned DevOps are the two sides of a single coin, though they are not essentially the same. Merging them is possible through understanding their core values and practices.
Agile has adopted fail-fast approach long ago. This means the developers tend to experiment freely when trying to reach the desired outcomes, but they are also quick to abandon the development lines that do not bring the desired results. Doing so allows minimizing the risks both for the customers and for the software development teams while ensuring more predictable software delivery process. This also raises the chances for the customers to get what they expect, under the estimated budget and within the timeframes.
On the other hand, such experiments in DevOps are not recommended, as the costs of operating the infrastructure can amount to tens of thousands of USD daily, and playing around with the production environment for the sake of experimenting cannot be justified. This is why before provisioning the infrastructure the DevOps team must define the project’s structure, scope, main requirements, possible scalability issues and the ways to ensure resilience and immutability.
All of this will be essential to both deliver the software on time and ensure positive customer experience afterward, as unlike traditional Agile developers, DevOps engineers are responsible for the full software lifecycle, from the design to the maintenance and final decommissioning. Thus said, merging these two methodologies is impossible without answering several painful questions:
- What practices have to be adopted?
- What practices have to be ditched?
- Who will do what in the team?
- What skills and tools will we need to master?
- How do we start doing DevOps after all?
There are both short and long answers to these questions. The short one is “”. The long one is below.
How to merge Agile with DevOps
The main thing to keep in mind is that these two approaches cannot be combined in their pure forms, meaning the Agile practices must be updated.
- The most important practices to adopt are the three cornerstones of DevOps: continuous integration of new code batches into a centralized mainline; continuous delivery of new builds to testing environments and pushing them into production through rolling updates; and building infrastructure as code, where the containerized apps can be deployed to production environments that are described in clear and declarative language, where the servers are provisioned, configured, managed and decommissioned through code commands, not manually. The last, but not the least important practice is building automated unit tests from the get-go, instead of leaving the testing to be the pre-release stage of the software development lifecycle.
- The most important practices to be abandoned are following multiple Agile methodologies, like Scrum project management. Scrum is about micromanagement, where each team member announces what was done since the last Scrum, and if there are any bottlenecks for going forward that lie outside the scope of their responsibility. True DevOps engineers care little about the scopes, as these are cross-functional teams, so every team member devotes their effort to overcome the challenge at hand, having a clear overall picture in mind. In addition, every bottleneck is perceived as a system flaw that provides a room for improvement, not as a team member’s fault.
- As it is clear from the above, there are no strictly defined roles in DevOps teams, as the same person can build the infrastructure, configure the CI/CD pipeline and handle the customer’s support request. This means that on the road to world they have to learn to do multiple kinds of tasks using multiple kinds of tools and forming all-around capable teams.
- Evidently, both the Dev and Ops tools must be available to every team member and they must be able to use them. Cross-team training and learning are essential in mastering the full kit of for project management, communication, and collaboration; software development, testing, deployment, and monitoring; infrastructure design, scaling, and maintenance; customer feedback collection and application.
- The key point in merging Agile and DevOps is accepting the different mindset. The is built around “you built it, you run it” paradigm, meaning the DevOps teams are responsible for the full range of software delivery-related processes and tasks. Such approach to business workflows must have a wholehearted support from the grassroots all the way up to the C-suite, as it will be a sure way to failure otherwise.
Conclusions on merging Agile with DevOps
Agile as a methodology of software delivery has long ago transformed into something that greatly contradicts the core values and principles explained in. However, this approach to project management is still much better than Waterfall and other old-school methods. The acceptance of “fail fast, fail often” mindset ensures the iterative approach to software delivery, where rapid customer feedback loops help the developers better direct their efforts and deliver the features the customers really expect.
This same iterative approach is greatly empowered through CI/CD, where the automation of code batch building, testing and pushing to production ensures uninterrupted customer experience, fewer bugs and shorter recovery times, according to the report.
Merging these two paradigms is no easy deal, yet if applied correctly, your Agile development teams can benefit greatly by becoming much more competent and competitive in the fast-paced business world we live in. We hope this article will be of use to you and in case you want us to explore some other topics — please name them in the comments below, we will cover them in the future articles!