Building great user experiences in software has guaranteed payoff. Great user experiences in software positively affect peoples' lives, even if they only use your software for five minutes a day. That's five minutes where people interact with, focus on, and hopefully have trust in the world you've created.
Does the world you create in software help users along in what they are trying to do, or are you adding to the problems they have? These are questions that all resources on a software project should be asking themselves constantly.
But in addition to these questions, how can you ensure that the software experience you’re creating hits a positive chord with your users all the time? How do you contribute to the solution and not to more problems through your software?
In this blog article, we'll cover a few guidelines from AppBuddy's "Outside-In" system that will help you build excellent user experiences all the time.
1. Have True Compassion for the User
Many times software developers are swamped and do things just to get them off their plate. I know many times I've been in the position where tasks need to get done and little thought is put into why I'm doing it. I just start cranking away. The motivation to just get things done alone is narrow, lacks purpose and often feels stressful to be in.
In order to live a life of purpose, we have to choose our perspective so that we are in constant alignment with our mission. At its core, the mission of software development is to improve peoples' lives. Specifically, people have problems they need to solve. Sometimes these problems cause them great pain and frustration (pain in the mind). Solutions to these problems not only take the pain away or solve the problem, but at their best they improve peoples' lives and make them happier than they were.
Stated differently, software development's mission is to have compassion for the user.
What does it mean to have compassion for the user? It is not simply feeling bad for him or her, i.e., having sympathy for another. Compassion is a very active force. Compassion is first really understanding someone else's pain, giving a damn enough to do something about alleviating their pain, and being driven to replace their pain and problems with something that will make their lives better.
No matter what you are doing on a software development project, whether you’re the developer or the project manager, you should always understand why you are doing any task on that project. Specifically, what was the old way of doing things and why was it a problem for your users? These questions can be answered through requirements sessions. However, in order to truly understand why something is a problem for your users, you need to not only identify the facts about the problem from the user's perspective but also put yourself in their shoes. This breathes life into your understanding so that you don't need a detailed requirements document to spell out everything you need to do at every turn of a software project to solve a problem. This also helps drive you to be creative and see the best solution for your users because now you are personally invested in solving their problems.
2. Broaden the Meaning of "Design"
Much of what is written about designing great software user experiences is about how to create amazing graphic designs or zen-like navigational flows. These points are definitely true, and there are some excellent resources out there on software design principles (list).
We like to think about "design" more broadly though. For example, software design has everything to do with software architecture. One of the key things to realize is that creating great user experience is an iterative process. The better and more flexible your architecture, the more flexibility you will have to change software user experience to meet changing user sentiments and stakeholder requirements. It also means that you will be able to respond quicker to changing needs.
While the subject of creating durable and flexible software architecture is vast, the main point here is that you may have to incorporate some foresight in your architecture so that you can meet the changing needs of your users. While creating quick MVPs (minimum viable products) often means writing some quick, hard-coded things just to get the concept out, you need to spend time upfront in your project refactoring your code so that it's durable against changing needs once your flow is vetted by users and stakeholders. One way to do this is to make certain aspects of your code more generic rather than hard-coded. To decide which aspects you need to have an understanding of what user sentiments and needs might change. This will ensure changes to your software down the line need little or no code changes at all. This in turn provides a better experience to all consumers of your software who benefit from the features they need earlier.
Another way to broaden your horizons is to "design" the perfect software development project that leads to excellent user experience.
All software is created through software development projects. In all projects, we need to be really clear on who the stakeholders are. If you are building software as an ISV, they will be your customers and the product owners at your company. If you are designing software for an internal IT department such as developing functionality for your sales team on Salesforce.com, your stakeholders might be the sales operations folks and the VP of Sales.
After you've identified your stakeholders, you should understand what they need and have a desire to help them. In other words, you need to apply your focus of compassion (see point 1) to them too. You also need to set up a system where communication is open between you and them (see point 3 on Open and Honest Communication). Both of these aspects ensure that you have a relationship of trust with those who you are building software for. When the going gets tough in software projects, (and trust me, it will at some point) knowing that everyone you are working with is on your side goes a long way to solving problems. This level of trust can start with you.
3. Open and Honest Communication
There are a couple scenarios where open and honest communication with stakeholders are critical in software projects: when assessing a problem and your ability to solve it and when communicating status, issues and changes. A lot of times, these situations are uncomfortable for us because we fear the other person may not like what we have to say. However, in these times it's more important than ever to be diplomatically honest.
What I mean here is that you need to deliver your messages in a way that will ensure that the other person trusts that you are being thoughtful and have their best interests at heart. It might mean you also deliver the message in such a way that their personality type will be receptive to. Above all, however this message is delivered, you must confront the facts and make someone aware of what you are all up against so you can come up with the most appropriate solution.
Going back to compassion for a moment, it's necessary to understand someone’s problems, not their needs. Someone might say that they need a Rolls-Royce to get downtown when a taxi cab will solve their transportation problems just fine. Many times stakeholders have a lot of preconceived notions of what they need. Your responsibility to deliver the best user experience possible is to get to their root problems. I guarantee you if you solve their problems not their needs, you will produce durable user experiences that users will magically love.
So don't be afraid to be honest when you feel it's your best professional opinion and you have the users’ interests at heart. The best way to ensure you do this is by getting out of the way, meaning you don't think twice about your own interests but focus on what is important -- to serve your users and stakeholders.
Another way to ensure open and honest communication is to ask thoughtful questions. This gets everyone to feel comfortable to freely exchange valuable information. Once everyone feels free to communicate, everyone understands the problem and your capabilities to solve it, and it will be much easier to come to agreement on what needs to be done.
Putting It All Together
These are principles that have been very effective for us in over 10 years of software development. Building great user experiences in software is definitely about coding the right 1's and 0's and having something that is visually pleasing, but the way you get there is to focus on what's important. Software is about people. The principles of compassion, relationship design, and open and honest communication work wonders in getting everyone together to create something beautiful.