October's Best Bugs

Bugs happen, a lot. What’s important is that you find them before they ever reach your customers. Because if they reach your customers, it can cost you, users, conversions, your reputation, or worse. Unfortunately, it's not always easy to find the bugs that your customers hate because automation or even developers can't capture the depth of behavior a user might take when interacting with your product. That's why we recommend thorough software testing done by real people on real devices. Real people will find the bugs that automation and other methods miss because they have the same perspective your customers do. This past month, our testers have been hard at work, making sure issues don't reach our customers or customers. Here are three issues they found this past month, why users don't like them, and why it's easy for automation and inhouse testing to miss them. 

A user adds a second pair of skis with different sole lengths to their cart, but the cart considers it as the same product as the one already in the cart. 

Nowadays, people expect the technology they use to understand their intentions as they use it. This is easier said than done, and this bug exemplifies it. The user added a set of ski's to their cart and specified a certain sole length. The user knows that they like the ski's to purchase another one for their partner. Their partner has different size feet so logically, they must add a new product to the cart with the appropriate size. The user goes back to the product page, enters a new sole size, and adds it to the cart. They expect the site to understand that the intended purchase is two sets of skis, both with different sole sizes. 

The website did not make the same assumption as the user. Instead, the website interpreted this second product as merely another of the same. So in the cart, suddenly, there are two sets of skis, but they both have the same sole size. No matter how many times the user tries to fix it, the site takes the sole size of the most recent submission. A customer can only do this so many times before they abandon the cart.

This issue is challenging to identify in testing because, from a particular perspective, nothing is wrong with the cart. The user can add products without problem, and when two of the same products are added to the cart, the quantity increases by one. If you were running a unit test, and regression test, it's likely that it would not raise any flags. Only a human can discern the issue, which can be boiled down to this: If you provide people with a field to personalize an item, they expect that item to be unique and for the cart to reflect that.  

App crashes when a user selects text and replaces it with a native keyboard suggestion. 

Phones have been able to complete our sentences for quite some time. But the usage of this feature used to be so minimal that issues related to it were disregarded as edge cases. The population has gotten more accustomed to it, and many people now use the feature religiously. Making an issue regarding suggested text now an experience that may make or break the application for a user. Consider the user who found this bug. The app they were using centers around inputting text and then manipulating it with an editor. The text is entered through the mobile phone's native keyboard. The user was so accustomed to editing with their suggestions that they performed this action without hesitation, and it caused the app to crash! You can imagine how frustrating it would be to stop using a feature that has become second nature to you. 

Automation can easily miss issues like this because the scenario is hard to replicate. People can have multiple keyboards added to their phone's which may mess with configuration. Each phone and OS has a different method of executing this feature. And first and foremost, a developer would have had to anticipate this issue. Automation can only find what you are looking for, and this case is so new that it's easy to overlook.  

Unable to rotate/move the camera if another tab is selected while moving an object  

The application in question allows people to place objects in a virtual room and move them around how they please. The crux is that the user feels like they can see themselves in the space and see it from every angle. That makes the ability to move the camera crucial. The user who found this bug was doing precisely that, moving the camera in every which way. While doing this, suddenly, the camera stopped working. Luckily the tester was a professional and was able to identify why the issue happened. When moving the camera around, their finger accidentally brushed a tab to select a new object. If the user did this while moving the camera, it would freeze and never regain functionality. Now imagine if the average user came across this bug. They may never identify the reason and dismiss the app as buggy and delete it. But it's also likely that this bug would happen to many! I can't even count how many times I've pressed the wrong button on my tiny phone screen.  

So what happens when automation checks the camera feature of this application? It will likely perform all the actions that the user makes, with one crucial difference, it won't make mistakes. It will merely execute the scenarios given to them. Ff you didn't consider a misinput, then you would have never found this bug. Real users make mistakes all the time, so this issue is an important reminder to always plan for when things go wrong, not just what happens when things go right. 

Bugs like these are why companies trust our testers to find the bugs that their team and automation misses. Because who better to test your software than real users on real devices?

If you want to see what kind of bugs our crowd can find on your website or app, reach out here.