We recently took a DevOps poll of 1,000 IT professionals to get a pulse for where the industry sits regarding the adoption and completeness of vision around DevOps. The results were pretty interesting, and overall we are able to deduce that a large majority of the organizations who answered the survey are not truly practicing DevOps. Part of this may be due to the lack of clarity on what DevOps really is. I’ll take a second to summarize it as succinctly as possible here.
DevOps is the practice of operations and development engineers participating together in the entire service lifecycle, from design through the development process to production support. This includes, but is not limited to, the culture, tools, organization, and practices required to accomplish this amalgamated methodology of delivering IT services.
In order to practice DevOps you must be in a DevOps state of mind and embrace its values and mantras unwaveringly.
The first thing that jumped out at me from our survey was the responses to the question “Within your organization, do separate teams manage infrastructure/operations and application development?” 78.2% of respondents answered “Yes” to that question. Truly practicing DevOps requires that the infrastructure and applications are managed within the context of the same team, so we can deduce that at least 78.2% of the respondents’ companies are not truly practicing DevOps. Perhaps they are using some infrastructure-as-code tools, some forms of automation, or even have CI/CD pipelines in place, but those things alone do not define DevOps.
Speaking of infrastructure-as-code… Another question, “How is your infrastructure deployed and managed?” had nearly 60% of respondents answering that they were utilizing infrastructure-as-code tools (e.g. Terraform, Configuration Management, Kubernetes) to manage their infrastructure, which is positive, but shows the disconnect between the use of DevOps tools and actually practicing DevOps (as noted in the previous paragraph).
On the other hand, just over 38% of respondents indicated that they are managing infrastructure manually (e.g. through the console), which means not only are they not practicing DevOps they aren’t even managing their infrastructure in a way that will ever be compatible with DevOps… yikes. The good news is that tools like Terraform allow you to import existing manually deployed infrastructure where it can then be managed as code and handled as “immutable infrastructure.” Manually deploying anything is a DevOps anti-pattern and must be avoided at all costs.
Aside from infrastructure we had several questions around application development and deployment as it pertains to DevOps. Testing code appears to be an area where a majority of respondents are staying proactive in a way that would be beneficial to a DevOps practice. The question “What is your approach to writing tests?” had the following breakdown on its answers:
- We don’t really test: 10.90%
- We get to it if/when we have time: 15.20%
- We require some percentage of code to be covered by tests before it is ready for production: 32.10%
- We require comprehensive unit and integration testing before code is pushed to production: 31.10%
- Rigid TDD/BDD/ATDD/STDD approach – write tests first & develop code to meet those test requirements: 10.70%
We can see that around 75% of respondents are doing some form of consistent testing, which will go a long way in helping build out a DevOps practice, but a staggering 25% of respondents have little or no testing of code in place today (ouch!). Another question “How is application code deployed and managed?” shows that around 30% of respondents are using a completely manual process for application deployment and the remaining 70% are using some form of an automated pipeline. Again, the 70% is a positive sign for those wanting to embrace DevOps, but there is still a massive chunk at 30% who will have to build out automation around testing, building, and deploying code.
Another important factor in managing services the DevOps way is to have all your environments mirror each other. In response to the question “How well do your environments (e.g. dev, test, prod) mirror one another?” around 28% of respondents indicated that their environments are managed completely independently of each other. Another 47% indicated that “they share some portion of code but are not managed through identical code bases and processes,” and the remaining 25% are doing it properly by “managed identically using same code & processes employing variables to differentiate environments.” Lots of room for improvement in this area when organizations decide they are ready to embrace the DevOps way.
Our last question in the survey was “How are you notified when an application/process/system fails?” and I found the answers a bit staggering. Over 21% of respondents indicated that they are notified of outages by the end user. It’s pretty surprising to see that large of a percentage utilizing such a reactionary method of service monitoring.
Another 32% responded that “someone in operation is watching a dashboard,” which isn’t as surprising but will definitely be something that needs to be addressed when shifting to a DevOps approach. Another 23% are using third-party tools like NewRelic and Pingdom to monitor their apps. Once again, we have that savvy ~25% group who are currently operating in a way that bodes well for DevOps adoption by answering “Monitoring is built into the pipeline, apps and infrastructure. Notifications are sent immediately.” The twenty-five-percenters are definitely on the right path if they aren’t already practicing DevOps today.
In summary, we have been able to deduce from our survey that, at best, around 25% of the respondents are actually engaging in a DevOps practice today. For more details on the results of our survey, download our infographic.
-Ryan Kennedy, Principal Cloud Automation Architect