Micro Focus is now part of OpenText. Learn more >

You are here

You are here

5 ways to incorporate design thinking in your dev process

Heather Woo Senior User Experience Designer, Finastra

Software developers are becoming increasingly mindful of the need to provide an exceptional user experience for customers. Ultimately the user determines the customer experience, so understanding how to deliver a seamless experience is key to delivering products that meet your customers' needs.

Something as simple as having to wait for a screen to load or confronting a confusing interface can sour a user's perception of a product. To prevent this outcome, many development teams add user experience (UX) designers. This practice embodies an integral principle of DevOps, which focuses on bringing together multiple disciplines to shorten the software development lifecycle.

But when you're combining different areas of expertise, you may find that there's a learning curve to get to the point where you understand where everyone is coming from. Here are five tips on how to get designers and developers off on the right foot.

1. Get everyone involved from the beginning

It's tempting to think that design comes first and development second. But that doesn't mean developers shouldn't be involved in the design process. Developers can provide important technical insights into how a design should be implemented, while designers provide a better understanding of users' requirements.

It's better to figure out sooner rather than later that a feature isn’t technically possible or does not satisfy user requirements. When designers and developers work together, these issues can be spotted and addressed right away, rather than after designs have already been approved.

Many organizations are adopting a more collaborative approach to software development, instilling a DevOps mindset that ensures teams involved across the product development lifecycle are mindful of other stages. This way of working means teams no longer hand off to the next team when their work is "done," but take collective responsibility for everything from security to testing to design.

The key to effective design is the ability to empathize with users. Involving developers in the design-testing process allows them to gain a better understanding of whom they are developing for, which means they can scale back or build out features accordingly.

2. Explain the UX process

Someone who's not familiar with the UX process may not understand why teams revise a design over and over for seemingly minor details. Every step in the UX process is there for one reason: to give the user the best experience possible. Establishing the rationale behind the UX process at the start of a project is vital.

The basic steps should include:

  • Research: Figure out who the user is and what they're trying to accomplish. What is their goal? What problems do they run into?
  • Create wireframes: These are bare-bone designs to get the main features of a product established. Instead of focusing on which colors and fonts to use, designers focus on the user's major interactions.
  • Design: Once the key features of the product have been laid out, you can add finer details such as the UI of the product, and you can create prototypes detailing its finer-grained interactions.
  • Test: Testing your designs with users is perhaps the most important stage of the UX design process. This provides valuable feedback about the product before you've spent any time on development.
  • Iterate: Using the feedback gathered in the testing stage, iterate designs to enhance the user experience.

Teams repeat the design, testing, and iteration steps multiple times until there are no more changes to be made, or for as long as time allows. This means you will end up with multiple versions of a design.

After the first few rounds of testing, the main bones of the design should be established enough that the development team can get started. But it's important to note that as long as the cycle of testing and iteration continues, the design is not final.

Developers need to be prepared to make changes based on the results from testing sessions. Everything in a design—​even something as simple as text justification—​is done to create the best user experience.

3. Establish how designs will be shared

Chances are, designers will be using design software that developers may not be used to, or even have access to. This is both counterproductive and anathema to DevOps practitioners, as is any process that hinders collaboration.

Having a central location where developers and designers can view designs is essential. These designs should also be available in easily accessible formats, such as PNG or PDF.

Establishing an effective line of communication between the developer and design teams is crucial to the successful implementation of any product. Avoid blind hand-offs at all costs, since this increases the risk of repeating work unnecessarily.

InVision is a tool that integrates with Sketch and Photoshop, allowing you to share designs online. Designers can upload their designs straight from their design software and developers can always see the latest version. It also has strong prototyping capabilities, so designers can show how you're supposed to interact with the design.

These features help developers understand how the product is supposed to work for the user. The comment feature also allows designers and developers to communicate and collaborate with one another directly on the design, ensuring fast feedback and iteration.

4. Determine which stage your designs show

When they're asked to design the minimum viable product (MVP) version of a product, designers want to know the requirements for the general availability (GA) version as well. They need to take into account the final state of the design from the very beginning to ensure a smooth transition between the MVP and GA stages.

That's why designers often have a general idea of the design for the GA ahead of time. In some cases, they might even have examples of a final design available.

But this can cause confusion for developers and product managers with regard to what's being implemented and what's expected. To combat this, designers should clearly label designs for MVP and GA. Developers can then implement MVP, while keeping the GA version in mind for the future.

5. Share components

Designers more than likely have some sort of style or branding guidelines to which they need to adhere. And chances are your developers have component libraries they use to make their jobs easier. You can save time up front by aligning these two resources.

Making designs that are compatible with libraries helps developers with their implementation, and it helps them maintain a consistent look and feel throughout the product.

Think outside your area

There are countless benefits to designers and developers working together. Each has knowledge that can be applied to the other's expertise. Developers can provide valuable information about what is and isn't possible in the design, while designers can get developers involved in the design process, so they gain empathy for their users.

As organizations increasingly adopt DevOps and agile practices, all teams involved in the product development pipeline are beginning to think about areas outside of their own expertise. When it comes to UX, designers and developers who have a better understanding of each other's realms will create stronger designs, see less wasted development time, and build a better user experience.

Keep learning

Read more articles about: App Dev & TestingDevOps