Help! I Can't Recreate My Customer's Bugs

Recreate Customer Bugs

There’s an inevitable moment that comes after you’ve released your app. A user does something. Something that your app doesn’t like. And it crashes. 

But, when you try and recreate the bug, nothing happens. You try again and you still can’t make it crash. The bug seems lost in the disconnect between what happens during production and what happens in real life. 

The really frustrating thing here isn’t that there’s a bug in your app. The issue is you’re not able to fix that problem. 

Worse, if too many bugs pile up and you can’t solve them fast enough, or even recreate them, more users are going to notice. After a while, it’s going to erode their trust in your app.

They’re going to stop buying it. Some are going to post negative reviews. 

It’s going to start costing you money as users churn because your app is too buggy. 

But, there is no need to panic just yet. In fact, recreating customer bugs can be done, and it is possible to find those pesky software defects that slipped through the cracks. 

To help solve this problem, let’s first look at the factors that could be preventing you from fixing the bug.

3 reasons why you can’t recreate the bug

We see this all the time. We know how frustrating it is when you can’t recreate the customer’s problem. 

What we’ve discovered is that there are three common reasons why you can’t recreate the bug and fix it.

1. You’ve got a mystery bug 

This one sounds cooler than it is. A mystery bug is when you know something is happening, but you don’t have enough information to recreate the fault.

Sometimes support doesn’t collect enough information. Or the customer wasn’t paying close attention to what they were doing at the time. Something just crashed and they reported it.

You don’t know anything about the device, the OS, what was happening when it crashed, or any of the relevant information you need to solve the problem. Figuring out a mystery bug involves a lot of guessing and time you usually don’t have.

2. You’re missing a key piece of information 

In this scenario, you know the steps the user took that led to the crash in the first place.

But when you do it, nothing happens.

You’re missing some crucial piece of the puzzle here. This could be what operating system they were using, what device (older or newer), things like that. Those important pieces of information that allow you to accurately recreate the bug.

It’s possible to figure out what you’re missing here. But it’s expensive to do so.

3. You just don’t have time

 This is a common problem. You could know exactly what you need to do and even how to go about fixing the bug. But you just don’t have the time to go in and fix it.

Odds are, if this is the case, you’ve got other bugs you don’t have time to fix, as well.

Some ways you can deal with this

Now that you know what’s going on, there’s some good news - there are things you can do to fix these bugs. 

When you have a known defect, you can get several testers working on the problem at once.

By putting several testers on the problem, you’re able to build more confidence in the process and the results. You have multiple people working through the steps, identifying the issues, and helping you collect as much data on the problem as possible.

You want to get yourself into a position where you understand the heart of the problem and solve it fast.

As we hinted in the last point, you need to collect more logs. The more information you collect about a problem, the better equipped you are to deal with the bug.

You want crash logs, app logs, proxy logs, basically whatever you collect to help figure out the problem.

Your goal is to gather up the information you need, analyze the data, and pinpoint the moment things go wrong.

Finally, you need to execute testing during production. Here, you’ve already solved the issue (or think you have). But you want someone to come in and go through everything again to make sure that it’s not going to happen again.

This one is really useful when you don’t have enough time to manage the whole process. 

Getting a handle on bugs

Ultimately, your goal is to eliminate the gap between production and reality. You want users to experience things the way you did before you released your app into the wild. 

That’s a challenge, though, especially if you don’t have the capacity to test everything across all devices, operating systems, and configurations. When users do discover bugs, it can be hard to recreate. There are countless user configurations out there and configuring on a user-by-user basis can get expensive when you have a small in-house testing team.

So what can be done (without just hiring more testers)?

This is where crowdtesting can be useful. 

At Global App Testing, we have a team of 40,000+ professional testers in over 105 different countries. If you need to get someone running tests on a specific device, under specific circumstances, we can help. 

Same if you’ve got a mystery bug situation. We can quickly and effectively go through your app, collect the data points that you need, and help you pinpoint the bug.

You can even do one last round of testing before you re-release your app to make sure that the bug is gone. Our team is dynamic enough to handle any situation you may come across.

And, we can make this happen faster and then adding more testers to an in-house team. 

If you want to find out how Global App Testing can help you recreate those bugs you can’t find and stop them, fast, let’s talk

We’d love to help you create a stronger app.

Was this article useful?

Great! We'd love to send you more articles like this

Subscribe

white-dots-small@2x

Join 24,389 people who already get the latest QA advice - unsubscribe any time!