Author Archives: sonarc

Today’s Tiny Wow: Basis

While I often focus on the big picture, sometimes the little things stand out and wow me. Yesterday, I got my Basis Band. This fitness watch measures all kinds of things from steps taken, calories burned, sleep quality, heart rate, and much more.

One thing I noticed quickly was that whenever I checked the time, the backlight went on. This is very helpful and a clever use of the accelerometer in the device. It detects the wrist movement that means ‘checking the time’ and turns on the backlight.

This is not remotely necessary to the function of the device, and I can easily touch one of the metal nubs on the face to turn on the light (another tiny wow), but this small behavior adds a bit of delight and intelligence. I wonder if there are any other gestures that the device recognizes?

Some new projects

After a long hiatus, I’m jumping back into the world of content creation. Not only will I be creating more posts for this blog based on my current companies evolution with UX, Agile, & kanban, but I have started a few other initiatives that I wanted to highlight.

Lunch with TED
Lunch with TED is a simple and free way to bring inspiration, perspective, creative thinking, and community to your workplace with very little effort and no money. Simply reserve a room, invite colleagues, and screen a TED talk. I started running them almost two years ago at my last company and have continued at my current company. They are so popular that I decided to share the idea in the hope that others find it useful.

Open Personas Project
A number of years ago, Steve Mulder, author of The User is Always Right, and I came up with the idea for an open source repository of personas. People who had created personas could share them with the broader community, and those who needed a starting point could use personas that had already been vetted to some degree. We can’t do this on our own and are recruiting a team of volunteers to help make it a reality.

FUXT.it
The design community has made so much progress in the past few years. With the success of everything from the iPhone to the Nest, businesses are realizing that good design sells. Sadly, there are still a lot of experiences that are not just bad, they are FUXT. You can help end these travesties by calling them out and publicly shaming them on FUXT.it. Don’t let bad design go unpunished.

‘How to change the CEO’s mind’ – My Response

The following was in response to Mark Hurst’s recent post How to change the CEO’s mind.

UX rarely has power in an org. Often, we must convince those who make decisions that to do what we recommend is beneficial to the company, their teams, and to them as individuals (not necessarily in that order). It’s a permission game. The more permission we are given, the better we are able to do our jobs.

Sometimes we have champions in the org that recognize our value and what we can deliver. Often there are those who at worst know the UX buzzwords and at best aren’t willing to give UX enough of a priority to be effective. Those are the cases where we don’t have much permission to act and can be frustrated at our lack of impact.

In these cases, a more modest approach may be necessary. Each additional bit of value we deliver and can take some amount of credit for will typically give us a little more confidence and permission until we have earned the trust of the one with the power. That can take time. Sometimes a lot of time.

A key decision as practitioners is whether it is possible to change this person’s perspective and if it can be done in a timeframe we are comfortable with in terms of our own growth and career (and whether there are other options available). I’m not saying quit as soon as you hit a wall with a stakeholder. Recognize that change takes time. Recognize that not everyone will change. Decide whether you have the patience to wear down the rock.

That being said, I agree with Mark. The transformations that stakeholders can have from seeing real users interact with their product can be amazing. However, as many commenters pointed out, you need to have permission to first do the testing and then for the stakeholders to trust you enough that they are willing to change their minds based on the test results in order for it to be effective. This is less about the techniques you employ then it is about your relationship with your stakeholders.

From Sketch to Code

One of the issues often discussed regarding the integration of UX and agile is the amount of UX documentation that is appropriate. There are many who recognize the value of a little, or sometimes a lot, of upfront design, while others see it as waste. The answer is less ‘or’ than ‘and’. Clearly a design by itself delivers no value until it is built and delivered, and no one in their right mind would challenge the necessity of software engineers. Most projects could also benefit from some amount of thinking prior to coding. The challenge for each team is to be constantly searching for the right balance for their team, in the current sprint, working on a given story.

Two Ends of the Spectrum

I think that most would agree that when a concept is in its infancy and the rate of change is high, it is more effective to iterate through the designs in a lightweight way, without code. Despite how easy it is to quickly generate working prototypes, it is still not as fast as some of the most lightweight design tools, like whiteboard, paper, napkin sketch, or even wild gesticulating. When ideas are vague, there is no consensus on the basic direction, and the impacts are not well understood, it is far more effective to work collaboratively with stakeholders on low fidelity sketches than to create interactive prototypes followed by group reviews.
On the other end of the spectrum, it is far more effective to make small changes directly to the code, and, if possible, forgo the overhead of continuously updating the design documents. At this point, when the design has solidified, stakeholders agree on the vision, and the rate of change is small, let the finished work speak for itself as much as possible. Only update documents to describe complexities that would not be obvious by looking at the finished product.
In the middle are steps that might include one or more of the following; refined wireframes, light ‘throw away’ prototypes, graphical comps, or even detailed specs.
The logical question is when to transition the design to code. Like many agile questions, there isn’t a single answer, but here is one way to think about the question to find an answer that will make sense for you.

Put Another Way

It design time is D and subsequent coding time is C1, and code and revision without any upfront design is C2, then the goal is for D + C1 < C2 AND the output of C1 is ‘better’ than the output of C2. If you don’t agree with this goal or don’t believe it is possible then I probably need to convince you of the value of UX to agile (post coming soon).
If D + C1 > C2, then it must be offset by an even greater improvement in quality of C1 over C2. (Thanks to Adam Sroka for inspiring the mathematical representation)
Keep in mind, what makes sense for one team/sprint/feature combination may not work for another. There have been instances where I’ve sat with a developer an said something like, “Take this widget from this page and add it to this page over here and make it look like the other widgets on that page.” No wireframe. No document of any kind. One developer and one UX’er sitting together knocked it out in under 20 minutes, iterating as we went. There have also been complex interactions with impacts throughout the product that required more extensive exploration before the design stabilized enough that development felt comfortable proceeding. It wasn’t unusual to have both of these kinds of stories in the same sprint.

The Bottom Line

The reality is that you never get to do the same story with the same team in the same context twice, so there is no way to measure the difference. Ultimately, it comes down to a judgement call between the developer and the UX’er.
UX needs to be willing to abandon the design document before the design is complete and collaborate directly with a developer on it’s evolution, and developers need to be willing to take a step back and explore what they will build before writing to much code.
How well does UX and dev work together in your team? Please share your thoughts on this post in the comments and take a moment and rate this post using the stars beneath the title.

Only You Care How It’s Built

Remember the last time you were really frustrated when using something? It didn’t work as you expected or you couldn’t find what you were looking for. As your attention focused on the people who built the tortuous tool, do you remember thinking to yourself, “That’s OK. I hear they have a great process.” No? The unfortunate truth is that the people you are building for will not care how you got there, only whether you solved one of their problems in a positive way.

I think this is one of the reasons behind the first agile value, “Individuals and interactions over processes and tools”. It is tempting, when integrating new practices, such as with scrum, to get caught up in the mechanics of a new process. There are new ways of working and new tools to learn, and these can take a lot of time, energy, and focus. It can be tempting to do things ‘by the book’ when first starting out, but that puts our focus on the wrong goal. The team is not there to perfect a process, but to deliver value to real people.

So why “Individuals and interactions,” and not “results”? Results don’t make a product, people do. The people are the invisible force that create the product. As one of the agile principles states, “Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.”

Pixar’s Randy Nelson has a fantastic definition of collaboration not as cooperation, but amplification. A good team that works well together will amplify each others’ skills and abilities to create better results than they would as individuals. This definitely resonates with my personal experience. My best ideas usually come when I’m engaged with others, not when I’m by myself. Sure, I have a few Eureka! moments wearing headphones, pushing pixels, but the bulk of them come from the interaction with other minds approaching the problem from different directions, each with their unique personal history.

There are many elements that create an environment that a allows a team to succeed. As implied above, clear goals and measurable results is one. I’ll go into that and a few more in a future post. In the meantime, what is it about your environment that supports or hinders your team? Do you have motivated people? Do your stakeholders trust you to make decisions on their behalf? Are you focused on value? What have you changed about your environment that has had a positive impact?

As always, I look forward to your comments. Also, please take a moment to rate this post by clicking the stars below the title. It helps me know if I’m on the right track and I really appreciate the feedback. If there is a specific topic you’d like me to address, add it to the Suggest a Topic page.

Going Back to the Source: The Agile Manifesto

There are a lot of different ways to implement agile. That is one of its strengths. Agile allows you to create exactly the process that works for your team, company, problem, and client. However, it also gives teams the responsibility to create that process, and that is difficult. Teams typically can’t rely on doing things the way they’ve always been done.

Whatever practices are put in place, be sure that you are true to the agile values and principles. I’ve been interviewing with many companies over the last 6 weeks <shamelessPlug> (I am available for work in the Boston area) </shamelessPlug> and I’ve been surprised at how many people are talking about agile, have not read the manifesto, and think that agile is about sprints, daily meetings, and a lack of big upfront design.

Agile is 4 values and 12 principles. Period. It doesn’t say whether to do upfront work or not, or to work in sprints, or to have backlogs, or to start coding right away. These are techniques that some teams have used based on agile, and others have codified into practices such as scrum, but these practices are like the reflection of the moon in a pond. If the water is choppy, the reflection is broken and unrecognizable. If the water is still, the reflection is very clear. Yet, as alluring as that image may be, it is still not the moon.

If you have never read the manifesto or haven’t in a while, do it now. Really. Go. I’ll wait. It’ll only take a minute.

Back? Great.

One of the values is “Working software over comprehensive documentation”. It doesn’t say don’t create documentation, but place a higher priority on working software over comprehensive documentation. Focus your priority on creating something that works more than an exhaustive description of something to build. Make sure that the documentation the team chooses to create has lasting benefit.

The values are not absolutes, but relative statements. If you adopt practices associated with agile without understanding the conceptual underpinnings, you may find that you are not getting the effect you hoped for, or maybe there are better practices that would support those values better given the unique situation of your team. A team that adopts the practices without incorporating the principles will be like like the moon’s reflection on choppy waters. It will be tough to see a coherent vision of what is being done. A team that chooses its activities based on how the values fit them will be like the reflection in a still pond.

For me, one of the most evocative parts of the manifesto is the last principle, “At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.” That alone, is worth the price of admission.

Please take a moment to rate this post (under the title) and leave your comments. Which elements of the manifesto does your team most embody?

Do Disruptive Startups Need UX?

According to Clayton Christensen in The Innovator’s Dilemma, markets for disruptive technologies may not be known prior to release and therefore often cannot be planned for. Where does that leave UX? How can you do research if you don’t know who to talk to? How can we do any user-centered design if we don’t know who the users will turn out to be and how they may use the product? So what is the value of UX in an early stage start up or similarly innovative team?

While he doesn’t say so explicitly, his research seems to favor an agile approach. Constantly evaluating  the product to determine who is using it and what value they are deriving will allow a team to focus their efforts on the goals most important to this new found audience.

This points to two clear uses for UX in the early stages of the creation of a disruptive technology. The first is to give the product the best chance of success by inc0rporating design standards and best practices. The second is in researching the new population of users, their activities, goals, and behaviors.

You only get one chance to make a first impression. Leveraging interaction standards will help give a new product the best chance for a positive initial reaction. Design standards may not work for everyone. They are, by definition, generic. However, it will make the product most likely to be usable by the broadest possible audience. In addition, while aiming for ‘just barely good enough,’ make sure that there is a shared definition of the level of quality required and that there is a UX component to that definition.

Once the first release is live, analyze the user activity. Reach out to some of the most active users. Talk to them about what they love, what they don’t like, how they found out about you, etc. Keep probing each answer for more detail. Find some users who signed up but never became active. What made them interested initially? How did they find using the product? Why did they stop? See if you can define the gap that prevented them from becoming active users.

Once similar stories of real people deriving real value begin to emerge, then we can start to leverage familiar UX tools to move beyond best practices to create a tool that supports the unique needs of those using it.

Having UX involved from the beginning will help you recognize the market when it emerges and be ready to meet its unique demands.

Share your experiences designing new or disruptive technologies. When was UX involved? While you’re at it, please rate this post using the stars beneath the title.

When Adding Waste isn’t Waste

Naresh Jain over at Managed Chaos was griping about The Bloat Effect. The gist is that as time moves on, everything gets bigger and more bloated, including the software, the team, and the process. This makes everything less valuable as a result.

There is often waste in our process. Sometimes it’s given to us and we have to deal with it. Occasionally we introduce it willingly. Often, we start out bloated. We may have an idea of what the streamlined, efficient process looks like, but it’s not what we adopt. Often there are good reasons, or at least reasons. We are, after all, smart, intentional people.

First of all, a definition of waste. Anything that does not directly add value to the customer is waste. Anything that causes you to spend more time than is necessary, is waste. Anything built but not used is waste. Anything that hinders progress is waste. A common goal of any process is to minimize waste, but sometimes we need it. Sometimes waste in the micro saves work in the macro. Waterfall is kinda like this. The theory is that the more you can remove uncertainty with upfront work, the smoother the project will be, ultimately saving time than if the project had tripped over some of the intricacies later in the cycle, or at least having predictable results with predictable resources. Of course, we know how well that usually works out. Agile aims to minimize all of this waste through multiple iterations and is comfortable with whatever revisions may be necessary later on, based on what we learn.

Recognize the role that waste is playing.

If you are being asked to do something you consider unnecessary, find out what need it is filling. If there isn’t one, you may have an argument for eliminating the task. If there is, you may be able to find a leaner way to solve that need. If you don’t have the authority to make the change, you may have to figure out who in the organization can and convince them. Unfortunately, waste is often thrust upon us with no recourse. Then it’s back to a software version of the serenity prayer, accepting what we can’t change and working on what we can. Sometimes that’s just just ‘how it’s done’.

However, you may choose to add steps into your own process to save time later on. If you experience a frequent roadblock that causes a lot of churn, you may need to add extra steps upfront to deal with it. For example, if you have difficulty communicating new concepts to key stakeholders, perhaps more time needs to be spent fleshing out those ideas before they are presented, especially if you believe that they are justified by the business and user needs. Do you spend time that feels unnecessary? What steps could you take earlier to minimize this unnecessary expenditure of effort? Would the trade-off be worth it?

Simplify as you go

Even if you can’t immediately change the process, you can work to simplify over time. Just because there may be legitimate reasons why you live with the excess now, don’t let that keep you from working to improve the process. This is one of the 12 principles of behind the Agile Manifesto. Can you take a small step the next sprint, or the next release, to streamline? Can you keep educating those insisting on inefficient methods in better processes? Is it waste or is it really saving you time later on? People may be hanging on to tools and processes that they are familiar and comfortable with. Moving them away from them too quickly may be difficult or undesirable in the short term. As you demonstrate success, you will have the freedom and trust to make changes and put past process attachments to rest.

Is it Agile?

As you evolve as a team, you may encounter people who tell you that, ‘You’re not Agile.’ They may be right. You may not be capital-A Agile, but I think the key questions are:

1. Are we doing better this sprint than last sprint?
2. Are we making changes that we expect will enable us to perform better in the next sprint?

Adding value

To often I’m concerned less with removing steps than with adding them. It seems common to encounter an engineering team that has been using agile without the benefit of UX and now they are experiencing some pain. There is often the misconception that waste is anything that is not working code. At the recent Deep Agile Conference, James Coplien indicated that, “Rework in implementation is waste, rework in design is agile.” Adding in a quick usability test to uncover design flaws early is not an outdated process to be slowly abandoned. It is a positive practice that should be introduced where it is lacking. Engage with your users, gather feedback on your product/designs, measure your results. These are steps that do not directly contribute to customer value, but they are some key elements that form the foundation of a solid product. Waste needs to be looked at in the context of the entire product, not just the tasks that any one individual or team are performing.

Failure: The Secret to Success

Honda has produced a series of short ‘documentaries’ promoting Honda innovation. I’m usually quite critical about this kind marketing content masquerading as entertainment, but having watched two so far, I can say they are well produced, engaging,  and only tangentially talk about Honda.

This one is about failure. I don’t think about failure much, even though some might consider that I’ve been around it quite a bit. Many companies that I’ve worked for didn’t make it, or had to cut back during hard times, but I never thought of them as failures. With each one, I often had great results with my piece of the company puzzle, met brilliant and talented people, and learned a hell of a lot. For me personally, that’s a success.

Projects come and go. I try and make sure that whatever I spend my time on is going to give me a great experience, draw on my strengths and knowledge, and give me new challenges to learn from. If it doesn’t work out, I’m very disappointed, but I take what I’ve learned to the next opportunity.

Oh, and it needs to  pay the mortgage. Can’t forget that one.

From Salon (login or adroll required) via Neelakantan at Interim Thoughts.

If you are an older subscirber, please update your RSS feed, or if you haven’t yet, subscribe to this blog’s RSS feed. Don’t know what RSS is? Check this out for an explanation of RSS.

Listen, Don’t Obey

As Tim correctly pointed out in his comment on the previous post, waterfall doesn’t exactly have a stellar record of success. In my experience, a major cause for that is shortchanging the upfront research that is necessary to ensure the success of subsequent stages of development. As I said in my comment, often the proper upfront research that would shape the vision of the product based on business need and customer understanding is sacrificed to meet aggressive deadlines and tight budgets. It’s no wonder that the final product is underwhelming, despite the best efforts of everyone on the team.

If these prior adventures in development have failed, why not try something radically different, like agile. If the organization is not willing to put the effort into a proper upfront research and design phase, then build something and hope you get useful feedback on it, right? It sounds good, but then why do we still find some of the same problems?

Tim hit it again. Often customers, or users, can’t tell us what they want, even when we do ask, or what they say they want is not the best way, or even a good way, to solve their problem. This can happen in waterfall or agile. Customer requests come from their perspective, which is via their domain expertise. They are experts at their tasks, but we are supposed to be experts at designing interactions. The key is to understand the problem and solve it, not just implement what our users request. Maybe the users’ suggestion is spot on. At the very least, these suggestions tell us where to focus our attention. We’ll likely find where pain can be removed or gain can be added. But when it comes to designing the solution, we need to bring our advanced knowledge of computer interactions to bear and conceive of the best ways to address their needs which may be better than our users could imagine.

While working on a call center application, I spent many hours sitting with agents, listening in on customer calls, and observing how they worked. Between calls, I asked a lot of questions about what I heard and what I observed. After only a day or two of this, I had a very good understanding of what their work was like and what their challenges were.

When I asked them what they wanted, they typically mentioned incremental improvements to their current tool, an old ‘green screen’ mainframe application. In fact, when asked if they wanted digital catalogs to replace their large rack of physical catalogs, they categorically said ‘no’. They wanted things similar to how they were. As one agent put it, “I don’t like change.”

However, the time I spent with them plus my understanding of the business challenges led to a radical design in a Flex environment that was light years ahead of what they were used to, and it did include digital catalogs. So how would the agents respond, especially given that we did something they expressly said they didn’t want?

We tested a rough prototype with a handful of novice and experienced agents. The feedback was overwhelmingly positive. At the end of the hour usability test, even the woman who didn’t like change wanted to know when the system was going to launch. She felt it was a dramatic improvement over what she had been using, and had mastered, over the past 13 years as an agent.

So do talk to your users. Ask them what they want. But when it comes to defining the solution, remember that you are expert when it comes to building tools. Just be sure to test your design to make sure you got it right.

To see the comments, or to add your own, click on the little speech bubble below. To subscribe to this blog using RSS, click here. Also, be sure to check out the Suggest a Topic page to vote on future post topics and to suggest your own.