Every job comes with some element of fear. For developers, that fear could be deployments. Anytime you push new code out into production, there's always a chance of bugs, even if you tested it thoroughly in staging.
In this article, we'll discuss how fear might play a role in the developer's life and what steps you can take to overcome deployment anxiety.
What is fear?
Fear manifests in different ways and can often present itself as anxiety, nervousness, or a feeling of horror or dread. When met with such emotions, there are three ways people tend to respond.
According to "The Biology of Fear," by Ralph Adolphs, humans respond to fear depending on various variables. Within this experiment, Adolphs correlated fear scenarios with behavioral responses such as attacking, running, freezing, risk assessment, screaming, and hiding.
Here are a few examples:
- If something is dangerous, people tend to respond in one of two ways: screaming or running. Of course, a developer won't yell at you (we hope…), but perhaps they tend to procrastinate if the project they're working on is considered "dangerous" to the product itself.
- If what we fear is an inescapable fact, then attacking the threat head-on is the most likely response. An example could be a sudden bug that causes the application to shut down unexpectedly. In a case like this, whoever is on call will feel inclined to take the initiative and attack the problem head-on.
- If what we fear is distant in time or place, we're likely to respond by trying to hide from it. Once again, procrastination.
We highly encourage you to check out Table 3 within “The Biology of Fear” article. It goes way more in depth into how behaviors change depending on fear scenarios.
Now that we know a bit more about how fear might manifest itself within your team, here are a few ways you can reduce anxiety surrounding deployments.
How to reduce fear of deployments
To create excellent and up-to-date software, you must continue launching new features, deploying code, and making changes to the architecture. But, with the upcoming deployment, your team is nervous, and you're unsure how to put their minds at ease.
Here are a few best practices you can use to help cultivate an atmosphere of fearless deployments:
Go with small, iterative releases
When a team is already nervous about deploying code, deploying huge chunks of code via the Big Bang model may not be the best approach. Too many variables are at play, and the outcomes are too uncertain.
Instead, it would be best if you opted for the iterative model. An iterative approach allows you to release smaller batches of code in increments, resulting in a gradually evolving product. Less can go wrong with this approach, and rollbacks are simpler.
Automate tasks and deployments
Due to how many moving parts are involved in deploying code, automating as much as possible will ease some of the anxiety your developers might have about new deployments. The benefit of automation is that it creates a repeatable process that will earn trust as it gets repeatedly executed successfully. The unknown parts of a deployment will be more oriented around the new code.
Once you've automated tasks involved in deploying code, your team will have less to worry about.
Ensure new features run smoothly with canary releases
Canary releases will also reduce the fear of deployments. By investing in canary releases, code is gradually rolled out to a small number of users to give developers on your team time to monitor metrics and receive feedback. Canary releases gives your team a safety net and allows for spotting coding errors before it is fully in production.
Invest in error monitoring
We cannot stress this enough (and, yeah, we might be slightly biased here), but you should invest in an error-monitoring product. Error monitoring is designed to find and alert you about bugs within your code. Not only that, but your error monitoring product should also be able to tell you which deploys introduced errors, that way, you can easily roll back if necessary.
Encourage a culture that supports growth
Failure will happen. While it might be rare if you're careful about how you deploy new code, bugs will slip through. Ensure your team is ready for this by training them on handling an incident early—one of our favorite methods to do this is chaos engineering.
Chaos engineering forces incidences and outages, giving developers time to practice how they'll respond to failures. That way, they'll be ready when one does happen in real life!
In addition to chaos engineering, you should strive to develop a culture that encourages us to learn from our mistakes via post-mortems. Use failure as a learning opportunity to prevent these mistakes in the future.
Problems will happen and if we prepare a way out if that happens, stress and anxiety will be reduced.
Hopefully, this article presented some ideas that will allow you to minimize stress and fear of deployments among your software engineering team.
Remember when we discussed how you should invest in an error-monitoring system? Give Airbrake Error and Performance Monitoring a try! Airbrake is an excellent addition to any tool stack because we immediately alert you to any bugs within your system and what deploys caused those errors.
See for yourself and create your free Airbrake dev account!