Lessons On Wearables: Don't Make Me Wait

Designing and making apps for the newly released Apple Watch is an incredible challenge. Most of these stem from some Apple-imposed constraints through WatchKit, Apple's framework for creating third party applications.

No Third Party Hardware Access

The biggest issue by far, is that third party applications for Apple Watch have no hardware access. This means that there is no digital crown, no special behavior for Force Touch, and no access to the Taptic Engine. If that wasn't painful enough, the code that developers actually write isn't executed on the watch itself. It is instead run on the iPhone. This produces an interesting side effect that is detrimental to the Apple Watch experience: latency.

When you tap a button, for example, the action that is performed for that button has to be relayed to the phone where it is decided what should happen next. If there is interference in the connection between the watch and phone, that will slow things down. In addition, inefficient processing on the phone can cause even more delays.

On mobile we already have that expectation of waiting. Because network signals can be finicky we come to expect to wait for some amount of time when accessing or changing data. But the design paradigms of a wearable change all that.

Wearable Design Principles

It bears explaining some really basic principles when talking about the user experience design for wearables. It is completely different than any other technological medium to date. What's frustrating is when we try to apply the concepts we learned from older media and project them onto emerging ones. I have three pretty easy principles for wearables:

1) Don't make me wait. These screens are so small, tap targets so tiny, that the amount of data that can realistically be useful here is much smaller than even on a mobile screen. A user shouldn't have to wait several seconds to 'paint' information that is only slightly bigger than a postage stamp.

2) Don't make me wait. The interfaces for these devices are so simple and used for such a short period of time, that the information to consume really is of an ephemeral nature. Why in the world would you make a user wait 10 seconds for content they will consume in less than a second?

Can you guess what the third principle is?

3) Don't make me wait. The casual use of the information on these devices is so short that if you don't already have the information ready to show, the user has already moved onto something else that is able to provide value.

Do you get it? If your application displays an activity spinner of any kind, you've blown it. You're making the user wait for something that should have already been ready to load on the device before they even asked for it.

Why Waiting Doesn't Work On Wearables

There are at least two closely related reasons why waiting for wearables is a really bad idea, especially as it relates to watches. First, ergonomics: try holding your arm up in the motion of looking at your wrist. After a couple of seconds, your arm starts to get uncomfortable and fatigued. Our arms are made to be at our sides when at rest. Any other position is not how we are naturally inclined to be.

While 'life is pain' (as the Dread Pirate Roberts retorts in The Princess Bride), do you really want your app--your brand--associated with pain, discomfort, and fatigue? These are terrible things to have your user feeling while experiencing your app!

The second reason why you shouldn't make users wait is the short wake time of the device itself. Because the Apple Watch is an incredibly powerful and versatile device, it also consumes quite a bit of power. Apple, I'm sure, have spent quite a bit of time on the power-saving capabilities of the device to ensure that you are able to make it through the entire day on a single charge. The biggest juice-suck is the beautiful display, so if you aren't doing anything, it's going to turn it off after five seconds--even if you're still holding your arm up.

If you're taking more than a couple seconds to load content, the device will power off its screen and the user will have to lower, then raise back up, their arm to see if your application is done loading content. It is incredibly frustrating to have to wait for content and keep lowering and raising the arm to see if it is done yet!

New Wine In Old Bottles

So this juxtaposition of utility and speed leads us to an interesting question: what do we need to do in order to create great user experiences, while working within the confines of what is arguably a poor technical implementation for third party apps?

First and foremost, I think we really need to look at other examples of how moving to the 'new world' often requires jettisoning old thinking, methods, and techniques. You cannot put new wine into old bottles.

Let's use a non-technical example: stage theater. Consider the makeup of this actress:

The biggest reason why makeup is so heavily applied in theater is so that the audience can clearly see the performer from a distance. From the person on the front row, all the way to the back of the theater, the makeup needs to convey important information about who and what the performer is portraying. The actor or actress will also exaggerate facial expressions for the same reason: to enhance the communication, feeling, and emotion to all attendees.

When a newfangled communication medium called motion pictures came on the scene, guess which actors and actresses were used in these new films? What's fascinating, is that the techniques that make for a great performer on stage, do not necessarily transfer very well to the screen. Close-up, thick makeup and exaggerated expressions make the performances feel awful, overdone, and even grotesque to the viewer. It just doesn't work! Many actors and actresses had an extremely difficult time making the transition and ended up going back to the stage, instead of embracing what the silver screen could do for their art. The same methods and skills have to be adapted or outright dropped on the medium on which they appear to be truly effective.

Strategies For Wearables

So if not making users wait is a central, inviolable tenant for creating great wearable experiences, there are a couple of strategies we can employ to make sure that our applications respond as quickly as possible.

First, create interactions that are appropriate for the medium and work inside the given constraints. Reading a Facebook post, for example, would likely be a poor experience on a watch. However, viewing a summary or first line of a post might be enough to let me know whether it is worthy of my time to fish out my phone and read it in its entirety.

The watch is a great device for attention triage. Notifications are a fantastic way to let people know about important things that they're likely to be interested in. However, if your app becomes too chatty and is tapping me too frequently, I can easily vote your notifications off my watch forever. Respect me and my time.

Second, push updated information versus waiting for me to request it. Apple dispenses several mechanisms to keep information up to date through things like Background Refresh and 'silent' push notifications.

Third, cache, cache, cache. Any opportunity your application gets for going out to network, make sure that you cache relevant details so that they can quickly be displayed at a moment's notice. Whether this is the latest news stories, my bank account transaction information, or the scores of my favorite sports team, you need to make sure that you're persisting that information so that it's there at the raise of the arm.

It doesn't matter if the data is slightly old. Stale information is orders of magnitude better than staring at an activity spinner, waiting for new information. If you communicate the age of that data, it properly sets expectations of the trust I should have in it.

...In With The New

While I don't think there will be an Apple Watch 'gold rush' of applications that will happen--especially with the WatchKit SDK as it exists today--we can still make really great experiences for the Apple Watch. To do that we need to understand the limitations that the current generation of hardware and software bring, respect the end-user, and add a level of sophistication that may not currently exist in our phone apps.

Build your experiences around the principle of "don't make me wait", even if that means that you have to mute or even remove functionality in your watch app. In the end, your users will respect you for that because being first on this platform doesn't matter much if the experience is exceptionally awful.