Design System Governance – Scale Your Design
Some team members despise design system governance. They see it as a roadblock to rapid growth, creativity, and flexibility. However, design system governance can foster scalability and creativity if properly implemented while maintaining design and usability consistency.
Good design system governance prioritizes users before growth and profits. Company culture also plays a significant role in how a company implements a governance process that team members follow and embrace.
The tools UX and engineering teams also have an impact on design system governance. UX teams must update design tools to match changes to the final product, exposing the process to human error!
With UXPin Merge, teams don’t need to worry about updating two different design systems. UXPin Merge syncs our editor tool with code components from your Git repo or Storybook integration (allowing you to connect with React, Revue, Angular, Ember, and many more), eliminating the need for separate design systems and mitigating human error.
See how UXPin can enhance your design system governance!
What is Design System Governance?
Design system governance is the process and protocols for maintaining and updating a product’s design system.
Even minor changes, like changing an app’s close icon from an X to a — must go through a multi-step approval and implementation process.
Design system governance fulfills several purposes:
- Maintain’s design and brand consistency
- Prevents poor design decisions—leading to usability issues
- Encourages team members to think creatively and try to solve problems with the tools on hand before attempting to make changes
- Ensures updates consider accessibility
- Keeps the entire organization informed of changes
- Updates digital product and design documentation
Without effective design system governance, editing and updating new components is a free-for-all that could create usability issues, inconsistencies and ruin the product’s reputation.
The Challenges of Maintaining a Design System
There are many challenges to maintaining a design system. Every organization must have a dedicated individual or team to manage its design system.
Here are six common challenges to maintaining a design system and why an effective governance model is essential!
Company Political Forces
Sadly, even successful design systems aren’t safe from power struggles within an organization. Team members might call on executive power to either push or block design changes, overriding the initial decision of a design system team.
Conversely, governance keeps executives and other stakeholders well informed on design changes and the reasoning, making it easier to get buy-in and approval.
Managing Input From Multiple Teams and Departments
A design system is not only for UX and engineering teams. Product teams and other stakeholders share ownership of the organization’s design system.
Managing all of this input can be challenging without a proper system of governance.
Design Systems are Often an Afterthought or Side Project
In many organizations, especially fledgling startups, the product’s design system isn’t a priority. It’s a side project a UX designer maintains in their spare time or over the weekend—feebly trying to maintain consistency with the demand for growth!
In this environment, a design system is prone to abuse and poor design decisions. Often UX teams have to undo changes to fix usability issues due to poor governance.
Without proper communication between departments, teams, and individuals, a design system falls apart. For example, two teams might unknowingly work on the same task separately, or worse, crucial usability changes go forgotten because everyone thought “someone else was working on it.”
Design system governance fosters organization-wide communication, so everyone is updated and informed!
Reluctance from Team Members
When teams are reluctant to adopt the product’s design system, they choose the parts they like and develop a “better way” to design the rest. New team members or those not involved in creating the design system believe they can do better—thus undermining the hard work of others.
This reluctance can not only affect the product’s usability and consistency but create unnecessary conflict.
A governance model with multiple checks and balances prevents team members from hijacking a design system.
Reluctance to Change
Sometimes the opposite is true. Design system managers believe the system is fine the way it is, blocking any changes. A design system is never complete. It’s a work in progress that must evolve for the organization to grow.
The Single Source of Truth Dilemma
Many companies struggle with the single source of truth dilemma—working with a single dataset between all departments, primarily UX design, product, and engineering.
The UX team works with design tools, engineers with code, and the product team (often with limited technical know-how) uses all sorts of tools, including powerpoints, PDFs, and paper, to name a few.
With this scattered workflow, maintaining a single source of truth is challenging. Often requiring additional staff and resources to ensure everyone is up-to-date. Even with good systems of governance, the single source of truth dilemma is a constant challenge.
Global payment giant PayPal solved its single source of truth dilemma with UXPin Merge. PayPal uses UXPin Merge to build and maintain its design system for internal user interfaces with code components from a Git repository.
When developers implement new changes, UXPin’s design editor’s components update simultaneously, so designers and engineers always work with the same design system.
Establishing Design System Governance Standards
There are four primary scenarios where a design system requires changes or updates. These scenarios require a submission process where teams must ask a series of questions and tests before prototyping or requesting amendments.
- Introducing new elements – Establishing a workflow for adding new elements ensures design system integrity while providing every team member with an equal opportunity to make additions.
- Promoting patterns – Patterns fall into two categories: one-off or best new practice. Teams must test these new patterns against what’s currently available before promoting them.
- Reviewing and adapting patterns – Every design system must have a team (at least two members) to review patterns before release. This review process ensures new elements meet the standards and practices of the current design system.
- Releasing design system updates – Rather than releasing new updates when they’re ready, teams must establish a release schedule for updates. A strict release schedule ensures teams follow quality assurance and documentation processes correctly.
An effective way to manage this submission process is through a simple decision tree that maps every step a change must follow.
This excellent example from Inayaili de León shows how Canonical’s team adds new patterns to their design system following a simple decision tree—from concept to release.
Inayaili admits that, like their design system, the decision tree is a work-in-progress that they update and refine as the product evolves.
A Step-by-Step Governance Model Example
There are many ways to approach design system governance, but here is a 10-step process inspired by design system guru Brad Frost:
- Use what’s available – Product teams must exhaust every effort to find a solution using the current component library. This means a design system must be well documented and accessible to everyone. If the current design system does not fulfill the new requirement, teams can proceed to step two.
- Contact design system (DS) team – Product teams contact the DS team to discuss the problem and the proposed changes. Again, the DS team and product team will work together to find an existing solution. With intimate knowledge of the design system, the DS team might uncover something the product team missed. If there is still no solution, teams proceed to step three.
- Determine if the change is one-off or part of the design system – The product team and DS team decide whether the amendment is a one-off (snowflake) or part of the design system. One-off changes usually fall on the product team, while the DS team handles design system changes. Either way, teams must prioritize and schedule the changes.
- Initial Prototyping – Teams prototype and test product changes.
- Initial Review Process – The DS team and product team review the results from prototyping and testing. If both teams are satisfied, they proceed to the next step. If they determine the changes are lacking, teams return to prototyping and testing.
- UX & Dev Testing – Once designs pass the initial review, they go to UX and development teams for further testing to ensure the changes meet user experience and technical requirements.
- Final review – The product team and DS team meet again to review the results of UX and dev testing. If both teams are satisfied, they proceed to the next step. If not, they iterate.
- Documentation and schedule release – Teams document the new changes, update the changelog (e.g., Github), and schedule the release.
- Changes released – Changes are released, product version bump according to versioning guidelines, all teams notified (Slack, Asana, Trello, Github, etc.).
- Quality assurance – Product teams review the final changes for quality assurance.
You can see how this 10-step process will mitigate all of the six common design system challenges we outlined earlier. With multiple checks and balances, a design system maintains its integrity while communicating changes to the entire organization.
While this process solves many design system challenges, checks and balances don’t eliminate human error. Teams need a tool to provide a single source of truth!
Improving Design System Governance with UXPin
UXPin Merge bridges the gap between design and code, creating a single source of truth, so designers and engineers always work with the same tools.
Popular vector-based design tools don’t solve the problem. Designers and engineers must update and sync identical systems separately—an ineffective workflow prone to error.
UXPin is a code-based design editor syncing code components via Git or Storybook to allow product teams, UX designers, and developers to work with the same components—no need to update systems separately!
Lastly, because prototypes are code-based, product updates and design system changes are significantly quicker to engineer.
Ready to switch to the only design tool that fosters good design system governance? Discover UXPin Merge to get the most of your design system and keep all the design and code components up to date.