Transformed a befuddling desktop application based on the engineers' implementation model into a Web app with an intuitive interface that captured the users' mental model.
Background NetApp's Lifetime Key Management appliance manages keys that an enterprise uses to encrypt its most sensitive data.
  Banks use encryption keys to protect our accounts. E-commerce sites use keys to safeguard our credit card data. Insurance companies use keys to protect our privacy. The government uses keys to encrypt data vital to national security. An organization can have hundreds of thousands — sometimes millions — of keys to manage
The Lifetime Key Management appliance is something of a marvel, but the management application had been designed by the engineers with little input from real users.
The Project Conducted a contextual inquiry. Describing mediascapes and the Mscape technology succinctly was the principle challenge.
  A colleague and I interviewed six current users — and a handful of others who provided useful background information. We weren't able to visit the users in person (they were scattered throughout the country), so we used WebEx to have them show us as much as they could about their typical routine and the context in which they worked with the Lifetime Key Management appliance.
  The research led to two key discoveries:
Users didn't care about keys, they cared about data. Their goal was data availability — making sure encrypted data could be decrypted and read when and where it was needed.
Users were manually managing keys even though that was the very thing the appliance was supposed to be doing for them automatically
  The second discovery — that users were doing manually what the appliance ought to be doing automatically — became the key problem that the new design needed to solve.
  Created preliminary use cases. Distilled UI patterns. The NetApp team I was working with wasn't particularly good at writing things down. There was no PRD or MRD, nothing that stated clearly and completely what the requirements for the user interface — and the application — were. That made it difficult to know exactly what I was designing. So I headed up a little project to create use cases, to spec out each feature in enough detail for everyone to agree on what we were doing.
  (Example: preliminary use cases, PDF, 188k)
  At the same time, NetApp's full-time user experience team was in the process of developing a standard approach to all its applications. Unfortunately, they hadn't yet gotten around to creating guidelines for the approach. So I reviewed all the applications they had under development and distilled a fairly comprehensive set of UI patterns to guide my work.
  (Example: UI pattern, PDF, 308k)
  Conducted a task analysis. Identified the primary scenarios. Created a persona. Developed a mental model. Based on the information we'd collected in the contextual inquiry, I identified the handful of tasks that were the most essential to users. I used those tasks to identify the primary scenarios that best described how users were likely to use the application.
  I created a persona that captured the archetypal user, his goals, his responsibilities, the obstacles and frustrations he encountered — and most importantly the fundamental misunderstanding that led him to manage keys manually.
  My crucial breakthrough — the key to creating an interface that remedied the user's misconception about how to best use the system — was to create two models. The first model illustrated the way NetApp conceived of their system and how they represented it to their users. The second captured the user's mental model. The two, placed side by side, were a revelation — the two models were offset by exactly 180 degrees from each other. NetApp's view of what users needed was upside-down.
  Invented a new representation model. Created an architecture diagram. Developed use cases, wireframes, workflows, and detailed specifications. I invented a new model for representing the system to users — one based the users' mental model, rather than the engineers' implementation model.
  I created another complete set of over 100 use cases, mapping all of the functionality in the preliminary use cases to the new model. I spent the next several months developing workflows, wireframes, and detailed specifications to document the new user interface.
  (Example: use case, PDF, 124k)
  (Example: workflow diagram, PDF, 660k)
  (Example: wireframe with specification, PDF, 456k)
  (Example: wireframe detail with specification, PDF, 1.1Mb)