process archives
Some people talk as if you can make a product “without designing it.” That’s silly. You can’t make a product without designing it any more than you can raise a child without parenting him or her. You may parent poorly or well, but only in cases of extreme neglect could it be said that you didn’t parent at all. Same thing in making products; you either design haphazardly or deliberately, well or poorly, carefully or slothfully—but you can’t avoid Designing.
Designers are often compared to protective parents, watching over “their baby,” reluctant to take criticism of “their baby,” being proud of “their baby.” That’s all well and good—as long as you don’t spoil the child. Good design, like good parenting, requires discipline.
In parenting, one of the biggest risks is that you indulge your child’s every whim under the guise of “loving him or her.” It makes you feel good in the short term. It makes you feel liked. You may enjoy feeling like you’re a good provider because your kids “have it better than you did.” But if you overdo it, you end up with kids who can’t work for themselves, don’t respect you, and are very demanding. Not good for you, not good for them—because you won’t be there in a few years to defend and provide for them. They need to be able to stand on their own merits. The same applies to your design babies.
There is little risk that your design will start making demands on its own, but your own whims (and sometimes even good intentions) must often be curbed. Every time you add a feature, a decoration, a “little something extra”—does it really advance the design functionally or even aesthetically? Or are you “spoiling the child”? Are you adding bells and whistles in order to “keep up with the Joneses,” or are you really just building what’s needed?
Disciplined Design means knowing your audience and their needs.
It means prioritizing and setting limits (to scope, to budget, to resources).
It means saying, “No, you can’t have that right now. Maybe when you’re older.”
It means having a vision of what a product will be when it grows up, but having the patience to realize that it will take time to mature and reach that potential.
It’s saying “No” to some Good things to make room to say “Yes” to the Best things.
It’s applying tough love when your child goes astray, reining in when the design wanders off the straight and narrow path of meeting audience needs and out into the ever-shifting mists of fad and fashion.
So here’s to bringing up a design in the way it should go. Be kind and thoughtful, but also provide discipline, and maybe your “children” will bring you honor and joy, in good Biblical fashion.
posted by
ted
on Monday, Apr 27, 2009
case study
In October, I attended a session by Jeff Patton at UIE13 on doing user experience work in agile environments. I found it extremely helpful in understanding how to improve the process on my current team. I have not yet “arrived,” but the principles learned there have had an actual impact on my processes, as opposed to the “feels good but what do I do now” impression you sometimes get from conferences.
In a “re-print” from last August on UIE’s newsletter, Jeff outlines 12 principles for UX in an agile environment. Here’s a summary of the points in his article (originally broken into part 1 and part 2), with notes on how I have applied these principles to my current project:
- Drive: UX practitioners are part of the customer or product owner team.
This one has been part of my philosophy for many years, but it was good to get some validation. I work with a “product manager” to discover and confirm requirements, meet with end users to see how the product will actually be used, and in other ways act as a proxy owner. The product manager has the final say, but the interaction design role has significant input and is the dev team’s interface to product management.
- Research, model, and design up front—but only just enough.
I found in my current project that cartoons, spare wireframes, etc. that run the breadth of the product, but don’t dive to the pixel really helped the team focus at the right level of granularity. Before I was stuck with two extremes—research and prototype everything completely before the 8 month project kicked off, or research prototype only the next 6 week dev cycle. Allowing myself to cover the whole product, but mostly at a “bare requirements” level struck the right balance.
- Chunk your design work.
Organizing and helping product management prioritize the work has been one of the things I do that product management has most valued in my current project. It has allowed us to stage the development in such a way that we can begin to develop, deploy, and test coherent bundles of functionality with end users—before the project end date is so close that changes become too expensive.
- Use parallel track development to work ahead and follow behind.
I am researching and developing one or two cycles ahead of development, while also tailing the team’s current development to make sure it’s implemented as planned. It’s sometimes hard to stay a full cycle ahead, but it’s made easier by the forethought given in #2 above.
- Buy design time with complex engineering stories.
In my case, we front-loaded the project with security work, dev & QA environment set-up, and API work that required little or no UI. This gave me a chance to get ahead without the team getting behind as a whole.
- Cultivate a user validation group for use for continuous user validation.
While I’ve been able to test with several user groups so far as we’ve gone along, I don’t yet have this in place. The strong study participant pool at Microsoft (and people hired to manage and recruit from it) is one of the things I miss most about not working there anymore. (Ellen Gasca, this one’s for you!)
- Schedule continuous user research in a separate track from development.
Again—would love to… but not there yet.
- Leverage user time for multiple activities.
When testing, I gather artifacts, ask if there are important tasks we haven’t covered in the test, and so forth. While I have face-time with end users, I try to make the most of it.
- Use RITE to iterate UI before development.
I’m not sure Jeff’s description of RITE in his article does it justice, so I’ll wax a little more verbose. RITE testing rests on the premise that it is better to remove “big rocks” after a few participants hit them than to watch participant after participant bang their heads against the same problems. Fix the big problems as soon as they are apparent, then test the solution with the next participants. In other words, by the end of the test, you are validating solutions instead of finding problems.
Michael Medlock and his team at the Games division of Microsoft coined the term RITE (Rapid Iterative Testing and Evaluation), codifying a pre-existing but ill-defined practice. RITE makes usability testing more impactful, and reduces the risk of introducing new problems when fixing others. On my current project, I have done RITE studies using paper prototypes before development began (as Jeff suggests above) as well as in a dev environment after a chunk of functionality was working. It works in both cases as long as the dev team can turn around changes quickly. A key is making sure to trying to fix only issues that have a clear cause, a clear solution, and a small price tag. Bigger or more complex problems will still have to wait till after your test is done.
If you haven’t tried it, read the original article and then give it a shot.
- Prototype in low fidelity.
I actually prefer Jeff’s quote of Bill Buxton for this principle: “The idea of high fidelity and low fidelity in prototypes is silly. As far as I’m concerned there’s only right fidelity and wrong fidelity.” Amen. It depends on skills sets, the level of interaction being modeled, the amount of time you have, and a dozen other factors.
For my current project, I am prototyping first with Balsamic Mockups for the high level pre-project design phase in #2 above, and using clickable image maps (basically a Fireworks png with hotspots added in Dreamweaver), heavily annotated for most interaction details. (I give Balsamic Mockups only 2 or 3 stars by the way; very easy to get something up there fast, but very limited set of representations. If they could just add some simple line and shape drawing tools…)
For other projects I have developed the HTML and CSS myself. For certain aspects of testing I’ve used paper prototypes of screenshots supplemented with sticky notes; it all depends.
- Treat prototype as specification.
In other words, don’t over-document, a classic agile principle. Some would argue that the prototype plus a discussion should replace all documentation. But I find that a well-annotated prototype saves QA a lot of pain and makes it easier to both “work ahead and follow behind” (#4 above). Otherwise it’s difficult to keep track of the details of what the team is currently developing compared to what you are researching and prototyping for the upcoming cycle. Also, there comes a time when updating the prototype becomes a waste of time; the QA says, “I’m finding problem X.” The designer says, “You’re right; we should use solution Y.” And the developer just fixes it. You only have to update the prototype if there is a risk that somebody down the line will have missed the conversation and not know what’s going on.
- Become a design facilitator.
While I haven’t yet moved into full-scale participatory design with users, I have done contextual inquiry with key users lately. I also I meet twice a week to review design ideas and confirm requirements with the product manager, and once a week with the dev team or at least the leads to review the designs, get input, and make refinements. As a group, we get it right more often than I would on my own. I am not just throwing designs over the wall at our developers.
Jeff finishes his article with two choice observations from Jim Highsmith, one of the original proponents of agile development.
Someone once said to him, “We can’t seem to finish anything on time. How do we build software and finish sooner?” Jim responded, “Start sooner.”
Later someone complained to Jim about “getting all this software built on time.” Jim answered, “Build less software.”
Getting interaction designers involved early is one way of “starting sooner”; the whole project runs faster and smoother if we have broken the ground first. And as co-owners with product management, we should be constantly looking for ways to “build less software”, to simplify, to prioritize.
Thanks Jeff, for summarizing some great agile principles to design by.
posted by
ted
on Tuesday, Mar 03, 2009
case study
Here in Northtemple Land, as in many parts of the United States, we’ve received slightly more than our fair share of precipitation in the last week. I have a long driveway to deal with and no snow blower (something I may need to remedy this year with Grandma’s Christmas check). The combination of heavy snow and a long driveway has resulted in an inordinate amount of time spent outside, with nothing to do but shovel and think.
What I’ve learned: Shovel smart, shovel soon, and shovel often. And what’s more, I think this applies to design as well as driveways, and maybe to any problem-solving effort.
First, let’s define some terms. When engaged in snow-shoveling, the stuff I’m trying to clear out is of course snow. What I’d rather be doing is building a snow fort or sitting inside under a warm blanket on the couch, reading that new book I’ve gotten for Christmas.
When I’m engaged in designing or building software, the stuff I’m trying to clear out is a messy combination of poorly understood requirements, technical problems to surmount, and depending on where I am in the product life-cycle, bugs. What I’d rather be doing is visual and interaction design of the “fun parts” of the system, not requirements gathering, trouble-shooting, or designing the more mundane stuff.
Lesson #1: Shovel soon—before anybody walks on the driveway or worse, drives down it. Often this is inconvenient. You or your spouse may have to stay in the car while the other clears an initial path. Your kids might have to clear the way before they head to the park, sleds in tow. But make sure you shovel before you travel; otherwise, you will have packed snow to deal with. And not just for today, but potentially for weeks and weeks, because once it’s packed, the results will be in your way until it melts or you buy a jackhammer. It’s uneven, slick, and hard to shovel. It also can also interfere with your ability to clear adjacent areas.
In design terms, make sure you uncover and understand the real needs before you design anything, and that you design those basics before anybody builds anything. Otherwise some less important or ill-understood requirement gets implemented first. Or you let loose a developer with a sense of aesthetics that doesn’t match the product vision or user needs, or any number of other problems intrude. Once code is laid down it is much harder to change the design—even if it is the wrong code. I’ve seen too many instances of “this is simple, it doesn’t need Design” turn into “oh, I hadn’t thought of that, but I guess we’ll just stick with what we’ve got, since it’s already built.”
Shovel first, travel second.
Lesson #2: Shovel smart—clear an initial, full-length path before attacking the full width of the problem. On my long driveway at least, I find it a good strategy to clear myself two long paths the full-length of the driveway, an axle-width apart. This gives me a clear path to drive on, even if I don’t accomplish anything else. If I decide to clear the rest of the driveway, it also gives me a clear place to stand without getting too wet, without slipping, and most importantly, without packing the snow under my feet.
In design terms, this means I should figure out what that initial path looks like. What is the bare minimum that can be delivered in the product and still have it meet the core requirements, even if there are other rough spots or missing bells and whistles? Figure out those requirements first, then design and build a bare-bones system to meet those requirements. You will probably have a good idea of other requirements and how they should be implemented, but don’t fully design or build it yet. Make sure you can just get the vehicle down the driveway before you worry about whether you can pop a wheely or perform other fancy maneuvers. (This one is so important that I’ll probably write up more specific design experiences with this later on. Thanks to Jeff Patton and UIE 13 for this one. And of course 37Signals and anybody else involved in actually agile development.)
Lesson #3: Shovel often—before problems get too thick to deal with. There are parts of my driveway where the snow can drift up to 3 or 4 feet unless I keep it cleared after each snowfall. If I get behind, maybe sidetracked by the fun stuff I’d rather be doing, I always pay for it in the long run when a 30 minute job takes 3 hours instead. The additional time is often longer than the sum of the time it would have taken had I just gotten to it earlier and more often. Why? Because the snow packs itself down, partially melts and re-freezes, and a single shovelful gets too heavy to lift, because of both increased volume and density.
So too in design. Combining Lessons 1 and 2, you have to keep the path clear—especially the essential path— not just once, but throughout the process. As design progresses to the important but not crucial features, it’s easy to forget that getting out of the driveway is paramount. As you clear the way for those secondary but still-important features, take care that you don’t accidentally make the main path harder to negotiate.
Also, as implementation begins, don’t allow bugs to accumulate for too long before getting them cleared out. This applies not just to the big important show-stoppers, but also the accumulation of lots of small issues. While each flake or bug might be inconsequential on its own, there comes a point when the whole product can bog down under the collective weight of a mediocre implementation of a great idea. The workarounds developers use to get around these problems end up breaking themselves when the bug is fixed; the developer leaves and the next guy can’t figure out the workaround; the user puts up with the problem long enough that they resist the fix, on the grounds that “it’s different.”
Some of this is just bound to happen on any project; bug-free code doesn’t exist, not at a reasonable cost on a reasonable-sized project anyway. But try to limit it to the non-essential periphery, and don’t allow it to clutter the key functions necessary for success.
* * *
Those reading only for design’s sake can stop here.
For those who want to carry this a step further into “real life”, I find that these principles apply to lots of other situations:
- Interpersonal communication. Remove obstacles to communication early and often. “Clearing the air” once is not enough to maintain important relationships!
- Repentance. Sorry to go religious on you, but the longer moral and ethical lapses fester unresolved, the harder they are to clear them up. Much better to straighten up and fly right now, than to let a matter of a few degrees of error land you in dangerous and unfamiliar ground later on.
- And I bet you can think of others and tell me about them via the comment link below :-)
The End.
posted by
ted
on Friday, Dec 26, 2008
“Our design and editorial teams are storytellers. Design begins in a laboratory
atmosphere where we create ideas from scratch. We develop the recipes, the crafts, even the
decorating ideas, we design and build the sets, we choose the colors, we choose the photographer, then we finally after all of that sit down to design the story and that’s why for
us design is both the creation and execution of the idea from start to finish.”
The process that Gael Towey explaines Martha Stewart uses to tell stories.
posted by
chris_mayfield
on Wednesday, Nov 26, 2008
“It’s about whittling. It’s about taking something and whittling and whittling and getting it sharp and perfect. Then you’ve got something.”
James Victore – Designer
posted by
chris_mayfield
on Monday, Nov 24, 2008

Jason Fried (from 37signals) suggests that you question your work
“These are questions we ask each other before, during, and sometimes after we work on something. That something can be as small as a couple-hour project or as big as something that takes a few weeks or more. Either way, it’s important to ask questions like this in order to make sure you’re doing work that matters.”
posted by
aaron
on Tuesday, Mar 18, 2008
Secrets of UX Design Productivity from Google Jake Knapp, a very well-spoken user interface designer, entertained a packed house with a speech on 17 tactics that he uses for creating strong UX work in “the flood” of projects that pour through his UX department from month to month.
posted by
aaron
on Thursday, Mar 06, 2008
“Pouring tons of money, tons of resources, and tons of people at a problem is like using a jackhammer to break out of jail. Putting a few smart people on the problem, embracing constraints, not trying to solve the wrong problems, focusing on precision, not using seven words when four will do, and taking the time to get it done right is like using the spoon.”
Jason Fried from 37signals explains their project and development philosophy, and why you’ve got a better chance of “breaking out” using a spoon over a jackhammer.
posted by
john
on Friday, Jan 26, 2007
Lessons in interaction design can come from the most unlikely sources—your four year old daughter who has just lost a tooth, for example.
She had been wiggling her first loose tooth for a few days, and it finally came out last night. When telling my wife what she expected under her pillow in return for her tooth, she said in fine alliterative fashion, “I want dollars and diamonds. Cause I’m a girl.” The interaction design lesson? Know your audience and what they want and expect.
The tooth fairy, however, apparently has budget constraints. Supply of lost teeth is high and constantly being replenished, while demand for spare organically grown teeth is quite low. So the tooth fairy did not in fact deliver diamonds nor dollars last night, but rather two shiny quarters. What do we learn for interaction design? Customer requirements must be weighed against budget and timeline; quality design is just one of the elements of a successful project.
Finally, though she did not get what she explicitly asked for, my daughter was thrilled with her silvery coins. You see, “diamonds and dollars” were probably just the words she used to convey her desire for “something shiny and spendable”. Those weren’t her words, but it’s what she meant by them. The interaction design lesson: Customers do not always know what they need, or even what they mean by what they say. It’s our job to take requirements, clarify them, push back to the simplest design that meets those requirements—not to play the Yes-Man to our client.
Thank you, Tooth Fairy, and we’ll see you again soon.
(More design insights from the next visit of the Tooth Fairy…)
posted by
ted
on Wednesday, Jan 03, 2007
“The six phases of a design project:
1. Enthusiasm
2. Disillusionment
3. Panic
4. Search for the guilty
5. Punishment of the innocent
6. Praise for the non-participants
”
on the wall of the Greater London Council Architects Department (via How Designers Think)
posted by
john
on Tuesday, Sep 05, 2006