You’ve got a bug in your product, and the clock is ticking. Your customers are irate, a group of disgruntled bosses is muttering nearby, and you’re expected to keep your calm and figure out what went wrong.

Fixing production issues may be a frightening—and overwhelming—experience. The key is to make the space you need to complete your task and to work deliberately. Here are a few tips to keep you cool when fixing even the most horrific production bug.

Give yourself the room you need to debug properly

While some people thrive under duress, most developers work considerably more efficiently when they are not stressed. When confronted with a terrifying production bug, the first thing you should do is try to make space for yourself to work without feeling rushed. Here are some ideas for how to go about it.

1. Acknowledge the issue publicly

Tell your users that anything is wrong unless the problem is security-related. Nothing is more frustrating for a user than not knowing what’s going on. Tell them so they’re aware of the situation.

GitHub is an excellent example of a website with a status page that informs people when it is experiencing problems. You could send a bot a message to give your users status updates if you use ChatOps magic.

2. Find a quick fix

If you’re lucky, you’ll come up with a solution to the problem that you can implement fast. If that’s the case, don’t stress about coming up with the perfect solution—just ship the repair! You’ll have fewer affected users once it’s life, and the complaining managers can go moan somewhere else while you dig a little deeper to figure out what’s causing the problem—and correctly fix it.

3. Find a workaround

Sometimes the broken functionality isn’t the only option to complete a task. If this is the case, use any communication channels you have to inform people of other options for obtaining what they require so they may continue working. The solution will most likely be cumbersome and slow, and it may require completing things offline (for example, over the phone or in-person), but at least you’ve provided them with a choice.

4. Switch off broken features

Remove the “Pay” button from your website if the payment feature isn’t working. Remove the search bar if the search tool isn’t working. Sure, users won’t be able to accomplish everything they want, but the functionality that does remain is something they can trust, and you won’t be bombarded with fresh logs and alarms.

This is a wonderful technique to prevent things from growing worse if the problem is constantly inflicting damage, such as creating bad data. In the worst-case situation, instead of your home page, you can display a large “we’re down for maintenance” statement and/or redirect it to your company’s Facebook or Twitter profile.

Work methodically

You should have more time to focus and get the work done now that you’ve cut through some of the confusion. I find that making a list of tasks to complete makes me feel more in control. Here’s a quick checklist to follow when you’re trying to figure out what’s causing a bug.

1. Get a second set of eyes on the problem

It’s always better to have two sets of eyes than one, so find someone to collaborate with. This will help you stay on course and reduce the chances of you ending up at a dead end.

If you’re lucky, your companion will be as knowledgeable about the system as you are. If not, he or she will still assist you in staying on track—and will be learning about the system, so there will be less strain on you next time. You’ll be grateful even if the second person’s only job is to shoo away nosy supervisors!

2. Reproduce the issue

The best method to ensure your success is to replicate the problem, preferably locally. When you can make bugs appear at will, they become far less mysterious. It also means you’ll know for sure when you’ve fixed them because you’ll be able to show the bug happening—and then not happening—before and after the patch is applied.

3. Eliminate the obvious

It’s typically the things about which we instinctively say, “Nah, that can’t be it,” that is to blame, so just five minutes to make a list of the most obvious likely causes will save you a lot of time.

When it comes to determining what is generating problems, developers have a strong sense. They, on the other hand, frequently disregard their own suspicions without discussing them. Make a list of them to compel yourself to think about them.

4. List all the layers and players

It’s easy to overlook a load balancer or a piece of middleware that validates a user’s cookie in a system that you don’t typically alter or think about. Making a list of the stacks through which a user requests traverses can help you extend your thoughts and uncover probable culprits that you might otherwise overlook.

5. Find what’s changed

Bugs that have existed for a long time without causing harm will most likely have come to your attention as a result of a change in the environment. To see what has changed recently, look into the source control and deployment history.

Are any commit messages or deployments suspicious? This method has helped me uncover issues more quickly in the past.

If you don’t see anything evident, check your list of layers and players to see if the modification was made in the code you’re responsible for. Ask around to see if any other systems have lately been updated.

6. Think about next time

Take some time after you’ve corrected a bug to make adjustments that will improve your life in the future. Create a test that will catch the bug if it reappears. Add any additional logs or documentation that you wish you had. You’ll be glad you did it later!

Bugs don’t have to be scary

Because of how we react to production defects, fixing them can be difficult. It does not have to be this. Remember to begin by concentrating on activities that relieve stress in the circumstance. Then, equipped with a checklist of procedures to keep you calm and focused, you’ll be able to repair errors faster and with less stress.

For more info:

Also Read: