Why App Quality is all Important
Which would you choose: an app which delights your customers and boosts your business, or one which may save hundreds of pounds in development costs but which could be vulnerable and potentially harmful to your business?
What makes an app a high quality app? It's a pretty simple question, but like most simple questions the answer is somewhat more complex. Let's start with something that's easily recognisable.
To be high quality, an app has to do what it is supposed to without crashing unexpectedly, leaking data and so on.
What this comes down to is the quality of the program code. We're talking bugs: code defects, security vulnerabilities or, more generally, anything that makes the app misbehave.
Good code is only the tip of the iceberg for a stable app. There are other reasons for instability too. Developers build apps to a specification based on requirements that have to be communicated, and it's not uncommon for requirements to be misunderstood or miscommunicated.
Imagine an app that's been designed to be used by ten people at once, but which was supposed to be able to handle 10,000 concurrent users. A misunderstanding like that can lead to an app that's effectively useless, without any coding errors on the part of the programmer.
Just to make things even more complicated, apps may stop working due to some external factor beyond the control of the developer. For example, many apps are integrated with third party systems such as a payment gateway or barcode reader. Or they may offer some features or functionality by using an external application programming interface (API).
These third party integrations are handy for developers and app users, but let's say the third party's systems go down, or an API is changed or abandoned. What happens then? If the app is not designed to handle that, one thing's for sure: the result won't be a good one.
Let's get back to quality for a moment. You'd think that to be high quality an app would have no bugs or code defects. But here's the inconvenient truth: software development is orders of magnitude more complex than almost any other human endeavour, and that means that code defects are unavoidable and inevitable. That's true for software from the very largest companies like Microsoft and Apple, and for much smaller software projects too.
In fact one way to measure the quality of software is to look at the defect density: the number of coding errors per 1,000 lines of code. (For the record, a defect density of about 0.7 is about average.)
Fixing bugs costs money, and apps are developed to a budget. Therefore the more bugs that get introduced, the more of that budget is used up by bug fixing activities, and less is available for making the app more useful.
That means that developing a high quality app involves a high quality development process: one which minimises the introduction of bugs, and catches those that do get introduced as early as possible. That's because the cost of correcting a defect in the software rises exponentially during the development process.
Defects in the requirements and app design phase can actually be corrected fairly easily, but the cost of correcting them once they’ve been deployed is much higher. So, carrying out high quality testing of an app is absolutely vital. That's because it will generally cost five times less to correct a bug that's caught during testing than it will once the application is put into production.
To be a really high quality app it needs to be easy to use - in-house or in the cloud - and also it needs to be easy to update, and easy to push updates out to end users.
(This last item is very important. Imagine an API upon which your app is changed by a third party. Until you can update your code to restore compatibility with the new API, your app will lose functionality - or even not work at all.)
How do you maximise the chance that people who download your app actually use it, and continue to do so?
We can talk about ensuring you have a high quality requirements gathering process, use sensible application design, and have an appropriate user interface and so on until we are blue in the face. But ultimately we can express this much more simply. Your app needs to:
- Look appropriate for your target market (business users, consumers, etc)
- Be simple and intuitive to use
- Offer obvious and immediate value to the user
- Deliver that value reliably and securely.
The effects of poor quality apps
Producing poor quality consumer apps is a waste of resources. That’s because if your app has obvious bugs then it will very quickly garner negative reviews and comments - and with anything much below a five star rating it will disappear down the rankings in Google Play or Apple’s App Store never to be seen or downloaded again.
But the consequences for business to mobile apps are far more serious. Why? Because if you offer a poor quality business to business app, you may well end up with:
- Frustrated and angry customers
- Miscommunications within your staff and conflicts with suppliers and business partners
- Data leaks and security breaches leading to loss of reputation, and high remediation costs
- Slow processes, failed transactions, and lost business.
All of this means that when it comes to apps - especially business to business ones - skimping on quality is a false economy: it’s just not worth it. The amount of money you might save is small, but the cost to your business can be very high indeed.
And that means you're actually faced with a startlingly simple choice: offer a high quality app - or you are better off not offering one at all.