I’m asked by friends who wish to build their own web application or community site to provide a “design”. Typically they are developers who want to dig into the code immediately and to have a design applied once they are done programming. Often this scenario doesn’t produce the best results. It can also be costly in terms of resources. I tend to ask the following questions:
- - What is the problem you are trying solve?
- - Who will be using it? What are their goals?
- - What are the core features that allow for the achievement of those goals?
- - Have you sketched out what it would look like?
Entire books have been written on the subjects of Experience/Interaction/Interface Design and its value in the software development. A great example would be Alan Cooper’s About Face that outlines the building blocks of Interaction Design using their Goal Directed Methodology. These resources are informative and exhaustive. I find the information is better suited to larger scale projects/teams involving clients. Therefore, there is usually a need to have more planning and design deliverables due to the communication overhead. However, the core principles apply regardless of the situation.
What I will try to outline here is geared towards small teams who wish to build a web product (Built for an audience/market segment and not a client).
The first step is to define the problem. As described by 37 signals and mentioned by Kamil on numerous occasions. The problem the Cameesa team had was as follows:
Is there a better way of providing apparel that people really want while having everyone benefit in the process?
The solution was to create a crowdsourcing / crowdfunding platform that had the core features:
- -Ability to sign up
- - Ability to submit a design
- - Ability to support a design
- - Ability to buy a shirt
- - Ability to checkout
From there we began to sketch the idea out in the form of a prototype. I know user experience designers are probably asking, “What, no personas?” When solving your own problems and working with a small team there’s not really a strong need for user needs documentation as you and your team are going are part of the target demographic. A direct result of solving your own problems! Another important item to note is the distinction surrounding sketching and prototyping. Bill Buxton, in Sketching User Experiences states they are not the same. According to Bill there is usually a bigger investment in building a prototype than in creating a sketch that is more disposable. However, with web applications that have narrowly defined feature sets it is relatively quick and easy to develop a prototype. Not to mention the availability of tools that can speed the process up. An example is of such prototyping software is Axure. It’s fairly easy to build a clickable prototype and mimic interactions in a point and click fashion.
A sample screen is presented below:

I find it’s easier than creating a paper prototype because you can drag and drop elements and reuse elements. I find the same to be true of design tools such as Adobe Illustrator and Photoshop. You can move elements around but it maybe hard to create and maintain an interactive prototype.
No matter what tools you use you should always attempt to sketch the idea out in the form of a prototype. This prototype will serve multiple purposes as it is a living document.
- It will be a starting point for discussion in order to improve and define the application further through iteration.
- You can begin soliciting feedback from others and conduct informal testing.
- It will be the blueprint from which you will develop the application.
Some notes on the points mentioned above. You won’t be able to get what you want to build on the first try. You will immediately see gaps that you’ll need to improve upon. Your teammates will identify things you’ve missed. Most importantly it is a tangible expression of the idea. Anytime, I describe a new feature to Kamil his first response is: “I don’t understand what you’re saying. I have to see it.” The misunderstanding can happen for many reasons, including the fact that I am horrible at explaining things. I usually find that presenting the idea visually is always best as language is open to interpretation. This is why I feel functional specifications are troublesome if not accompanied by visuals. People can interpret the description in multiple ways. I find it’s much better to annotate the prototype itself then it is to write a specification.
Furthermore, you have something visual to bring others to collect feedback. The prototype should look rough, unfinished and appear like a work in progress. The reason? People are more likely to be liberal in critiquing something they are shown if it looks like a work in progress. If it looks “finished” people tend to hold back when critiquing. They reason a lot of time was spent and that it maybe hard to change based on their feedback.
If you were able to create a clickable prototype now you can do what Joel Spolsky calls Hallway Usability Testing. For some, formal usability testing may not be worthwhile in terms of cost as it would be by grabbing “the next person that walks by in the hallway”. More so in the time spent in recruiting and compensating participants. Put someone in front of your prototype and have them click through it. You will be able to uncover core problems by having only a few people review it. Tell people to be brutally honest. Don’t let the idea of formal usability testing, with test plans etc. get in the way of you soliciting feedback.
Then when you and your team feel you’ve gotten the prototype to a point where major flaws are eliminated and the idea is well articulated THEN you may start to code. The prototype is the blueprint to be followed to start structuring your code. Core screens and main interactions should be adhered to. It should be understood that you may not be able to copy every item exactly as is represented in the prototype. Technical constraints may arise and as a result minor items may need to be modified.
I find it is usually a big mistake to jump right into the code as significant time can be spent only to be re-done after you’ve decide how it should really work. Even though open source frameworks such as Ruby On Rails and Django have provided us with more agility, it is still quicker to create a prototype first. Once the application is live with the defined core then you may keep progressively iterate your application making marginal improvements. For major enhancements you should always go back to constructing a prototype of some kind.
This post elaborates a little further on Kamil’s post on “Writing Your First Application”. This would fall somewhere under Step 3 in terms of defining your application.