Homepage > Journal > Error handling in mobile applications

Error handling in mobile applications

How you like that:

If you read "Typical data entry errors during online shopping," you already know that errors are an integral part of E-Commerce.

Mobile applications aren't free of them either. As their users, we know this very well.

Indeed, making errors while using mobile and desktop devices, web and mobile applications, ordinary corporate websites, and sales platforms is simply unavoidable.

You need to be aware of that while developing a mobile app. An application that works flawlessly is an ideal that is certainly worth pursuing. Strict realism, however, shouldn't exempt any company from the desire to achieve it.

How should you design error handling in mobile applications not to lose users, customers, and the opportunity to obtain a business goal?

What actions should be taken, how to approach the subject of errors, and what should be at the heart of the design? What should the application be like in terms of error handling so as not to discourage users?

We'll discuss these in a moment.

As always, we cordially invite you to read our article!

Do you want to know how much it costs to develop an app?

A list of the most frequent errors that unfortunately can't be avoided

Humans are creatures that make mistakes. Hence you shouldn't strive to eliminate them (which is only possible to a limited extent), but to handle, counteract and fix them in a way that is most desirable by users.

Error handling in a mobile application, errors in mobile applications, although they're similar to a certain degree to errors occurring in web applications, they have their own character.

An image showing a man on his phone

The difference is related to technology, operating system requirements, different functionalities, and contexts of use of devices and mobile apps.

Mobile application development is also about designing system reactions to occurring errors. User Experience (UX of a mobile application) depends on how errors are handled. Comfort, security, and control should be offered to the user, especially when an error appears.

The speed and the effectiveness with which the application helps fix the error determines whether the user treats the error as incidental and acceptable or as potentially dangerous and risky. And thus prompting them to stop using the application.

An error is a situation where a goal can't be achieved due to incorrect actions by the user, the mobile application, or external factors (third parties — such as Internet providers).

The error makes the interaction occur not in line with expectations, experiences, or scenarios. The application doesn't perform actions that the user expects from it. As you can easily guess, it's a source of frustration and stress.

And stress negatively influences mental and physical well-being, so contact with its source is usually not recommended or avoided.

Numbers don't lie. According to the statistics presented in the article "Why Users Uninstall Apps," for 11% of users, technical difficulties are a sufficient reason to uninstall an application. It's simultaneously a lot and a little. The results suggest that counteracting such situations is possible. All that it takes is to offer appropriate error handling. And it's best not to ignore this necessity.

Customers and users of applications will simply uninstall software that doesn't provide proper error handling. And naturally, business owners and UX/UI designers who create mobile applications want to avoid such a situation.

A photo showing a smartphone and wireless headphones in a case

Let's note that every application user has — more or less — honed skills to use it. What does it mean?

Experiences breed expectations and are a type of habit that, if not discovered and respected by the creators of applications (UX designers, UI designers, web and mobile developers), will cause an array of errors. Or, in the most optimistic scenario, a series of mistakes.

Thus, errors can be divided into the following:

  • Occurring on the side of the customer (e.g., entered data are incomplete or formatted not in accordance with system requirements)
  • External (e.g., errors of system integrated with the app)
  • Internal (e.g., resulting from system errors, the logic of application operation).

Of course, errors have different weights — both in terms of how the system works, as well as the potential and real damage it can cause to the user.

After all, a temporary loss of control over the application interface (e.g., application freezing) differs from an error occurring during a payment with an app, resulting in the loss of money.

The following types of errors can be distinguished according to the criterion of harmfulness:

  • Critical Errors
  • Recoverable Errors
  • Warnings.

Critical errors include situations in which the normal functioning of an app is made impossible. Interaction with its interface is impossible. In other words, its operation is permanently or temporarily interrupted for various reasons. The entered data may be lost.

Recoverable errors can be fixed. They're much less harmful and dangerous. Adequately designed and offered error messages enable quick and effective prevention of unfavorable situations.

For example, it's enough to re-enter the correct data that is immediately checked regarding correctness through validation (in-line validation).

Warnings, although they aren't errors for many people, it's still worth mentioning them. Warnings are situations in which the course of a process was disrupted or a process was partially completed.

An image showing a mobile phone

For instance, the user booked a flight but didn't receive information about the seat number. Although these errors are not as harmful and discouraging as critical errors, they still significantly influence user experience (UX).

You can also look at errors from the perspective of their specificity. According to this division, it's possible to distinguish errors that are specific to:

  • Concrete application (for a particular type of app)
  • Given platform (e.g., iOS, Android).

It's also worth remembering that mobile applications are characterized by errors that are only specific to them.

They include errors that stem from the following:

  • Orientation of the screen of a mobile application (portrait mode versus widescreen mode)
  • Touchscreen sensitivity to gestures
  • Imperfect performance of gestures
  • Screen size
  • Internet access
  • Failure of built-in devices (e.g., camera, gyroscope, microphone, GPS)
  • Update of mobile application compliance with the requirements of iOS and Android platforms
  • Influence of context.

Remember that mobile applications should be designed with specific tasks in mind (Task-Oriented Design) and that they're, in comparison to web applications, more based on micro-interactions and micro-moments.

You also need to pay attention to very typical causes of errors for mobile applications:

  • Excess of functionalities
  • Confusing navigation
  • Excess of animated elements
  • Pop-ups (e.g., ads from an external company)
  • Lack of adaptation to requirements and limitations of the mobile channel regarding, for example, forms or galleries (e.g., issues with scaling of photos in different screen orientations)
  • Inadequate size of buttons (too small or too large)
  • Lack of consideration of the different contexts of the use of smartphones and mobile applications
  • Lack of design consistency (e.g., regarding functions, navigation, aesthetic)
  • Mimicking solutions that are characteristic of desktop applications
  • Overload of the phone's memory and processor.

In summary, errors are natural elements that must be considered when creating, designing, and using mobile applications. They should be accepted and prevented.

Developing error-free software is impossible (even after performing various tests, e.g., A/B testing). However, it's possible to create exemplary software in regard to error handling.

How errors are predicted, cushioned, mitigated, communicated, and resolved is critical to offering a positive user experience to mobile app users.

Perhaps one of the first and most recommended approaches to errors in mobile apps is their prediction. It's not just about deducing and using intuition or exploring your experiences with apps but about something much more rational.

We're talking about the design of wireframes, mockups, and prototypes of applications based on research and testing conducted with users who belong to the target audience.

Thanks to the research-testing approach and the involvement of UX researchers at an early stage of the development of a mobile app, it's possible to eliminate many errors and notice the possible causes of errors in designed solutions.

When talking about research, we also have in mind regularly performed, planned, cyclical, and focused UX audits that allow you to optimize apps (not only in terms of technology but also usability, impressions, and user experience), also, in terms of errors that occur in it.

Preventive thinking provides a much better user experience and improves the competitiveness of an application, and considerably lowers its cost.

With that said, it needs to be supported by the best, the most up-to-date design patterns that not only influence the operation of an application and its usability but also translate into customers' comfort, sense of security, control, agency, and purposefulness.

Predicting errors made by users also involves analyzing popular use cases. A UX/UI designer must answer the most crucial questions: What will the user do when they want to perform X task and/or achieve the Y goal? What problems will they encounter? What errors can they make?

You should particularly predict problems (complex and simple) that result from the determination of the following:

  • Time
  • Place
  • State
  • Amount.

Relationships between these variables, how they're understood, determined, and expressed, and the logic behind them most often leads to making errors in mobile applications. And it's necessary to consider them during application development.

Prevention also means proper communication with the user. Application developers need to create it from start to finish. They need to grab the user's attention with it, consider their problems, and appropriately communicate the most frequent issues and ways of solving them.

Adequate communication means offering to the application user a range of tools that allow them to:

  • Understand what happened (as soon as possible)
  • Accept the situation of error occurrence (although it's not possible in every case, you still need to strive for it)
  • Fix the error, restore functionality
  • Warn about the possible appearance of an error.

Thus, it's essential to offer the following:

  • Hints
  • Tutorials
  • Directional cues
  • Suggestions
  • Limitations (especially when it comes to forms)
  • Communication through conventional signs, symbols, and words (e.g., icons, colors).

A crucial matter is the time and way of communicating errors. An error should be communicated as soon as it appears with messages that make it:

  • Noticeable and recognizable as an error
  • Understandable in terms of its cause, weight, and the possibility of repair (naturally, it's not about summarizing the entire process)
  • In line with the mental models of users.

For example, the color of the error messages in mobile applications should be compatible with the convention of marking problems, errors, and threats, meaning that:

  • Color red signals an error, problem, threat, or risk
  • Green color means success, correctness, or positive result
  • Yellow color indicates an occurrence of an error or a problem and warns against the danger
  • Blue highlights important information that the users should see.

It's also worth remembering that marking an error with colors is insufficient and should be supplemented by graphic and verbal elements (e.g., exclamation marks).

Standard colors highlighting errors aren't always readable for people with various sight limitations (e.g., color blindness).

It's equally important to adapt the language to the types of errors and needs, habits, and expectations of users.

Errors in applications

Errors should be communicated in a way that is:

  • Simple and understandable
  • Brief and clear
  • Free of jargon and specialized terminology
  • Emotionally neutral and with a tone devoid of condescension
  • Focused on the explanation and adaptation of a solution to the capabilities of users.

In the case of entering data by the user, a good design solution is to:

  • Increase error tolerance
  • Make validation more flexible
  • Use affordance (suggesting with shape, appearance, the color of function, and mode of operation)
  • Communicate the state of the process
  • Limit the ability to send a form with errors
  • Offer helpful texts.

When adapting the tone of messages, you should primarily avoid too serious, formal, and official tone. It's not recommended to excessively try to befriend users and underestimate the problem.

The emotional tone of error messages should be neither overly dramatic nor emotionally indifferent. A good example of this approach is the error messages of Google's applications.

While designing error messages for mobile applications, it's worth being empathetic and understanding.

A best practice is also striving for maximal usability of the message. The user should know what happened and what they can/should/must do in a given situation.

Directional cues in error handling in mobile applications

What are directional cues? These are all elements of the user interface, which are visual cues. They suggest the way of interaction with an app or its part; they indicate the location of important information or functionality.

Directional cues are an essential preventive measure and significantly reduce the number of errors made by application users.

A picture of a toy ship

They're very useful for counteracting errors because they:

  • Improve the scalability of the screen of an application — through them; users can more quickly understand how the app works
  • Allow you to highlight the visual hierarchy of the interface elements.

The most common directional cues include the following:

  • Arrows
  • Indicators
  • Lines
  • Geometrical shapes (e.g., vertices of triangles)
  • Icons, illustrations that suggest with their shape and cultural meaning the way of interaction (e.g., scrolling, taping, pressing)
  • Animated visual hints.

Like conventionalized color schemes, UX/UI designers eagerly use directional cues because users quickly learn what they mean. One of the techniques is to place them at the level of the so-called natural line of sight. Thanks to this, people can notice them very quickly.

It's worth noting that the color scheme and the size, shape, and way of use (e.g., through repetition) constitute implicit directional cues.

Compared to the written word, the perception of shapes, colors, and conventional symbols, especially those strongly associated with a function (such as a warning), is much faster and less cognitively engaging.

It requires less focus and concentration and engages less cognitive resources.

Moreover, humans naturally tend to look for hints and elements that they know well and are helpful for them.

Especially in dangerous situations in which the stress level is higher. It would be a mistake not to use these inherent and automatically activated predispositions and actions.

Errors in mobile applications stemming from gesture navigation

What are gestures? They are micro-movements of the index finger and (mainly) the thumb, thanks to which the mobile application user interacts with it, navigates through it, and performs tasks. The most frequently used gestures are taps, swipes, and pinches.

A photo of three smartphones on a table

The typical way of using mobile phones and the applications installed on them are one of the most important causes of making errors.

Small screen diagonals and thus small working spaces, tactile screens, and the necessity of using various gestures make using smartphones a unique activity.

Let's add to it the influence of different contexts of use, like movement vs. staying still, being in private vs. in public, and being in a closed space vs. an open one. It's easy to understand that the operation and the use of smartphones and mobile apps are much more error-prone than using desktop devices.

Furthermore, the number and types of errors are influenced by the size of buttons offered in interfaces and the tactile technology itself, which in individual models, brands can differ. For example, in terms of sensitivity to pressure or error tolerance.

The efficiency of fine motor skills, which is essential for the relatively flawless use of mobile apps, determines the number of errors made during their use.

From the perspective of ergonomics and smoothness of navigation in mobile applications, often operation with gestures is favored over traditional user interface buttons, thanks to which it can be minimized. And this means better use of available space and improvement of navigation. But this has its price.

An image of somebody holding a mobile phone

The ability to interact with a mobile application with gestures is sometimes hidden and requires tutorials that make users aware of its existence and effects.

Another issue concerns the availability of gestures for some groups of users. Such a solution requires manual dexterity and proficiency in using the phone. For seniors and children, using an app with gestures may be challenging and be a source of errors.

Hence, the way to counteract the occurrence of errors during the design and development of a mobile application is:

  • Informing about the ability to use a gesture with short messages
  • Offering animations that show the ability to use a gesture.

Error handling in mobile applications. Summary

  1. Regardless of its type, a mobile application can be a source of errors.
  2. A mobile app that works flawlessly is an ideal worth pursuing.
  3. A mobile application, in terms of the nature of the errors that occur in it, is only to some extent similar to a web application.
  4. Mobile applications own their peculiarity to the technology, various contexts of use, and the nature of tactile interactions on limited screen space.
  5. User Experience (UX) depends on how errors in an application are handled.
  6. The speed and effectiveness of fixing the error determine whether the user will treat the error as incidental and acceptable or as prompting them to abandon further use of the application.
  7. How errors are predicted, cushioned, mitigated, communicated, and resolved is critical to offering a positive User Experience.
  8. An error is a situation in which a given goal can't be achieved due to incorrect actions of the user, application, or external factors.
  9. A flawless mobile app isn't possible, but it should be developed using UX research and testing.
  10. We can divide errors into those occurring on the customer side, external and internal.
  11. Typical errors in mobile applications include those resulting from the orientation of the mobile application's screen, the touch screen's sensitivity to gestures, poor gesture performance, and the size of the screen.
  12. Excess functionalities, confusing navigation, and an excess of animated elements can also cause errors.
  13. The most recommended approach to the problem of errors is to predict, study and counteract them.
  14. Predicting errors involves analyzing popular use cases.
  15. Prevention also means proper communication with the user.
  16. Adequate communication means offering the application user a range of tools to understand the cause of the error and to fix it.
  17. Errors should be communicated in a simple, understandable, brief, and clear manner, free of jargon.
  18. When adapting the tone of messages, you should primarily avoid too serious, formal, and official tone.
  19. It's also not recommended to excessively try to befriend users and underestimate their problems.
  20. Direction cues are elements of the user interface that are visual cues.
  21. Directional cues are an essential preventive measure and significantly reduce the number of errors made by application users.
  22. The perception of shapes, colors, and conventional symbols, especially those strongly associated with a function, is much faster and less cognitively engaging.
  23. Gestures are micro-movements, thanks to which the mobile application user interacts with them and performs tasks.
  24. Small screen diagonals and thus small working spaces, tactile screens, and the necessity of using various gestures make the use of mobile applications a unique and error-prone activity.
  25. During the development of a mobile app, it's worth remembering that a good way to counteract the occurrence of errors is to inform about the possibility of using a gesture with short verbal information and to offer illustrative animations showing the existence of the possibility of using a gesture.
How you like that:
Journal / Redaktor
Author: Radek
UX Writer and researcher by education + experience. Collects The Story's knowledge and shares it on the Journal.
Reviewer: Dymitr Romanowski

Are you interested in working with us? Take a look at our Portfolio