Table of Contents Hide
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!
Image source: Vagile
Fostering Trust and Respect
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 developers occasionally 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.
Read the full article here