More apps are going to be downloaded this year than ever before in history. Whether we’re checking out TV Guide on our iPhone, going through our to-do list with Evernote on a Surface, or zipping through Star Wars Angry Birds via AppUp®, we’ve all used apps at some point and fully intend to use many, many more.
What makes an app something we keep using, let alone let stay on our devices? We’ve probably all been through this drill: look for an app, download it, give it about one minute to perform the task we’ve downloaded it for (tops), and then essentially fish or cut bait. Our apps have a finite amount of time to impress us with their functionality, and we are fully aware that there are many, MANY other apps waiting in the wings that could possibly step in to do the job better.
As developers, sometimes it’s easy to miss the forest for the trees, so to speak. There’s a wholly different perspective behind designing an app vs. using it without that back-end perspective, and sometimes usability can get lost in translation. In this article, we’re going to look at basic app usability guidelines from a user (not a developer!) perspective, an inside look at what the end user is really looking for when your app catches their eye and gets to that elusive and risky download stage. These guidelines can serve as both transformational and cautionary signposts for developers who want to create a better user experience when designing their apps.
The very first thing that catches a user’s eye will not be the long list of cool stuff that an app promises to do. It’s going to be the design, for better or for worse that makes someone pause and take another look in a very crowded app market. One of the most effective things that a developer can do to make an app stand out is to make the design consistent both within and without the app itself. Here’s what that means: when a user is within an app, it should look consistent from one screen to the next so they know what they are doing and don’t start suspecting that they’ve been kicked out or some other not so ideal result. Same goes for outside the app; if you’ve got a website that users can visit as part of their app experience (this is especially true of apps that inspire a large fan base that want more ways to interact), then that website needs to have the same look and feel of the app so users can experience the same branding consistency.
In-app navigation should be painfully obvious. Don’t make users guess on what they’re supposed to do next, since this (obviously) leads to frustration, which then potentially leads to a prompt uninstall. The line between using an app successfully and throwing it to the trash pile is literally only seconds long; users won’t give you much of a chance to impress them. Navigational aids (like breadcrumbs and clear visual cues) don’t need to necessarily hold someone’s hand, but they also shouldn’t lead the user on a scavenger hunt. Make it simple, make it succinct, and give me the confidence that I won’t get lost and have to start everything I just did all over again.
Don’t Hide Things That Are Important
I can’t tell you how many times I’ve been testing an app and something that is necessary to a crucial task within the app is playing peekaboo. Anything that includes a call to action or vital input should be front and center, standing out without a lot of extra “stuff” occluding it. Making users hunt around for something they need to use within your app is a surefire recipe for a quick exit and uninstall.
Tell Me What I’m Doing Wrong
We are visual creatures, especially when it comes to using apps. We need to see instant feedback when we do something right or wrong. One of the most teeth-grinding experiences that I’ve come across in a few of the apps I’ve used recently is the guessing game: you know, when an app requires some kind of form and then keeps popping up a vague error message aka Dennis Nedry in Jurassic Park:http://youtu.be/RfiQYRn7fBg
video courtesy YouTube user Phil Wylie
Users need to know what they did wrong, and they need to know how they can correct it. Nothing is more crazy-making than (for example) filling out a form and a big red stop sign blares out something like “you cannot proceed” without giving any pertinent information. Avoid doing this, for the sake of all the users you want to keep from silently jinxing you with the plague.
Don’t Ask For the Same Information Over and Over
Users understand that there is some information that needs to be given in order to use most apps these days, and we really don’t mind doing it. However, when this information is asked for over and over again, the frustration level climbs accordingly. For example, I was using a financial planning app the other day that asked me for relevant account information a total of four times in a row – and yes, I did end up uninstalling it. All necessary actions and/or input should be asked for once. The less textual input, the better; this will cut down not only on unnecessary information gathering but also reduce the chance of errors within the input process.
You Don’t Need That
An app that asks me for the name of my dog, my blood type, or my political affiliation is pushing its luck. These are extreme examples, but developers need to understand that while users expect there to be some information asked for (the basic username, password, and possibly first name), anything beyond that is going to be seen as intrusive. People don’t want to fill out a long list of text fields, especially using a touch-based app like many of those being developed for the Ultrabook™ or Windows 8 right now.
Tell Me What I Need To Do
It’s a good idea to gently guide the user to exactly what they need to do using default values in text fields that inform exactly what they need to type in – First Name, Email, Address, etc. These should be within the text field itself for the greatest accuracy. This goes along with the idea of clear navigation and consistent design; you’re directing the user to the action they need to take using the shortest, most direct route possible, which makes for an optimal experience.
Tell Me What You’re Going to Do with My Information
Explain clearly how information that users enter in will be used; tell me that my email address will serve as my username, or that my location will be used to personalize my experience, or what my public profile will look like with certain bits of data. This gives the user a big picture viewpoint of what the app will look like and how they will be using it; it basically orientates them to how things will be situated within the app and is a great way to build both trust and user confidence.
Less is More
Prioritize the content that you want people to read. Users don’t want to read walls of text within an app, plus, we have notoriously short attention spans. A very specific content focus requires some pretty tight planning, as well as some hard choices as to what to include in the app itself. Writing something as concisely as possible is definitely an art, and will take some tweaking to get right, but it’s worth the payoff as users will not stick around to read a novel.
In addition to being short and sweet, any content included in an app needs to be instantly understandable, especially if it includes a call to action. For example, look at these buttons below:
Image courtesy Hongkiat
All of these buttons give vital information: latest version, free, language, how big the file is, etc. The content is concise and gets right to the point, paired with an active call to action button. The user knows exactly what they are about to do and takes action accordingly. A specific focus like this that offers a limited set of content and functionality makes it easier for users to follow the path you’d like them to take, and makes for a better overall user experience as well.
Don’t Reinvent the Wheel
If you’re designing for next-generation Ultrabooks with touch or touch-enabled Windows 8, you’ll need to define touch gestures and terminology (and look at the platform you’re developing on so nothing conflicts!) so people don’t need to guess at exactly it is you’re asking them to do. Luke Wroblewski’s series of touch design principles videos talks about this very topic in Touch Design Principles Part 3: Gestures and Discoverability:
“Touch gestures are implemented without on-screen control prompts (arrows, icons, etc.). They are, quite literally, invisible. How can we help people discover the touch options available to them within programs? There’s no visible interface element saying “hey, click on me and I’ll help you do something!””
Luke talks about several different visual cues that can help people discover touch-based input actions, such as removing other options, faded edges, animations, and “just in time” educational pop-ups that are triggered by a certain action. Of course, since each OS is different, it’s important to familiarize yourself with standard controls so they don’t conflict with what you’re going to ask your users to do within the app.
App Usability is Key to Keeping User Engagement High
If you want to keep users around past that honeymoon stage, then app usability is crucial. Developers know that they’ve got pretty stiff competition, and users know there are plenty of fish in the sea when it comes to apps. Keeping the basic principles in mind that we talked about in this article will go a long way towards engaging the consumer and securing them as a longtime user.