You might already know how to improve your code by removing complexity and making sure the code is performing well. But do you struggle with creating nice workflows for your content creators?
At one of my workplaces, we had the trouble of having really bad workflows. They were the result of programmers speaking directly to content creators and implementing exactly what they asked for. Now, you might think that is a good thing. You should always listen to the client, right?
The main problem is that neither programmers nor content creators know what it takes to create a good user experience. They could both identify that the experience was less than ideal but didn’t really know how to solve it. It’s like seeing a painting and being able to tell that it’s ugly, without knowing how to paint. The result is an over-use of swear words in the office when people get frustrated with the bad workflows. Furthermore, it results in worse end-products since the iteration times don’t allow for that much polishing.
I’ll give some tips that you can use to improve the daily life of your content creators. This, in turn, will save time for both you and them.
But first, we’ll have to define what workflows are and what makes them good.
What Are Good Workflows?
A workflow is a series of tasks that a user needs to complete in order to accomplish his end goal.
Now let’s break that down because this is crucial to understand.
The first part talks about a series of tasks. There is a planned out path here and the tasks are not random. In a good workflow, they are very well thought out and optimized. This will serve as the foundation of creating any good workflow when we describe the process further down.
Now, without having an end goal in mind, it is impossible to break down a workflow into tasks. That is why the second part of the definition is also important.
But, how do we differentiate a good workflow from a bad one? The short answer is, it depends. It depends on who the user is, what the end goal is and what the tasks are. A good workflow for one user might be a terrible one for another.
The user needs to be the center point when designing a good workflow. That is why user experience (UX) designers put a lot of thought into who their users are and spend time observing and interviewing them. But you as a developer can get pretty far by just changing the way you approach workflow creation. And you also have the added benefit of being a developer, meaning you will be able to hack the process.
You should optimize workflows to minimize two things: Time of completion and cognitive energy required. Identifying the trouble spots requires some different strategies and I’m going to cover some of them.
But first, a word of caution: Not every workflow needs to be optimized. You must carefully choose the workflows that are most commonly used. Optimization takes time and you are kidding yourself if you think that optimizing rarely used workflows is the best way to spend your valuable time. That is why you need to start with collecting data, a process which should ideally be automated. And this is where you can start hacking.
Data Collection Using Telemetry
Having some form of telemetry integrated into your application allows you to collect valuable data. This data can give insight into exactly what users are doing and what is taking up time. But there are some things to be aware of.
First, you should make sure that your collected data represents the active time that the user is actually spending on workflow tasks (as opposed to grabbing a coffee). There are several ways to do this. But having some sort of idle timer is an easy way to go.
Second, measure the tasks as they are executed from a user’s point of view. Every interaction that the user performs should generate a data entry. This way, you are able to identify what the users are doing and find common patterns. Make sure that each entry is both uniquely searchable and humanly readable. You could use some sort of identifier together with a description. For example: “level_002: Move object: ‘castle'”. Then combine this with timing data.
Take the opportunity to also send crash data. You’d be surprised to know how few content creators are filing bugs when the application crashes And your telemetry data can prove valuable in finding a repro.
If possible, tell people to do quick screencasts when they are working. You could also sit beside them observing and taking notes, but a recording is doing the note-taking process much better. Observing and interviewing has other purposes though, and we’ll get to that.
Now, all of this will take you pretty far when it comes to getting insight. But you could do even better and even implement a system that records the user’s actions and is able to play them back with the correct timings. I will cover such a system in a later post.
Once you have collected data and identified trouble areas, you are ready to do something about it.
To Profile or Not to Profile
One thing that might show up in your data is that some processing done by the application is taking a long time to complete. Optimization of such trouble spots is no different than any other code optimization. Just bring out your favorite profiler and start identifying code to optimize.
But computation time is rarely the real problem with bad workflows. The bottle-neck is more often than not the user’s ability to work efficiently due to constantly having to repeat unnecessary steps or feeling overloaded with information. Identifying this type of issue is harder, yet still possible.
Watch for Pauses and Detours
If you have a screen recording or a playback, you might watch it with the sole purpose of trying to mark pauses and detours in the flow of the user. Is he getting stuck? Does he do things correctly or does he seem to have trouble figuring things out? You are looking to identify parts of the workflow that are hard to understand or are otherwise requiring a lot of thinking or trial and error.
You might actually go ahead and ask the user if he remembers what happened. It is important to figure out the reason why something is hard. UX designers do this by asking questions while observing users.
Walk a Mile…
Another tip is to actually go ahead and reproduce the sequence of tasks yourself. The amount of insight this might give may surprise you. Once you start actually using your software in the same way that a user is using it, the same things are likely to annoy you.
Make sure to take note of any thoughts popping up, maybe even speaking them out loud into an audio recorder so that you don’t interrupt your flow too much. These thoughts could be something like:
- Why did I have to do this twice?
- There really should be drag and drop for this…
- This dialog is requiring an extra click. Is it necessary?
- Why is this not available as a keyboard shortcut?
Can you see where this is going? Now try doing this a couple of times and you will no doubt discover things that feel repetitive or time-consuming.
Reducing the Number of Tedious Actions
Ofter, you can make some easy wins after collecting insightful data. You might have discovered that a sequence of actions contains unnecessary steps. One way to deal with this is by listing all the steps needed to complete that action. For example:
- Click the add object button.
- In the dialog that shows, click the name text field.
- Type in a name for the object.
- Click the dialog’s ok button.
- Place the object in the scene by clicking where you want it to go.
It is very important that you list all of these interactions as they all add up to create a less than ideal workflow.
Then, your task is to make this list as short as possible. In this case, you might easily eliminate step 2 by automatically focusing the text field. Another question to ask is if you really need the dialog. Dialogs tend to interrupt the user’s workflow. Maybe you could just make the name editable in-place? You may continue the simplification process until you end up with a list like:
- Place the cursor in the scene where you want the object to go.
- Hit the keyboard shortcut for add object to place an object in place, alternatively use the context menu.
- A text field pops up over the object and the user can enter the name in place. Or he can accept the default. In any case, to commit the name, just clicking somewhere outside the text box or hitting the enter key on the keyboard will do the trick.
Now, this might not be the perfect example and the new workflow may not be the best either. But the only way to find out is to test it. Prototype and compare. Can it be simplified even further? Do it!
Reducing Cognitive Overload
If the user gets confused or stops to think, it is probably because he suffers from cognitive overload. The brain is almost like a power source and some bad workflows consume a lot of power. Identifying these is hard. UX professionals put in a lot of effort to look for the right things and ask the right questions.
But as a developer, you can follow some simple guidelines to do your part. The following guidelines will go a long way in reducing cognitive overload:
- Hide unnecessary buttons, data, panels etc. Try things like having different modes for different users so that they don’t have to filter through controls that are irrelevant to them. This is the most important thing you can do.
- Replace text with icons. Of course, the icons must make sense. Preferably, they should be familiar too.
- Try to limit the number of items in any one menu to a maximum of around seven items. Seven has proven to be a sweet spot when it is actually better to group things together as submenus. If we get more, we can no longer learn to remember the items’ positions and will have to read through the text.
- Organize information and controls in general. Make sure to divide them into meaningful groups with spatial separation. Don’t underestimate white-space.
It is possible to add to this checklist and I will be elaborating on these and other topics in a separate post.
If you can master the art of creating good workflows, you will be at a competitive advantage over other developers. And your users will be happier. But doing this requires a lot of information gathering and analyzation. As a developer, you might find creative ways to make your life easier with the help of software to automate this process.
You can’t design workflows in isolation. You need to keep an active dialog with your users. So, whenever you are creating a new workflow, do it in iterations and involve your users. Prototype, let the user test, change, and repeat. This way, you ensure that you are going in the right direction.
Just talking to each other in the beginning to “collect requirements” is not enough. Instead, trust the process of iteration.