Saturday, February 3, 2007

One Billion Buttons Please: Should we build features for experts or newbies?

I just returned from a lovely evening sipping flasks of yogurt-soju cocktails followed by a wobbly post-beverage walk in the brisk wet Seattle air. It is on libationary nights like this that I find myself musing about interaction design. Certainly, such behavior must be an incurable disease rooted deeply in the nerves at the base of the spine, but after this much alchohol, I can't help but give in.

Tonight's stream of thought kept returning to the question: What level of expertise should we target with our product feature? On one hand, web savvy designers swim in a warm sea of learned gurus preaching the religion of simplicity; how it entrances new users, increases our reachable audience and leads to happier customers. At the exact same time our expert users, the ones paying the bills, are screaming for cybernetic time travel juggernaut creation tools complete with one billion intricately labeled switches.

Balancing the tension between new users and expert users need not be a painful task. Here is a simple framework that I’ve used for many sober years to help me make these decisions more easily.

Layers of mastery
First, I always imagine a program of consisting of three distinct layers of functionality.
  • Intro: First are the features that are encountered when a new user is introduced to a workflow or scenario for the first time. Often these features require only basic, common skills to understand. .
  • Expert: Next are features targeted at the expert user has mastered the workflow and is looking to use the tools provided in an efficient and effective fashion. Expert features require the mastery of several new skills from the user, but they pay off with improved productivity.
  • Meta: A meta-feature help extends the capabilities of the product in new directions. Meta-users use functionality like API and construction sets to better serve newly discovered needs that are not directly served by existing expert or intro features. The presence of meta- features enable lead user scenarios and open up entirely new and unexpected markets.

An example
For my last product, a 3D multimedia application called Anark Studio, we were in a tricky situation. Most of our initial users did not like programming, yet they were hell-bent on building complex interactive applications. In response, we created three basic layers of usage.
  • Drag and drop behaviors
  • Core expert concepts
  • Program it yourself
Intro: Drag and drop behaviors
At the intro level, users could drag and drop pre-created behaviors onto objects. If they wanted a cool mouse over effect, they just drag one out of the gallery and dropped it on their object. The only skills the user needed to know was how to read an how to drag and drop. We made sure all the defaults on each prepackaged behavior were set to something reasonable, the names of the behaviors were easy to understand, and the results were instantaneous and visible.

New users found this functionality amazing since it broke their preconceived notion that all interactivity required programming. The low barrier to entry helped users overcome much of the fear of failure and lost time that naturally arises when they encounter a new application.

Expert: Core concepts
Some users stopped learning at the intro level, but most were engaged enough to dabble in more complex tasks. In order to provide them with more powerful tools that opened up creative possibilities, we introduced to the users three additional core concepts called slides, actions and symbols.

When providing tools for the expert to master, you can’t simply throw the kitchen sink at them. If you provide a hundred tools that all operate differently, you’ll find the most of them go unused. I’ve found that most expert users are only willing or able to learn 5 or 6 core concepts. These are of course the same users who are asking nuclear powered button tool chests. The trick is to bundling variety of tools together using a familiar metaphor. This allows you to teach one concept that opens up multiple capabilities.

For example with slides, most of our users were familiar with slides in PowerPoint. Even though we really were dealing with a rather powerful state machine full of unique persistence and animation constraints, the familiar metaphor helped them bridge the gap to practical usage quite quickly. They could immediately add, remove and rearrange slides. Only after they were using the slides to create interactive states did they start to notice the unique aspects of our implementation.

Add core concepts and their associated metaphors with great care. You’ll be living with them for many years as you build on new features within the conceptual framework that your users have learned.

Meta: Program it yourself

From the very beginning, we also told users that they could double click on any behavior and edit its underlying code. Every control in the application was build up from atomic elements and we gave the user full access to everything under the hood.

Now, they could certainly dabble in creating new behaviors by modifying our existing samples. However, in order to truly build new behaviors, they needed to have mastered all the expert features to an intimate level. Objects models, property publishing, custom events and all concept unique to the inner workings of an Anark behavior all were required to build new objects that extended the system. At the meta level, users were willing to put up with a lot of learning. They had invested heavily in the program and were excited to extend the application in a myriad of ways.

Early versions of Anark Studio had only a few intro and expert features. However, the existence of meta features allowed users to create a truly impressive set of additional capabilities ranging from new animation techniques to physics systems to large scale enterprise hooks. Many of the subsequent markets where Anark found success were a direct result of the customer driven innovation that formed around the meta features of the program.

Paying it forward
Another lesson that was has stuck with me is that you gain a lot by allowing the efforts of meta-users to be bundled up into modular items that can be used by both expert and intro users. All the code they wrote could be turned into simple drag and drop behaviors. Not only do your meta-users extend their own capabilities, but they also can extend the capabilities of the other users of your application.

Hints for using the model in real world situations
My favorite models are ones that allow me to ask hard questions about a design.
  • Do I have a good balance of intro, expert and meta features? Often I’ll find that I ignore a category in a design. Lack of intro features kills my potential market size. Lack of expert features hurts my chances of having a dedicated core audience. Lack of meta features builds the product into a corner, does not leverage customer contributes and reduces future flexibility.
  • Am I classifying my features correctly? Sometimes someone will place a very cool and powerful feature smack dab in front of intro users. The few users that make it through the gauntlet are delighted, but the rest disappear without a whimper. You rarely hear from the users that find your product too difficult.
  • Am I managing conceptual complexity? Am I use a few key metaphors that are readily accessible to my target audience?
  • Do my meta-features empower intro and expert users? If you fail to take this final step, the 1- 5% of your users that a meta-users will end up creating their own isolated community that fails to expand your market and take the burden of creating features off your shoulders.
Answering any one of these questions correctly can have a major positive impact on your product’s success, be it a website, a desktop application or a game. Ask them early and ask them often. Do not be afraid to adjust your design if the answers are not satisfactory.

Used correctly, this simple model of mastery layers goes a long way towards creating balanced applications that serve all your users. It never has been about only serving clumsy newbies or only serving the button fetishists. Such a dichotomy is silly. If we step back from all the blathering, it is obvious that intro, expert and meta users are all quite potentially the same person, just at different stages of experience.

Building products that take into account mastery is really a technique for ensuring user delight throughout their entire life cycle of usage. From the first intuitive inaction with the application all the way to the find stages where they play your application like an instrument, we are charged with making our user’s experience chock full of pleasure and value. Each stage matters and we ignore them at our own peril.

Hydrating with tea,

  • An interesting take on simplicity by Don Norman. I've run into this many times myself. the problem with making something that is easy to learn, but hard to master is that users often don't realize how much power is at their finger tips. In some sense what many users are asking for is something that *looks* powerful, but is very easy to master.
  • Joel on simplicity. Another interesting argument that basically says "All those features are great and computers are advancing fast enough to deal with the increased complexity."


  1. Interesting read, Danc. I hope your enlightenment in this arena will be palpable to the (eventual) users of your current undertaking.


  2. I was just talking with a friend of mine and I had noted the exact same idea of levels mastery in application and how it effects the evolution of culture and society: I would like to say it's good to see someone with a very good example of this concept.

    Mindfulness of how to expand and create something is the key to mastering how the evolution of something ends up. :) Thanks for the read.

  3. I talked about this a great deal with the other game designers at my last job.

    We came up with a few interesting techniques:

    * Sometimes a feature is usable by BOTH newbies and power-users. You can build your UI to allow both: drag-and-drop behavior along with hotkeys, for example. The presence of hotkeys doesn't get in anyone's way when first learning the tool/game, but it makes things easier for experts who want to use it over and over.

    * Hiding advanced features can be effective, so that the initial interface your users see isn't as intimidating. ICQ does this. So does Game Maker. In both cases, there's an "Advanced Mode" buried under a series of obscure menus somewhere, so that it's basically impossible for a newbie to accidentally enable advanced features -- you have to already be comfortable with the program before you can enable Advanced Mode in the first place.

    * In a few specialized cases, you actually WANT to only build towards one group or another. Google's search engine doesn't really need an "advanced mode" with a thousand buttons. A realistic flight simulator doesn't necessarily want a "beginner mode" with only a joystick. Home electronics equipment, while benefitting from ease-of-use, actually sells better if it looks more complicated because people mistakenly believe that more buttons and dials means higher quality... even at the expense of usability! So, never let your desire to attract newbies AND retain experts override common sense.

  4. Good points.

    Google is actually an interesting example. They certainly focus heavily on the intro features and offer a great experience to users coming to the product without specialized skills.

    However, if you dig in there are loads of expert features. Did you know there is an entire units and measurement calculator in Google? Or the stock quote system? Or a hundred other little tweaks that are available to more learned users.

    If you dig in even futher, there are reams of meta-features. The entire mashup world lives off the meta-features that Google implemented. Adwords API's, Google Maps name it.

    take care

  5. Apple's Garageband is one of the best example of this kind of layering I've run into.

    At the very top level, you can grab loops, drop them into place, extend them and so on. It's all very simple and while you can do a pretty good amount with it, there's not a lot of screen clutter and there aren't many controls visible. You can change instrument presets (like, having a piano loop played on a guitar voice or whatever), but not edit the parameters.

    The next level is actually editing instrument parameters and changing how they're laid out. There's a little dropdown arrow thing that opens up a list of the various plugins and sound generators that make up an instrument preset. You can edit the pieces that go into each preset, swap them out or change the parameters, and save that as your own preset.

    The next level down is AudioUnit plugins. Even though Apple doesn't come right out and say this, Garageband is an AU host and will use any AU plugins you might have installed on your system. All of a sudden this gives you access to many more possibilities.

    It's worth looking at from an interface standpoint.

  6. Libationary, huh? Not thats not a word you hear too often. ;-)

    I get the "slides" concept but what about situations where a methaphor may seem ambigious, i.e. it's meaning is clouded by overuse or pre-existing notions, like, say, the concept of a photoshop layer?

    You hint at this in your conceptual complexity section but don't directly address it as an issue. I wonder how you can present a new concept to the user without interferring with preconceived familiar concepts.