Good design principles can be applied to any type of software. Websitesetuper will help guide you in the process and provide a framework that will produce great results.
Keep it simple:
Complexity is the enemy of usability. As you design and build your software, be sure that it’s not too complicated to use. Every additional feature will add more complexity. It results in a larger learning curve for both new users and power users alike.
Make it intuitive:
Intuitive products are easy to learn because they behave like how people would expect them to work naturally. This reduces training time or help desk calls from frustrated customers who can’t figure out how a certain control functions within a user interface (UI). This requires good knowledge of industry standards as well as user habits. Follow conventions where possible including UI elements such as buttons, menus, etc. But don’t follow them slavishly when there is reason not to.
Use real words:
Don’t use jargon or vocabulary that’s too technical for the target audience. Write your software product so it can be understood by a 10-year old, including clear labels and instructions on dialog boxes. Be sure to take advantage of context sensitive help when needed.
All applications should provide some sort of help, whether it is contextual (i.e., based on what users are trying to do) or through documentation such as an online user guide. Your application should also provide feedback in response to actions that were taken by the end user. This usually takes form in sounds but could include animation if you’re building UI elements within a Web page presentation layer rather than native OS X widgets.
Make it fun:
This may sound frivolous to some, but if your software is enjoyable and easy-to-use you can turn an otherwise tedious task into something that’s actually pleasurable. We all know the best games are immersive (i.e., they immerse us in a game world where we forget our real lives exist). So there’s no reason why applications shouldn’t be as well. Design them with this mindset of immersion by making them engaging enough for users to want to use over existing methods of accomplishing their tasks or through other competing products on the market already.
Don’t annoy people:
We’ve all encountered those nagging dialogs that won’t go away unless clicked on “ok” (e.g., “do you want to save changes?” dialog boxes). There are some cases where this is useful. However, more often than not it’s frustrating for the user who just wants to close out of the window and get on with their work. This also includes full-screen alerts that require manual dismissal before continuing (i.e., popup windows). Especially if these messages stay in view even after clicking buttons or links within your application. You should respect users’ wishes by not interrupting them unless absolutely necessary. It means no pop up notifications during normal usage!
Provide good documentation:
Help files may seem like an unnecessary addition but they can be extremely valuable when needed. Imagine how much time would have been wasted trying to solve a problem if there wasn’t an easily accessible help file to look up! Engaging content is better than just adding boilerplate documentation; make it personal and interesting, perhaps even include screenshots.
Another great way of guiding users through the process of using your software is by providing example files they can load and play around with (e.g., sample documents for word processing applications or photos/videos in image editing programs). If you’re targeting enthusiasts who enjoy tweaking settings then consider showing them how this would affect certain aspects within their media such as color correction curves on an RGB histogram. It’s like giving candy to children!
Keep it focused:
Make common tasks easy, but not too easy. If the system prevents you from making mistakes or does things automatically that could be done by hand then humans have no opportunity to exercise judgment and will become bored over time. Users should feel in control of the system at all times.
Avoid designing “wizards”:
Wizards (a series of multiple screens where users can make choices) often go wrong when they attempt to anticipate every possible choice before laying out options on screen. This is because people don’t think like computers do. We can infer what’s on the screen.
If there is more than one way to do something, then provide a “smart” method. The best software provides methods that are easy and quick for users who know what they’re doing. But also allow people who don’t have time or energy to figure out how to accomplish their goals efficiently.
Design dialog boxes carefully:
A good design requires some thought about information architecture. Because it’s important not only where options are placed on the page, but also what order they appear in. People will make assumptions based on your interface. So try making those assumptions work with you rather than against you by placing them in logical positions within the workflow of completing a task (see next rule).
Respect the platform:
A well-designed interface is consistent with the platform’s conventions and uses standard control keys. This makes it easier for users to switch between applications within a suite or from other suites. Because they will be able to learn your software more quickly if you respect their knowledge of how things work on that system.
Iterate and improve:
Designers should continually ask themselves “how could this feature be improved?” It doesn’t matter whether it works well now as long as there are ways in which it can be made better by iterating (repeatedly improving) what already exists, rather than starting over completely each time an improvement comes along. We don’t always need brand new features; sometimes we just need one small tweak here and there to fix an issue with what already exists.
Keep it consistent:
People should be able to predict how things will work in your software. If you don’t stick with conventions then goals become more difficult to complete. Because the user has to figure out how everything works all over again for each screen they go through, rather than just once (which is less taxing on their cognitive abilities). This also helps people feel better about using new features in your application when working within a familiar interface that doesn’t change too frequently.