The problem with industry buzzwords like "DevOps" is that companies feel they need to attach themselves to them in order to remain relevant and retain talent. While wanting to be on the cutting edge of technology is admirable for any company, too often it leads down a path of adopting concepts they don’t fully understand and aren’t prepared for.
DevOps is one of those industry buzzwords that many companies have been eager to embrace, but not every company has fully understood exactly what it takes to prepare for DevOps adjustment and whether it’s relevant to their business.
So, why would your company want to adopt a DevOps methodology? The core concept behind DevOps is that it shortens system development lifecycles and provides continuous high-quality updates to clients. It’s software development that meets the customer need to have everything now while ensuring that the software is robust and secure enough to meet the various challenges required in a competitive software landscape.
Achieving a DevOps methodology requires development teams to be able to make software changes quickly, have them tested, be empowered to deploy them to production, and provide the necessary support. It sounds complex and risky – and it can be if companies aren’t prepared for it.
Before companies make the crucial decision to go the DevOps route, it’s important that they look at the following cultural and technical factors and decide if they’re prepared to make these changes to ensure that their teams are ready to tackle the world of DevOps.
Understanding Your Customer
At the heart of DevOps is the ability to meet your customers' needs more quickly and also support those needs more directly. Before you even consider bringing your technical teams into the DevOps space, you need to ensure that you bring them closer to your customers. Whether through engaging existing support teams, speaking to customers directly, or conducting customer surveys, your development team should start thinking and designing for customer needs, be aware of their support needs, and ultimately start working towards these goals collaboratively.
Appetite for Risk
Appetite for risk is something that is not often considered in the DevOps space. It’s not that DevOps is riskier; in fact, smaller, more frequent releases are less risky than larger less-frequent releases. However, the ability to support production directly or release updates quickly requires a certain tolerance for risk. While many teams can embrace the DevOps philosophy, those responsible for payments, security, or other financial and legal obligations will probably not be too enthusiastic about jumping on the DevOps bandwagon. I’m not saying this can’t be done, but a lot of things need to be put in place to mitigate the risks.
When teams start to support their code in production, accountability becomes an important part of a company’s culture. No longer can their code be deployed to production and left in the hands of a support team; no longer can their code be handed to others without dealing with the repercussions. It’s essential to introduce an environment of ownership where teams are prepared to not just support software at a range of different hours but also to own up to their mistakes when their code push causes issues elsewhere and take responsibility for addressing it. Teams must ensure that their app is tested sufficiently before deployment and has taken into consideration all the external dependencies. This leads to the need for strict exit criteria.
Strict Exit Criteria
While most DevOps teams try to avoid restrictive processes for the sake of improving efficiency, strict guidelines must be implemented to determine when a piece of software can be deployed into production. If the architecture and automation testing is done correctly, this does not need to slow a team down. But teams shouldn’t be in the habit of skipping processes. Instead, they should ensure that the different testing and audit mechanisms are allowed to do their job. You don’t want a DevOps team full of cowboys.
Looking for a DevOps-focused solution?
Perhaps the biggest barrier for a development team is the skill set required to maintain an application in production rather than developing for it. In addition to the technical skills around the different OS platforms and bash scripting, it’s essential to understand the underlying server infrastructure that supports the applications, know where and how to troubleshoot across the different environments, and importantly, have the ability to fix problems quickly. These are skills that not every developer may want to acquire, but they’re needed if they want to support their applications in production.
Test automation is at the center of achieving uptime and faster delivery and support. So, if your automation coverage isn’t great or is a little too unreliable, fix that first. The success of your project depends on having testers who can get involved at the unit test or component leave automation phase, and who are technically competent to debug issues and quickly script automated tests to cover them.
High Code Coverage
Along with automation comes the ability to measure your code and functional coverage and specifically identify where your gaps are. While 100% code coverage doesn’t mean it works, it does provide a strong sense of comfort in your regression efforts, so before teams look into achieving DevOps capacity, they should address their code coverage.
Monitoring and Alerting
Monitoring is at the crux of understanding how a system operates in production and being able to respond to failures. As such your development teams should invest in tools that can identify when services might go down and can assess system performances and hardware resources to ensure that service capacity and application performance remain optimal. These essentials should form part of your definition of "complete" to ensure that any code you put into production can be maintained correctly. Code that cannot be monitored should never go live, and it’s important that teams develop this habit and this capability if they want to embrace DevOps.
Load and Performance
The monitoring mentioned above speaks volumes about the ability to measure a system’s load and performance and allow a team to respond proactively. However, you shouldn’t rely on your monitoring or ability to scale to address this, because at times (and especially if you’re using a cloud service provider) this can end up being very expensive. So, before the code is even delivered, you must be able to optimize this. Having a good performance and load test framework in place that can identify the optimization of your systems, frontend, backend, network, and databases every day reduces the risk of introducing performance issues into production.
Ability to Recover
No matter how good your testing efforts are, at some point things might go wrong and teams will miss something. Being able to identify and recover from failure is critical; so your deployment systems need to allow for easy and effective rollback with the code designed in as modular a fashion as possible to limit subsequent risk on dependencies.
The pipeline is essentially the lifeblood of your development framework, taking your code to various stages and testing it there. However, your pipeline is only as stable as the underlying code and container infrastructure it runs on; thus, it’s important that your team ensures that your pipelines run reliably. This enables you to put in urgent fixes without needing to spend time addressing pipeline issues that prevent you from doing so.
DevOps is more a philosophy than a methodology. It’s a lifestyle that companies and teams need to align with and feel comfortable about more than just a development approach. Consequently, it is important that you look at your team as a whole and assess the software to see how it’s built, tested, and deployed to evaluate if this is really the correct approach for your company/team. If you’re willing to pursue DevOps, perhaps this article can give you a roadmap for how you can get there.