Playfulness in Interaction Design June 11th, 2008 at 12:07 am by Damon Dimmick

I recently attended a lecture by Matt Jones on the topic of Playful Design. Matt was talking primarily about engaging users and customers through a process of playful discovery, in which fun and quirky features are designed into products, allowing users to engage in entertaining passive exploration of the product. Playful features could have a purpose or simply be there as a wink to the user. The main idea is to create an atmosphere of play that enhances the intrinsic value of the software or product. This playful attitude can be added as part of error messages, quirky functions, or in-product mini-games.

Although the lecture didn’t really focus in any specific product categories, the overall concept seemed to be aimed at electronic consumer devices, social networks, and the kind of fast & fun web 2.0 applications that are popping up like mushrooms. It got me thinking: If playfulness has value, it stands to reason that play could be incorporated into more serious contexts as well. What about products that are notoriously unplayful?

Some companies are finding playful success in the technological gaps that users expect to be dehumanizing, such as the usually stale e-commerce purchasing process. Woot.com, the ubiquitous retailer of zero-day bargains, has made an art of infusing a pretty standard process with a lot of nudges, winks, and playful jibes. For example, instead of just telling customers “your order has been completed” after checkout, Woot does a good job of humanizing the interaction, telling the customer that everything appears to have gone smoothly. Order history pages are populated with playful language such as “What’s going on here?” as well as a tongue in cheek nods to their business model, e.g. “Hey, here’s a fun game: try to get the longest list of purchased woots of anyone! Better get started though, some people have a pretty good start on you. If you win, we’ll be really happy for you.” Perhaps because Woot treats its customers like a friend with whom the site plays around, Woot’s customer base tends to be loyal, engaged, and unsurprisingly, just as playful towards Woot.

Another fun example is Twitter. When Twitter gets flooded, the server responds with a playful image that is far from serious, but incredibly endearing.

Some other playful examples:

• Flickr uses the same playful strategy for humanizing error messages. Although Flickr usually has solid uptime, when Flickr is down for servicing, users can expect tongue in cheek error messages such as “Flickr is having a Massage.” Sometimes it is the little things that count. Many Web 2.0 companies have followed Flickr’s great lead.
• Pownce: Makes not finding pages a little more fun.
• Renkoo: a site focused on event planning, that offers the popular BoozeMail Facebook app, has an offline message about the service having a hang-over, and an invalid page error message from the Renkoo Bots: “Oh these silly humans. Little do they know that we are destroying their precious webpages. With lasers!“

Other sites like Digg and YouTube have rather boring and unplayful error or away messages, though on the rare occasion when Digg is down, they offer a nice touch for their news-starved user base: a list of every Digg employee’s favorite blog.

These are all great little features, but there’s a bigger question lingering:

Can we work the same kind of playfulness into enterprise applications?

Playfulness in a business context would have to be executed carefully, but the goal remains the same: Engaging users and creating an enjoyable user experience.

Business applications are very task-oriented beasts. They are used to get things done, and that means that any included playfulness should either be helpful or at the very least not get in the way of users.

The current generation of open-ended games, including massive sandbox games like World of Warcraft and Grand Theft Auto, can really be boiled down to long chains of deliverables and task goals, the completion of which lead to psychological payoffs which have no real value outside of entertainment. It may be a little much to ask that our office apps be as fun as a car chase in a video game, but it seems like we could bootstrap the same ideas of challenge, feedback, and psychological payoff in order to instill some sense of playful gamesmanship in productivity software.

How could we work a playful context into a ho-hum application like a task manager / to-do list? Taking a cue from exploratory games, we’d want to tie in pleasurable feedback (e.g. mission complete!), some kind of progress indicator (two more goals left), and perhaps performance based recognition (level up).

One example of a playful infusion to an otherwise boring set of tasks can be seen at LinkedIn. In order to encourage users to fully complete their online profiles, LinkedIn suggests which sections of the user profile to fill in next and rewards users with a percentage-complete score. This is a much more fun interaction model than the standard, dry web form we might expect. This kind of model can inform the possibility of yoking playfulness in robust applications like our previously mentioned task manager. It also makes the network more useful overall by encouraging users to add more detail to their profiles over time.

Task priority ratings, difficulty estimates and due dates are already found in many task managers, so using this data to create playful feedback seems reasonably straight forward.

Our playful feature might manifest itself by keeping track of user progress and comparing the statistics across a historical data set. Did the user complete more goals today than their historical average? If so, let them know with a pleasant notification. Did the user just finish a task with a very high difficulty rating? A different message might be called for when the user checks that big task off their list. To tie this playfulness to our idea of noting progress, completion data and accomplishment notifications could be charted historically within the task manager for later reference. If a user is actually improving their historical performance regularly, that might call for another feedback cycle, preferably something engagingly visual, like a slick chart that shows their progress.

How these kinds of notifications are implemented can also make the difference between fun and lame. A sterile text message reading “You have completed 3 tasks today. Good work.” could be dull and even patronizing. The user might be more engaged by a quirky little animation with a distinctly non business message, congratulating the user on hitting a performance indicator, slogging through a challenging product launch, or achieving a sale that has been on the user’s calendar for a while.

It’s actually not that hard to imagine this kind of playfulness being useful from a business context. I could even envision a more social structure in which team members also get notified when someone is having a particularly productive day. If the members of a team all complete their current batch of tasks ahead of time, could the system give them a collective pat on the back ( or optionally inform their manager of excellent performance)?

Would there be value in assigning real-life bounties or rewards to certain tasks either explicitly or randomly? It’s tempting to consider the possibilities, though we’d want to make sure to avoid creating perverse incentives and unintentional stressors. Above all, a playful context always means -positive- interaction. If it edges into negativism, playfulness just turns into pressure.

There might also be value in engaging in some purely playful, non-functional elements. These could be features that activate based on predefined conditions and which do nothing other than offer the user a chance to smile or to be surprised. These elements would be discovered spontaneously by users, and should be clever enough to spur an inter-office email along the lines of “Hey, check this out!”

For example, imagine building a playful egglet into a text editor. For example, let’s consider an egglet that provides useless but fun feedback based on typing speed. When the user starts typing at a very high rate, a small egglet in the form of a speed gauge would appear at the bottom right of the interface, possibly along with a subtly implemented sound, like that of a revving engine. What’s the point? None. It’s purely there as playful fun, a way for us to tell the user “wow, you sure are typing fast.” As long as it is executed tactfully and doesn’t actually keep the user from accomplishing his goal, the egglet can add an element of quirky humor to an otherwise sterile software tool.

The danger here is overshooting the idea of playfulness and delving into the simply annoying. Some companies just can’t control themselves, resulting in too-clever-by-half abominations like Clippy, Microsoft’s infamous Office Assistant.

The trick is to offer something that is playful, entertaining, but only slightly obtrusive. Bonus points if the playful feature ends up being useful or offers valuable feedback. If the playful feature is purely for entertainment purposes, its probably best to give users a quick and easy way to permanently turn the feature off. Learn from Clippy’s mistakes and remember that cute and annoying have a lot in common.

The idea of playfulness is really just to give an experiential gift to the end user. In a world with increasingly dehumanizing elements and rampant focus on efficiency, genuine efforts to do something extra for the user are usually appreciated. The extent to which playfulness can be incorporated into applications without becoming annoying is a matter of art. Erring on the side of quality instead of quantity is probably a safe bet, but a nudge and a wink towards end users can be the perfect way to ask “Want to play?”

More often than not, they probably do.

Tags: design, interaction, playfulness, ui