If you’re working in a position that performs any kind of UX design function within a large-enterprise environment, it’s likely you’ve found that some of the most important relationships you need to cultivate are with your software-development colleagues. After all, developers implement your UX design vision, developing running code that your valued users can use. These developers ultimately keep your company in business. That’s some serious power at their fingertips.
But we continually hear about the challenges of establishing effective designer–developer collaborations. The Internet is full of such articles, indicating a persistent gap. However, UX designers have written most of those articles rather than developers. Why is this? What do developers think about this? What insights could they provide that we, as UX designers, could take back to our teams?
To help shed light on this issue from the developer’s perspective, I’ve turned to Crystin Stoll, an experienced Senior Software Engineer and Front-end Developer at Rockwell. During my multidecade career in software development, Crystin is one of the most UX-minded, collaborative, well-respected technical professionals with whom I’ve had the privilege of working. She has graciously offered to provide her software developer’s perspectives on the following issues:
committing to standardization
orienting toward the greater good
fostering trust and respect
I’ll let Crystin take it from here. The remainder of this article is in her words.
As a software developer, I strive to keep things simple and must often ward off attempts to introduce complexity. Finding a simple solution that produces only a few optimized lines of code (LOC) is often more difficult than going with a quick-and-dirty solution. However, the up-front cost of making this extra effort and striving for elegance can take you a long way. As complexity increases, the overall cost of the product increases, taking its toll on users in the form of time and resources, as well as stress and frustration. Complex code requires nontrivial maintenance, bug fixes, and increases learning time. Understanding complex code can take a lot of time—and brings out the impostor syndrome in every developer—but is necessary for anyone to handle the code effectively. Otherwise, guess what? You’ll end up with more bugs. The earlier you prevent or find such bugs, the more money you’ll save your company.
In “The Cost of Poor Software Quality in the US: A 2020 Report,” Herb Krasner, a renowned software-engineering expert and lecturer, states, “Large systems have much higher defect potentials that are more difficult to remove than for small systems due to size and complexity. The earlier in the development lifecycle defects are found, the more economical the overall delivery will be.”
Ensuring the simplicity of a software user interface (UI) is the responsibility of both its developers and designers. Its success depends on developers and designers working closely together early during the design phase. Working together provides a system of checks and balances. Just as an engineer can overengineer, a designer can overdesign. Both parties should hold each other accountable for keeping the software simple and providing a great user experience. Of course, a complicated design directly impacts code complexity. If a design is hard to code, the implementation of that design is often hard to use—and buggy.
Collaborating during the design phase and placing an emphasis on simplicity, can improve the user experience, reduce the cost of complexity, and create an overall better product and user experience. It’s always best to avoid the throw-it-over-the-wall approach to software development. Both designers and developers should actively participate in creating early UX-design iterations. I refer to these early meetings as negotiations. The number of meetings that are necessary decreases naturally as your team norms. Plus, gaining experience is a contributing factor to the frequency that is necessary for teams to be effective. A great user experience requires not only a good UX design but a well-thought-out implementation that employs the right data structures and algorithms so an application can perform with speed and efficiency for users.
The more discussions you have with your counterparts in design and development, the more you’ll learn about how you can positively impact the product together. Discuss different approaches, usability, complexity costs, technical feasibility, and keep your users’ best interests at the forefront of all decisions. Keep your design and code simple because every bell and whistle costs money to design, develop, maintain, and fix.
Committing to Standardization
In my opinion, as a software developer who works in a fast-paced agile environment and focuses on adding features to the product, the ideal UX design process is one in which designers arrange reusable components in page layouts and focus on the product’s overall usability and flow. Keep each design as simple as possible, keeping effort, scale, and usability top of mind. Sometimes a problem we are trying to solve is complex and requires specialized components—for example, a grid to display a table of data. To enhance the user experience of a data-dense table, the grid might incorporate many features such as a filter control, hover effects, ToolTips, and behaviors that truncate text and add an ellipsis whenever the text overflows a table cell. Each of these features helps remedy users’ common annoyances and improves their overall experience. However, each one also adds to the code’s complexity, which developers should always minimize.
Using a component library delivers the best of both worlds: the product developers won’t subsequently have to carry the burden of complexity, and the components are rich with features that designers and test teams have already vetted.
Unless UX designers are specifically designing a UI component library, they should avoid creating custom components. Although a custom component might help solve a specific problem, customizations unfortunately introduce inconsistencies between UI elements—perhaps even to a very simple button that has zero complexity. These sorts of inconsistencies pile up as technical debt, and they ultimately cost money. If multiple designers are creating custom components, there is no single source of truth—each could be recreating the wheel and each wheel would be different. You can manage inconsistencies in design by defining and adhering to a style guide, but it still takes a great deal of effort to check that everything is consistent and gets implemented correctly. Again, a component library encapsulates all of that. Using a library not only speeds up development, it also speeds up designers.
Orienting Toward the Greater Good
It is important to care about what your team is building. We all want to create something great for our customers and users. In a large company, there may be many stakeholders and layers of management—all of whom have a vested interest in the product. Scope and requirements might change, or there could be a mandate for a new feature coming all the way from the top of the organization. Do not let a high-level mandate cloud your better judgment. Avoid a just-following-orders mentality. The designers and developers are closest to the actual implementation of the product and know when something is kludgey or an idea is not feasible. Just because something can be done, it does not mean that it should be done.
Of course, it is important to do your work in a way that meets requirements, but it is also important to look out for the greater good of the product and its users. As a UX designer, you are an expert in your field. So, if something isn’t right, communicate that in the hope of driving change for the better. You won’t always be successful, and sometimes you must just grit your teeth and design something as it’s specified—but you can at least maintain your integrity by speaking up. If something feels off to you, it likely feels off to other people, too.
Our chances of success increase if we all work together and focus on creating a great product. The better we work together, the better the product. Although there might be some mandates from above that clash with your goal of making the product better, more often, there will be friction between the designers and developers themselves. Therefore, communication is key. For the product’s sake—and ultimately, for the sake of the product’s users—designers and developers need to get through the storm phase as fast as possible and start to norm. This is not easy, and the amount of effort it requires depends on each individual’s experience, social style, and work style. Having everyone learn a bit about team development and work styles would benefit the entire team’s performance. When the going gets tough, just keep going and talk through the issues—and you are on the way to norming!
Communication requires more than establishing a cadence. It requires purpose and an understanding of impacts. Having mutual respect for one another’s role can make each meeting more effective and expedite the norming process. Once designers and developers can agree that building the best product possible for users is their focus, both sides will be on the same page and able to trust that those in each role have given thought and care to doing excellent work. This trust in each other fosters an environment in which criticism and pushback is usually constructive—and is always for the greater good.
As a developer, when I am implementing a design, basic UX knowledge and best practices help me to extrapolate the designer’s intent when an image is not enough to convey the minutia of every use case. Over time, having worked with several designers, I have learned from them that User Experience is about so much more than aesthetics. It is both an art and a science. The more I know, the more I respect the research, thought, and process of design. Conversely, the more designers know about the implementation of a user interface and how design complexity can impact the software-development lifecycle, the more they can optimize and simplify their designs.
The importance of fostering close designer–developer collaboration will only increase as enterprise software evolves to become more service and cloud oriented, resulting in more frequent iterations and higher expectations from users and customers. If you’re a UX designer in an enterprise environment, you probably already know that it’s important to foster good relationships with your development colleagues. However, you might not always be aware of the rationales and expertise that your development colleagues can impart—unless you continually solicit their feedback and participation in your design process.
Prioritize simplicity. Complex designs lead to complex code—and you’ll ultimately pass that complexity on to the people who use the product you’ve worked so hard to bring to production. Commit to standardization. The efficiencies you can gain by using common component libraries and style guides benefit everyone: designers, developers, and most importantly, the users of the final product. Both designers and developersoccasionally suffer from impostor syndrome, but your contributions to the success of your product are no less valuable when you champion reuse.
Constantly orient and reorient toward the greater good. It’s all too easy to fall into the feature-creep hole—especially if organizational leaders, whose mandates are difficult to dispute, have dug that hole. We all must choose our battles, but when you challenge decisions that would ultimately undermine the quality and usability of the product you and your development colleagues have together worked so hard to forge, you set a positive precedent and can be an example to others. Foster trust and respect by demonstrating the same empathy for your development colleagues that you do for the users of your product. This expedites the norming process and pushes the team toward more efficiently performing processes, ultimately leading to better outcomes.
User Experience Team Manager at Rockwell Automation
Cleveland, Ohio, USA
Jon has a degree in Visual Communication Design from the University of Dayton, as well as experience in Web development, interaction design, user interface design, user research, and copywriting. He spent eight years at Progressive Insurance, where his design and development skills helped shape the #1 insurance Web site in the country, progressive.com. Jon’s passion for user experience fueled his desire to make it his full-time profession. In 2013, Jon joined Rockwell Automation, where he designs software products for some of the most challenging environments in the world. In 2020, Jon became User Experience Team Lead at Rockwell, where he balanced design work with managing a cross-functional team of UX professionals. In 2021, he became a full-time User Experience Manager. Read More
Over the last eight years, Crystin’s passion for technology has propelled her through three teams at Rockwell Automation, groups that have focused on projects ranging from low-level hardware programming, mid-level edge analytics, and high-level, customer-facing cloud solutions. She believes that all levels of software have a user, and every user should have a great experience. Read More