Development fundamentals for UX designers (2024)

In this article, I’d like to show you that by learning about technical limitations & development aspects, you’ll be able to include a valuable additional layer to your design work & to collaborate with developers more effectively.

If you are a UX designer (interaction designer, product designer, service designer, UI designer — your label doesn’t really matter), most probably you are working on digital products or services. In other words, you are creating software products.

According to my experience, this is an often overlooked fact: you, as a designer, contribute to a software development process. And without knowing what’s under the hood, you won’t be able to make informed design decisions.

Historically the design work was done by the developers of a software product. Involving designers effectively has been a great challenge. On the one hand, it’s hard to fully integrate design activities, and keep design and development in sync. On the other hand, next to the product development process aspect, you can think about this integration on a lower level: each participant of a software development process should understand what they are building. And this is one of the reasons why the infamous “Should designers learn to code?” question has been asked so many times recently.

I believe that this is not a good question. Here are some better ones:

• Should designers understand the costs, risks, trade-offs of a design decision?
• Should designers know how developers work, what challenges they face, what their main tasks are?

And the answer for these is: yes! Of course understanding the basics and the capabilities of for instance Javascript might be a plus in some cases, but it doesn’t mean that you should learn to write production ready code.

Both designers and developers have their core competencies and responsibilities. You work together, you have the same goals, you’re dedicated to the same project, you collaborate as much as possible. However, you need to respect each others knowledge and expertise.

Design should not be turned into design by committee, and designers should not give instructions to developers on how to write their code.

I believe that the most important thing is establishing a mutual trust: developers should know that you understand the risks, costs, trade-offs of a design decision, so that you won’t ask unreasonable things, and you should feel that they won’t try to avoid solving more complex problems.

So instead of learning how to code, you should

• understand development fundamentals and
• be in close collaboration with developers.

Understanding the main technical constraints, limitations and the most important development aspects is beneficial for any designers, whether you are a freelancer or an employee working at a small startup, at an agency or at a large organization.

Learning how to collaborate effectively is beneficial for designers who work in a team or with other professionals regularly. And this is how these two goals are closely related: understanding technical constraints and development aspects will help you improve the way you work together with developers.

So let’s take a closer look at these 2 areas!

As a result of understanding technical constraints and development aspects, you’ll

• be able to produce design work that can be implemented effectively,
• generate less waste in the process (or no waste at all),
• know how user needs and business goals can be translated in a way that it is technically feasible.

Here are some examples of design decisions you can’t make without knowing about development aspects:

• How to choose an appropriate third party / existing solution, reusable component (e.g. a map component or a payment solution)
• How to define logical relationships inside an app, e.g. “a user can have maximum 1 profile picture” is a rule you should define
• How to represent real world objects & concepts inside a digital app (e.g. how to define data types, what data modeling is)
• How to store data, e.g. you should tell what groups of data will be read or modified together and how often
• How to create a web application in a way that it provides good user experience even in case of a slower network connection (performance aspects)

This UX Knowledge Base Sketch lists out some more development aspects you should know about, use it as a starting point:

The second main area you should concentrate on is collaboration.

Collaboration with developers is about

• how you can involve them in your design processes,
• how you can ask better, more relevant questions from them, and
• how you can participate in their workflows (for instance during implementation.)

These are some of the main areas of collaboration:

• Doing research together (e.g. your developer team member can act as a secondary interviewer)
• Synthesizing research data & ideation: developers can bring their unique perspective
• Designing with development aspects in mind: e.g. designing for different screen sizes and devices; creating multi-state UI; better form design by specifying e.g. each user input’s data type, max. text lengths
• Prototyping: developers can help you by creating a coded prototype, and they can also add a fake back-end (mocking)
• Testing: developers can observe usability tests, take notes; after the tests you should discuss the results together (e.g. Biggest surprises? What did stand out?)
• Implementation: for instance following developers’ progress inside a version control system; writing automated tests; reporting bugs
• Prioritization: it’s an ongoing activity during the product development process, e.g. you should prioritize together during a project kick-off; bug fixes should also be prioritized
• Data-Informed Design: developers might help you add code snippets or setup an A/B test or a fake door test
• Teamwork in general: collaboration is about creating a shared understanding and coming up with solutions collectively.

You’ll find some more details about these collaborative activities in the following UX Knowledge Base Sketch:

I received a lot of comments, messages from you. Based on these, I thought that it’d be useful to add some points.

Designer — developer collaboration is a two-way street

This article is written for UX designers, this is why it explores the topic from their perspective. But of course establishing mutual trust and mutual respect is very important. As I wrote previously, designers should feel that developers won’t try to avoid building more complex stuff, and they should feel that their developer team members are transparent about their work, especially about the amount of development effort required to complete a task.

Understanding and learning about development fundamentals is not about making the developers’ life easier, it’s about making everyone’s life easier in your team (including yourself!). So it is not about “pleasing” developers.

Maybe I should write the “pair” of this article: Design / HCI fundamentals for developers :)

Both designers and developers should develop certain skills

Both designers and developers should consider adding some important competencies, characteristics, developing mindsets in order to be able to collaborate effectively. Here is a — far from complete — list of these:

• Curiosity, willing to learn about the context and the problem space
• Understanding that today’s products and services are complex systems, and that human experience is even more complex
• Accepting that your first ideas are not necessarily the best ones
• Thinking about the larger context, applying a broader perspective to the problems
• Staying humble, being ready to change opinions in the face of new evidence, information
• Being able to handle uncertainty
• Accepting that having more ideas means that you have more possible ways of solving a problem
• Understanding that assumptions should always be tested
• Challenging all the ideas, questioning everything, being flexible
• Accepting that it is impossible to answer and know everything, but at the same time thriving for understanding the people you are designing for and the problems you are attempting to solve
• And also accepting that you’ll make mistakes during the process

Understanding development fundamentals (from the designers’ perspective) or understanding design fundamentals (from the developers’ perspective) is a great foundation for collaboration. However, as you can see there is a lot of other skills to work on for both professions.

Understanding development aspects is not about limitations

I believe that Elisabeth highlighted a very important aspect here:

Always thinking about limitations is not the best approach, this is why it’s a good practice to consider how’d things work in an ideal world, but after that you should “scale down” the dreams, and take into account what is feasible in your current context.

🙏Thanks for reading my article! Please let me know what you think about this topic, here are two questions I’m especially curious about:

• According to your experience, what are the most common technical constraints / limitations you need to take into account during your work?
• Think about a case when you experienced great designer-developer collaboration — what made it great?