How to bring user-centered design to your custom internal apps

For some businesses, every aspect of their internal workflow can be easily and conveniently handled by a professionally-designed, third-party business app. Unfortunately, there are many organizations that don't fit neatly into the mold of mainstream business software. On the bright side, low-code app development platforms have made it possible—even for businesses with limited resources—to build their own custom internal apps capable of accommodating their unique processes.

While these in-house apps offer a promising alternative for businesses looking to streamline their workflow, many of these custom solutions end up lacking in a key area: user experience (UX). Which makes sense! After all, most custom apps aren't designed by professional developers, and those that are, are usually put together so quickly that there isn't much time to plan, investigate, test, and iterate throughout the development process. As a result, low-code developers often focus more on functionality than on the specific needs, preferences, and expectations of their users.

This is a big missed opportunity. The user base of your custom app is made up of your own co-workers (and most likely, yourself as well), making it easier than ever to design specifically for the people on the other end of your solution. Keeping users at the center of your design approach means that tools you create will be easier to use and understand. Focusing too much on functionality and not enough on the human element of app design can result in more user errors, more frustration, and more miscommunication between teams and co-workers.

What is user-centered design? 

Over the last 10 years, the bar for user experience has been raised significantly. Design practices that were standard practice 5 years ago are now considered unacceptable by savvy tech users. The adoption of higher standards is good news for consumers because it means that software companies have begun investing more in the user experience for their products. One of the major drivers for this revolution taking place across the industry is a methodology called user-centered design.

As the name implies, user-centered design forces developers to put themselves in the shoes of the end user at every stage of the design process. Who will be using this product? What are their expectations? What are their pain points? What thoughts do they have? In user-centered design, these questions—and many more—get asked over and over, from the first day of development to product launch and beyond.

User-centered design relies on frequent, rigorous iteration throughout the development process to ensure the user's needs are actually being served by the solutions you're building. Teams work in short sprints that are punctuated by real user testing designed to validate—or disprove—the development team's assumptions about how people with use each new feature.

The value of this kind of approach might seem self-evident now, but that wasn't always the case.

For as many benefits as user-centered design can offer, if you're a team of one or two, developing a custom internal app, it might sound like more time or effort than you want to spend. Don't worry, though. User-centered design is as much about development mentality as it is about development practices. Even if you don't have the bandwidth for more complex user-centered design methodologies, you can still gain a lot by thinking like a user-centered designer.

User-centered design for low-code development 

One of the main draws of low-code development for user-centered design is the ability to adapt and refine your app so that it conforms to your people, rather than forcing your people to conform to your app. If good UX is a priority—and it should be—the ability to quickly revise and make improvements in response to user feedback is crucial.

When it comes to developing internal apps, a low-code app development platform has the unique advantage of being relatively easy to pick up and use by many of the people in your office, whether or not they have a background in tech. When properly implemented, low-code allows you to bring key stakeholders from different internal teams together on the design process for the apps they'll be working with on a daily basis. When the actual users of your app have a hand in its creation, that user-centered approach won't be an afterthought; it will be baked into your process from the start.  This will lead you to make more informed UX decisions and generate more buy-in from colleagues who feel they have a personal investment in the tools they use on a daily basis.

How do I apply user-centered design to my next custom app?  

The truth is there isn't a one-size-fits-all answer to that question. Depending on the particulars of your app, the size of your team, the culture of your company, and a thousand other variables, how you apply user-centered design may vary dramatically. However, we can offer a few tips on improving UX for internal apps by embracing more user-centered thinking:

Conduct research before you get started

One of the most useful practices for developing a good internal app should actually be done before you've even sat down at the computer: the research phase. A key benefit of developing your teams' apps in-house is the ability to get constructive input from your core users. With a relatively small time investment, you can ensure that your app fulfills your users' needs as soon as it goes live.

Whether they know it or not, most developers—even citizen developers—already conduct user research all the time. It happens in every meeting and every strategy session—even in quick conversations around the water cooler. Anytime you're gathering insights from your users (your colleagues), you're doing research. If you think about all of those interactions as research, it can help you understand how they fit into a larger research-based development mindset.

However, what's often missing from these practices is a formalized research process that you—or anyone in your organization—can easily plug and play to minimize waste (both time and resources), and maximize your results.

To start, you'll want to identify the team members who will be using the app most often. Then, you'll want to map out the manual processes that they're currently using in lieu of your app. For example, if you're building an app to keep track of important financial data on a large number of commercial properties, you'll want to map out how your teams currently use spreadsheets, along with any protocols they have in place for organizing, and sharing those spreadsheets with their colleagues.

Next, you'll want to ask these key stakeholders to identify any major bottlenecks within these existing processes, along with any ideas they might have for streamlining them. For example, they might be able to tell you where there are redundant categories that need to be updated across multiple spreadsheets for the current system to function. With all that direct experience, they can probably tell you how the information could be tracked more efficiently within a new, centralized database—a solution you may not have considered when approaching the problem from the outside.

It's important that throughout this information-gathering, you maintain a centralized strategy document that matches concerns and commentary to specific stakeholders, and their role in the process. This will allow you to keep your research organized in a sort of design roadmap that could theoretically be shared with a collaborator to pick up where you've left off. You'll also be able to cut down on excessive meetings and strategy sessions by easily verifying exactly which individual to consult for any specific issue, especially if your role isn't directly involved with the affected team.

Even the most skilled app developer is limited by their own perspective and experiences. By collecting plenty of input before you get started, and continuing to check in as you make progress, you can make informed design decisions that your users will appreciate.

Look for ways to empower the user to do more 

A key tenet of user-centered design is to empower the user with every design decision you make. One easy place to start that empowerment is with routine tasks that eat up a lot of time. Every department has their own set of mundane, repetitive tasks that they're responsible for performing. For instance, HR reps are typically responsible for maintaining employee information in their records. Even if the rep finds strategies to complete more tasks in less time, every minute spent on data entry could likely be better spent on higher-value activities, solving larger and more complex problems. By centralizing too many manual tasks in one person, not only are you wasting bandwidth, but you're also setting up unnecessary and frustrating dependencies. Why force every employee to contact an HR rep every time they need to access simple information, like the amount of vacation days they have left? Is there a better model?

If you're looking to free up time and remove friction from your workforce, look for opportunities to implement self-service design in your internal apps. Broadly speaking, self-service design allows a user to complete a task without another person acting as an intermediary. If you look closely at some of the workflows within your own office, you're likely to find that the only reason a simple task hasn't been converted over to a readily available self-service process is that it's just "always been done that way". That kind of thinking prioritizes legacy processes over the people involved. As a developer, you can reorient your entire offer to be more people-centric by confronting those old and inefficient ways of doing things.

To continue with the earlier example, if you were to create an easily-accessible app that stores and manages employee attendance records, employees can get access to the information they need, while freeing up HR reps to do other work. Once you've got that system in place, you could add even more self-service features, such as a single screen that allows employees to consult or download key company policy documents.

If you approach app development from a self-service mind frame—and thus a user-centered mind frame—you'll be surprised by how many problems you can solve for the people you work with.

Evaluate how app solutions impact human relationships

All the software your company uses makes up a kind of web that connects all the different verticals and stakeholders in your organization together, allowing them to communicate and collaborate as a team. If you overlook user experience when creating custom versions of these apps, you can end up putting efficiency at odds with harmonious working relationships between your employees. If this goes unchecked, it can lead to decreased communication, and even lowered morale. It is the developer's job to think about the impact their apps can have on this web of relationships.

Let's say that you're designing an app to manage your IT inventory and track hardware requests from the rest of the company. While this app may help them stay more organized, they've now become responsible for making sure that every piece of equipment that gets checked out gets returned in a timely manner. They now find themselves in the uncomfortable position of tracking down and nagging their co-workers on a regular basis. Formerly healthy relationships with other teams now become sources of tension. By focusing on functionality over user experience, you've solved one problem while creating another one.   

However, by employing user-centered design thinking, you'll remain attentive to the concerns of your users, and anticipate this kind of problem and build your app to minimize or eliminate it.

Alongside the inventory tracker, you could set up a simple automated system that sends out email reminders and follow-ups once an employee has checked out a piece of equipment for a set length of time. The IT team would only have to intervene personally in edge cases, and when they did intervene, they'd have a record of the ignored reminders to make their case clear. By automating this process, the responsibility for the task—as well as any interpersonal friction—is shifted onto the app rather than on the individual IT staff, reducing their workload and promoting healthier relationships with their colleagues.

You should look at your custom app as a project without an expiration date. After it's launched, take time to evaluate both the impact on direct performance and on team cohesion. If it's not going as you intended, look to the people involved to brainstorm a solution that works for everyone.

The big picture 

With the power of low-code app development platforms, it's become much more feasible to create your own, in-house software solutions for your teams to use and tweak, as needed. However, with the exciting potential of developing new, cost-saving apps comes the responsibility to employ good user-centric design practices. Where a poorly implemented app can hurt productivity and team cohesion, an app desinged around your users' needs can improve morale and boost your company's growth in the long term.