1) Choose an appropriate default behavior.
Most applications have a default use case. This is usually implemented through some parameters with some default values. But, we do not take time to carefully analyze and understand this default use case. It is an after-thought or an ad hoc decision most of the times. Worse, we defer this to users by making them go through an elaborate setup process to pick the default values. We feel that users would feel empowered if we make them explicitly set these values themselves. As it turns out, most users want to get up and running right away and expect the application to just work. Customization, if necessary, should be "as and when" needed, and should be presented to the users in the context of their actions (and not as a separate action). We call it "on-demand incremental context-sensitive customization." For example, in ScrumPad, users can create a project with 2 weeks sprint as a default (they don't have to do anything extra). When they define sprints, the system would set the end date 2 weeks apart from a given start date. We even help pick the start date based on the last sprint / current date. We also pick the name of the sprint as "Sprint#count
2) Minimize required information.
Most applications have forms to collect different data. Some of the elements on these forms are required and some are not. We tend to make more data required than we ought to. What we found is that most of the time we over think what we should make mandatory when we collect data from users. We should really question our assumptions about what we think are really necessary. We need to allow users to move forward with the minimum information and let them provide rest of the information "as and when" necessary. We call it "on-demand incremental context-sensitive data collection." Amazon does it really well. You can start shopping without needing to login. You are prompted for login at the last possible moment. We see this also in signup process for most of the new breed of Web applications. In ScrumPad, we used to force users to pick tags when adding stories. We thought we were helping the users by forcing them to think about themes / grouping for their stories at the time of creation. Our users did not see it that way, instead they found it annoying / limiting. We changed our mind and now it is an optional element, and the users are happy!
3) Trust users, not constrain them.
We tend to design our applications around the idea that our users, if allowed, would do things that they are not supposed to. If somehow we prevent them from doing "not allowed" things through different roles, we would help them. This Also gives us a false sense of satisfaction that our applications would become more secured. This was the case with ScrumPad when we initially designed it. Scrum promotes three roles- Scrum Master, Product Owner, and the team members. As any purist would do, we segregated these roles very strictly. As a result, we were forcing our users to fit into these straight jackets and made their lives difficult. As we faced with different real world situations, we started to relax some of these constraints by allowing users to be in multiple roles. Still with that, it felt like it was a work-around rather than natural. We started to question our assumption that we need to prevent one role from doing things that usually is expected of from another role. We came up with two reasons why we do this. One, we are afraid that we won't be able to track who did what. We could easily address this concern by implementing tracking "change history." Second, we are afraid that people will be confused about what a role entails. If this is the case, then we have a bigger issue than what a tool allows us to do. However, we are certainly not suggesting that we should allow everyone to do everything. Of course, we need to draw some lines among different roles, but we should minimize them to improve user experience with our system.
4) Mange the context.
All user actions have contexts. The context depends on what action was taken just before, what role a user is in, the location a user is coming from, what time of the day it is now, etc. etc. among many other things. Most applications don't do a good job of taking all these into account and making it easier for users to perform the action. For example, if you go to "Groupon" site for the first time, it forces you to choose a city or login/signup before you can see the current deals, whereas if you go to "Livingsocial" site, it recognizes your location, and allows you to go the current deals page for that location. Which one do you think is more user-friendly? Manging the context is becoming easier and richer (with location and other contextual inputs from other connected apps- i.e. social networks) now-a-days. It is in fact expected of applications to manage the context more intelligently.
5) Personalize interactions.
Personalization has become popular among applications now-a-days. We see this commonly implemented as "My page/data/tasks
6) Don't interrupt, allow "undo".
Traditionally we have designed applications with many little interruptions in the form our pop-up prompts. This form of interaction design has been popularized by Microsoft. Here is a good illustration of this by Joel Spolsky in his Business of Software conference talk. The most common and popular of such interruptions is a "delete prompt"- asking user to confirm their intent to delete something. The thought behind it is users might accidentally clicked "delete," when he did not mean to. We know these situations are rare. We are interrupting all users most of the time for those rare occasions. Google has shown how we could avoid these type of interruptions by implementing "undo." We don't have to implement/support "undo" for all users actions. Given the context and domain of the applications, we could pick and choose actions that could benefit from "undo."
7) Learn and accommodate.
We are just starting to see more and more applications are designed to learn user behaviors and adjust accordingly. An example of this is Gmail. Gmail recently introduced tracking important emails. It tries to determine whether an email is important based on the context and the past actions by the users- whether the user opens an email from a certain user or with certain subject line for example. Also the users can explicitly tell Gmail which emails are important. Overtime, Gmail gets better at isolating important emails from regular. Recommendation engine (i.e., friend recommendation, content recommendation etc.) is another example where "learning" is applied. I'll use Zynga as an example to illustrate where an application could implement "learning mechanics." We all played Zynga's one of many popular games. One thing they encourage is to post status messages from time to time to Facebook. While I understand the motivation behind this, but it provides poor experiences to users who always choose to skip posting such messages. A better thing to do would be to learn the behavior of individual users and stop prompting for posting messages for the users that always/most of the time skip such actions. Instead, Zynga could provide a visible action button to post a message, just in case these users do feel to brag once in a while.
We can summarize these 7 usability rules into just one as Jared Spool would put it- "increase goal time, reduce tool time." In other words, we should do everything we could to not require users spend time in learning & using the tool (tool time) so that they can have more time doing things that they actually want to do (goal time).
The ultimate test of usability lies in how much training users need (in-person training, or help screen casts, or help FAQs) to start using a product. "A perfectly usable product" would not need any user manual, or training, or FAQs.
Do you have any insights for improving user experience?