InVision presents

Design Systems Handbook


by Marco Suarez, Jina Anne, Katie Sylor-Miller, Diana Mounter, and Roy Stanfield

A design system unites product teams around a common visual language. It reduces design debt, accelerates the design process, and builds bridges between teams working in concert to bring products to life. Learn how you can create your design system and help your team improve product quality while reducing design debt.


Go to Chapter
Introducing design systems
The power of scale

Repetition and reusability make scale possible. InVision’s Marco Suarez takes you back to the foundations of component-based design and the many ways design systems enable scaling. He also addresses a few common misconceptions about design systems.
 

Go to Chapter
Go to Chapter
Designing your design system
Step by step

Starting can be the hardest step. Design systems expert Jina Anne walks through what to consider as you start out. Involve the right people, find the right model, add the right pieces—and you’ll be well on your way to establishing a successful design system.

 
 
 
 

Go to Chapter
Go to Chapter
Building your design system
A strong foundation

Building a flexible, maintainable, stable, scalable design system creates a strong base for your product design team. Etsy’s Katie Sylor-Miller shares foundational knowledge learned building design systems across cross-functional teams.

 

Go to Chapter
Go to Chapter
Putting your design system into practice
Better together

Encouraging adoption of your design system forges connections and creates champions across teams. GitHub’s Diana Mounter lays out practical strategies for sharing design systems and growing adoption, including examples from her experience.

 
 

Go to Chapter
Go to Chapter
Expanding your design system
More than the sum of its parts

Components form the core of a design system, but teams can align around much more than components. Marco Suarez outlines how teams can round out their systems with vision statements, design principles, voice and tone guides, and more.

 

Go to Chapter
Go to Chapter
The future of design systems
To infinity and beyond

Design systems play a huge role in shaping our present, but we may only be scratching the surface. Airbnb’s Roy Stanfield explores a bold future of intelligent, adaptive, context-aware systems that could further accelerate design’s possibilities.

Go to Chapter
Go to Chapter
Appendix
More resources

Design systems continue to evolve, and every company’s system can offer something to our collective knowledge and understanding. We’ve curated a list of publicly available design systems and resources to help you continue your exploration. 

Go to Chapter
04

Putting your design system into practice

Better together


by Diana Mounter

How you develop your design system will influence how you share and encourage adoption of the system. Broadly speaking, there are 2 general approaches to developing and rolling out a new design system: incremental and large-scale redesigns.

In this chapter, we’ll walk through the 2 approaches, highlight the pros and cons of each, and discuss adoption strategies.

Tina Koyama, Ashlie Ford, and Devon Beard discuss Twitter's approach to building and rolling out their Horizon Design System.

Large-scale redesign

When a team takes this approach, it often means they spend more time designing the system before rolling it out everywhere, including doing a visual refresh or consolidation of components. This allows the team to develop a fuller system—from the primitive layer of colors and typography to components, page layouts, and interaction flows.

Some teams approach their new system by creating imaginary products to help them step away from the constraints of working within a real application. Other teams design their new system alongside the redesign of a real product or feature.

Testing with pilot projects

At Etsy, I worked with a team of designers and engineers on the redesign of seller tools. This project provided a great opportunity to test a new approach to our CSS and refresh our visual styles. We built a new style guide alongside the seller tools redesign that documented implementation and design guidelines.

This became a pilot project for testing the new design system. Rebuilding a real part of the product gave us a great playground for testing new components, responsive layouts, and new typography styles.

In From Design Systems: Pilots & Scorecards, Dan Mall writes about the criteria he uses to find good candidates for design systems pilot projects. Though our approach at Etsy was more opportunistic, many of the attributes Mall lists happened to match the seller tools project:

  1. Potential for common components. Does this pilot have many components that can be reused in other products?
  2. Potential for common patterns. Does this pilot have many patterns that can be reused in other products?
  3. High-value elements. Even if uncommon, is there a component or pattern with high business value at the heart of this project? We’re talking about elements that are integral to a flow or audience with unusually high value for the organization.
  4. Technical feasibility. How simple is a technical implementation of the design system? Is a large refactor required?
  5. Available champion. Will someone working on this product see it through and celebrate/evangelize using the design system (and even contribute to it)?
  6. Scope. Is this work accomplishable in our pilot timeframe of [3–4 weeks] (insert your timing here)?
  7. Technical independence. Is the work decoupled enough from other legacy design and code that there are clear start and end points?
  8. Marketing potential. Will this work excite others to use the design system?

There was one downside to building the new design system alongside a product—it ended up being biased to the needs of that product. Afterward, it needed further development to work for the whole Etsy application. Working in a silo with minimal outside feedback allowed us to make progress quickly, but meant that we had to work harder to encourage other teams to adopt the design system.

Showing value through a sandbox environment

While working on the new Etsy style guide, we set up a simple sandbox environment that allowed us to quickly prototype HTML/CSS mockups. As we prepared to share the new style guide with other designers, we realized the sandbox could be helpful with adoption.

One of our goals was to reduce the time designers and developers had to spend writing CSS, so they could spend more time iterating on designs. The new approach we took with CSS, combined with the sandbox environment, made prototyping designs in the browser fast and easy.

The best way for people to see value is to experience it.

We set everyone up with sandboxes for training. This approach empowered people to prototype and experiment with the style guide using the sandbox, revealing value through hands-on use.

To set people up for success, we wrote tutorials teaching them how to apply different styles—such as atomic vs. component classes, build mobile-first responsive layouts, and create complex views such as a search results page—without writing CSS. To help people understand the why behind our decisions, we included a presentation on our design principles with example scenarios, code samples, and live coding demos.

The sandbox’s CSS environment mirrored production, so a designer’s prototypes easily translated to a developer’s production work, avoiding costly and unnecessary new CSS. Since code prototypes are written in the same language, they gave developers a better sense of the intent than a static mockup. Developers didn’t have to translate like they do with comps from design tools. This further helped with adoption. A design system that both designers and developers love has a greater chance of success.

Documentation is key

Another key to adoption is up-to-date documentation. As design systems peers say, “If it’s not documented, it doesn’t exist.”

When styles go undocumented you run the risk of people writing new but duplicate code. Documentation becomes more important when introducing a new design system because old patterns can outweigh new ones. Documentation helps promote those new patterns, reduce the need to write new code, and makes implementation easy with code examples and guidelines.

Outdated documentation can cause damage too since it can lead people down the wrong path and cause frustration. It’s worth investing time in developing practices that help you keep updated documentation.

Find opportunities to check documentation accuracy—such as before and after an onboarding session, or as you add new styles. Writing docs on the fly helps you test your code and avoid building documentation debt. If you can, add tests that check documentation when patterns are added and updated, and try to make it easy for people to report inaccuracies.

At Etsy, some engineering teams created onboarding projects for new engineers. This usually involved building a small feature from the backlog that would help them get familiar with the engineering stack. I was stoked to see them implementing UI layouts without help from designers, just by following style guide documentation.

Post-rollout follow-up

Design systems are never done. The launch of your new system should be thought of as version 1.0, with many iterations will follow.

Whether you form a full-time team to evolve and maintain your system or not, you likely have a few groups of people interacting with it—makers of the system, users of the system, and users who also contribute to the system. Whatever form your team takes, makers need to stay in touch with the needs of users and the organization.

A few months after rolling out the new design system at Etsy, we ran working sessions with staff from a cross-section of teams. Our goal was to learn how to improve the experience for people using and contributing to the system, how successful we’d been with promoting the system, and where it was lacking. We took a qualitative research approach so that we could be open to discovering things we didn’t realize were problems—this meant a lot of face-to-face discussions with light agenda’s to stimulate conversation.

Contributors

We ran a user-journey mapping workshop with first-time contributors to understand their experience. We suspected people had mixed experiences—some seemed to struggle or give up on their contribution entirely, and some had taken a really long time to add their new pattern.

Findings: We discovered how deflating the experience could be even when the contribution was successful. This led us to develop a more collaborative pairing approach and take an encouraging mindset toward code review for first-time contributors.

Engineering early adopters

We met with early adopters on product teams with a particular focus on understanding the engineering perspective. Most engineers hadn’t taken part in training sessions and had learned to use the new design system by reading the style guide.

Findings: We learned a lot about out holes in our documentation. For example, tutorials didn’t lend themselves well to engineers, utilities were useful but buried, and people felt concerned about how to use styles safely in experiments. This led us to reorganize and elevate important information up-front, improve search and navigation, add tutorials that appealed more to engineers, and provide more clarity on style usage.

Product managers

We ran a session with product managers to walk through the new system and discuss the impact of refactoring and building responsive layouts as part of feature development. Building a design system that was responsive by default was a core goal—and new for many parts of the Etsy web application.

Findings: We learned that most product managers trusted their engineering managers to guide them with impact on scope—this confirmed communication with engineers was a priority. PMs understood there might be extra work initially, but moving to the new design system would make front-end implementation easier in the future. We showed them they could scope work and make progress iteratively.

Collaboration creates investment in adoption

It might not be logistically possible to involve your entire company in design systems decisions, but some level of collaboration is worthwhile.

Before Etsy formed a dedicated design systems team, a working group made of a cross-section of designers drove the evolution of the system. This group met regularly to plan and prioritize projects, share work, and get feedback. Group members collaborated with engineers and specialists where needed, in situations like running experiments on high converting pages and measuring performance.

These collaborations spread adoption even further and resulted in design system champions across the company. People who spent time contributing to the system were invested in it and promoted it to others. Working in a silo had helped us for the short term, but extending contributions to outside the team set us up for success in the long term.

Incremental rollout

Not all design systems teams are able to take the time to develop a fully-fledged system before rolling it out. Many teams have to roll out parts of a design system at a time.

On the plus side, with an incremental rollout, teams can adopt new parts of the system as they become available, which can feel less daunting and disruptive. However, teams will also need to give more thought to communication and promotion of the system. Without a launch, there isn’t a big moment to get everyone’s attention. Instead, you need to find and create occasions to introduce people to your design system.

When I joined GitHub and began exploring how the small, then-part-time team might turn Primer into a more robust design system, I knew we weren’t able to go away for a long period of time and develop a complete system. There was a ton of work in flight, and no planned re-design or siloed feature we could use as a pilot project.

We needed to figure out the biggest pain points, reduce them to their smallest part, and roll out Primer updates incrementally.

Solve problems and win early adopters

One of the biggest pain points at GitHub was the amount of time people were spending writing CSS, particularly for things that should have been systematized, such as spacing and typography styles.

Our solution ended up being the introduction of utilities (single purpose classes, often referred to as atomic or functional classes) based on system variables. We weren’t able to start with auditing components and page layouts—we had to start small and test the foundation of the system before extending to larger parts. Adding utilities enabled us to make styles available without refactoring tons of UI. Designers and developers could start to use the primitive styles of the system as soon as we rolled them out.

Once people discovered they could use utilities instead of write new CSS, Primer started to catch speed. It solved a real problem while allowing us to test the primitive layers of the system. From there, we could start to replace and update the component layer of styles.

Improve documentation and findability

Like at Etsy, documentation was key to adoption at GitHub. Tons of widely used patterns in the GitHub codebase weren’t in Primer and thus weren’t documented.

We sorted through piles of custom CSS and created a directory in the GitHub codebase that formed a “waiting room” for patterns that should be moved into Primer. We focused a lot of effort on getting as much as possible documented, whether it was in Primer or not. We also focused on adding more layers of documentation, including describing our class naming conventions, accessibility principles, recommendations for tooling to work with our system, how to run linters, and an overview of our style organization and packages.

Just having styles documented wasn’t enough, though. We needed to prioritize the style guide navigation and search for findability.

We originally modeled the navigation to match our package organization—core, product, and marketing—prioritizing that information over the findability of searching for specific styles. The style guide also lacked search and hid styles behind several layers of navigation, forcing multiple clicks before people found what they were looking for.

I found myself acting as a human style guide search, with people pinging me to find what they were looking for rather than finding it themselves.

With research outlining people’s struggles to find styles, and the fact that we were wrestling with an aging web app we originally used for the style guide, we decided it was worth the effort to rebuild and redesign.

The new documentation site listed all our styles in the navigation, and we added a contextual search that helped people find documentation with similar keywords—such as finding “color” within utilities vs. support variables.

Getting a documentation site set up early on was important. Looking back, I don’t think it was the wrong choice to repurpose an old web app at first—it may not have been ideal, but it did what we needed. It is important to re-evaluate the quality of your documentation site over time though, to ensure it meets user needs, and is scaling with your design system as it grows.

Grow adoption through many touchpoints

When you don’t have that big moment to launch your design system, use every opportunity to share its value. You’re building systems to solve real problems and you know what your goals are—take some time to share those goals and how you plan to reach them. These details are helpful when you’re trying to show how changing something like a few lines of CSS matters.

At GitHub, we used lots of small interactions to promote Primer and the design systems team. Here are a few ways we made our piecemeal approach successful:

Creative comments in code review

We started to jump in and comment on pull requests in the GitHub app that touched CSS or design patterns we were trying to improve. This gave us an opportunity to suggest changes in line with the new design system, and point people to our documentation site so they knew it existed.

We spread the word about our team and our availability to help by adding simple comments to pull requests, such as, “Ping the design systems team,” or, “Find us in the design systems slack channel.”

Over time, people started to CC us on issues and pull requests, and we took advantage of features like Code Owners so we got automatically requested for review when someone made CSS changes.

Recently, we’ve started adding bot scripts that comment on pull requests with simple feedback. With lots of points of communication about our team and Primer, we’re growing awareness and adoption of design systems.

Show, don’t tell

We noticed when teams updated the GitHub UI, they would go to another part of the website and literally copy and paste the markup and CSS. Refactoring away old instances of patterns is our best fight against the continued reuse of old patterns. It is a long-term initiative, but we can prioritize the most popular and troublesome patterns.

Respond quickly to support requests

Most teams at GitHub have an on-call duty rotation called First Responder. It means one or more team members are on call to triage issues, respond to support requests, or provide code review.

As support requests grew for design systems, we adopted this process to help respond to people in a timely manner. Over time, we’ve iterated on the process and created a number of automated scripts that help track notification items that need attention. Responding to people quickly increases the likelihood that they react positively to our team and recommendations.

Presence and responsiveness  

Particularly early on, we made the simple effort to be available via Slack to answer questions, pair on code, or jump on a call to walk through something. It takes time away from deeper work, but allocating time to this is worth it to help win friends and champions on other teams.

Publishing and distribution at scale

Most of my recent experience working on design systems has been on large-scale web applications like Etsy and GitHub. The scale to which those systems need to be distributed and published usually requires more complex infrastructure than a small company with a small system and small team.

However, many companies intend to grow the size of their team and scale of their product over time, so understanding how to set your design system up for scalability will benefit you in the future.

Let’s walk through methods of style organization, distribution, and public vs. private documentation and code, to help you consider what’s right for you and your team.

Package management and organizing modules

Design systems should be built for change, large or small. This isn’t just important for how you code your system or use things like variables or design tokens—it’s important for how you organize modules, and version, and distribute them too.

At GitHub, we iterated on how we organize and package styles multiple times. Like Etsy, we pulled our design system out of the GitHub monorepo into its own repo. We wanted to have more control over the changes made and when those changes made it back into GitHub.com.

We also use Primer for more websites and applications beyond GitHub.com. Conference websites like git-merge.com are built with Primer, as well as community websites such as developer.GitHub.com and opensourcefriday.com.

Not all these sites need the full suite of styles we use for GitHub.com, and GitHub.com doesn’t use all the marketing-oriented styles in the core application. This led to taking a modular approach with style organization and influenced how we packaged and distributed Primer.

Versioning the entire system vs. versioning by module

Versioning the entire system means everything within the system belongs to just one version number and can only be installed in its entirety. This could be likened to browser or software versions. When you update to a new version of Google Chrome or your phone’s OS, for instance, you’re updating the whole piece of software in one go.

If you were to version your design system in the same way, it would mean everything within the design system would be updated too.

For example, you may have updated your font styles, added a new navigation component, or deprecated an old grid layout. When a user of your design system chooses to upgrade, they get all of those changes together. This still gives teams the flexibility of when to update the system, but a more granular approach can be helpful as your system scales.

Versioning individual modules means having a version number for every component or group of styles within the design system. So if you put your button component into one module and your utility styles into another, they would each have their own version number, such as primer-buttons@2.4.0 and primer-utilities@2.8.0.

You can still maintain a package that includes the entire set of the modules and version that too. For example, primer-css@9.5.0 includes primer-buttons, primer-utilities, and all the other Primer modules. So you can provide the best of both worlds—the option to use the entire system, or just use individual modules.

This modular versioning approach does require more effort for initial setup because you need to work out what to boil each module down to. For instance, should you have a module for layout utilities as well as a grid system, or combine them all into one layout module?

The benefit of this approach is that users of your design system can choose to upgrade just the bits they need. Giving teams the option to selectively update when they have the time to do it can mean they’re more likely to iteratively keep up to date—whereas the overhead of updating the entire system in one go can act as a barrier.

Versioning by package enables a design systems team to push updates more frequently without the pressure of forcing an update to the entire system.

Compared with versioning the entire system in one go, versioning by module creates more flexibility around major design systems releases, can lead to a culture of continuous development, and enable your systems team to move faster overall.

Releases, branches, and version numbers

Design system teams often have to balance competing priorities. Attending to bug fixes or other commitments has to be balanced with intensive projects requiring more research and planning, such as developing a new color system or bringing in a newly supported feature like a CSS grid.

Your publishing workflow needs to work for both the users and the maintainers of the design system. Maintainers want to have confidence in what they test and ship. Users of the system want to have clarity on status and what type of updates they’re getting.

At GitHub, we found the combination of versioning and organizing releases with Git branches gave us the right amount of flexibility in planning and shipping new design system releases.

We maintain a “dev” branch that includes work in progress and creates a new branch for each individual release. Since Git allows us to create multiple branches of the design systems code, we can work on a minor or patch release at the same time as a major release. This means we can take our time with a major release that might include breaking changes, while also shipping timely updates and bug fixes in minor and patch releases.

Versioning our system and using Semver makes this workflow possible. We can clearly point to a specific version number for each release, and know by the Semver system what type of updates are included with it, and therefore what type of testing we need to do.

Since Semver is a well-recognized standard for versioning, it helps clearly communicate to users of Primer—internally at GitHub or externally—what updates they’re getting and what type of testing they may need to do in order to use the updates.

Public vs. private

As your system and its number of users grow, you might find yourself considering whether to make your design system public to some degree. There isn’t a one-size-fits-all solution to this—it should be based on what’s right for your team. Making a system public doesn’t have to be an all-or-nothing approach, there are multiple ways of breaking down what’s public.

Many pioneering teams have created and published beautifully designed documentation, such as Material Design, Lightning Design System, and Shopify’s Polaris. We shouldn’t assume the solution that worked for these companies is right for everyone else. These are companies making a significant investment in design systems. Plus, they have the broader objective of wanting external developers to use these systems to build on their platform.

When deciding what, if anything, is made public, you should prioritize based on your company’s needs, rather than standards set by other companies.

Here are a few ways you can make your design system public:

Public documentation only

You might decide that making the source code public isn’t right for your team, but you want to make the documentation public.

Marvel’s style guide and Mailchimp’s patterns are examples of public documentation sites that don’t (yet) share their source code.

Open-source design systems

Many companies open-source their design system. This means the general public can open issues to request new features, give feedback, or let the maintainers know of bugs. Maintainers can also choose to accept contributions in the form of code or documentation changes via pull requests. If the maintainers choose, they can make the design system available for modification and reuse by adding a license.

The US Web Standards, Primer, Help Scout, and Solid are all examples of design systems open-sourced on Github.com.

Open-source the docs with your code on GitHub

You don’t necessarily have to share a crafted documentation website—you can just share documentation written in markdown format and it will be rendered and styled on GitHub. Another option is to publish the docs via GitHub pages. This can be a low-barrier way to share documentation since GitHub hosts the documentation, giving you a default public URL if you don’t add a custom domain.

Share a ZIP file to download

If you want to keep the source-code and/or the npm packages private, you could choose to share the code for your design system so it can be used by others. This might be a nice option if you don’t want to make in-progress work on your system public, or add the overhead of managing open-source contributions, but are still happy to share the code for use by others.

Projects like Lab by Compositor (a design tool for creating React components for design systems) use the Releases feature on GitHub to share release notes and a ZIP file download of the software. They also use the repo to host documentation and issues to get feedback from users.

Publish a Storybook of your UI components

Storybook has become a popular tool for design systems teams, especially for those using React, though it can also be used with Sass or CSS-based design systems too. As Brad Frost describes, Storybook is a “workshop” tool designed to output rendered examples of your styles and components, which you can use in development for testing changes. Style guide documentation is your “storefront” and includes crafted and detailed documentation with information like usage guidelines and code-style principles.

Providing rendered examples of your components, even without detailed documentation, is still very useful to users, maintainers, and would-be contributors of your design system. It provides a catalog of what’s included in your design system.

Pattern Lab (created by Brad Frost), Fractal, and React styleguidist are other tools that provide similar features to Storybook with options for documentation and code examples. All these tools can be used without sharing your design system’s source code, and give you options as to what level of documentation you share.

As you consider varying degrees of access to your system, also consider some of the reasons teams make their systems public:

No authentication barriers to sharing

Anything behind authentication, like outside VPNs or firewalls, means one more barrier to access. I know this firsthand since we have a new, in-progress documentation site for Primer that requires staff login. People frequently think the style guide had been taken down or don’t even know it exists.

Authentication also makes it difficult to give external contractors access. It’s a small barrier, but it can have a negative impact and mean people who could be using your design system documentation can’t or won’t because it’s too much hassle.

Helps with recruiting through previewing design maturity

Design systems are a popular topic in the design and front-end community right now and might be part of a prospect’s decision to choose one company over another.

Design systems can be a sign of maturity for a team, and also provide insight into what it might be like to work at that company. Especially if you’re trying to recruit directly for your design systems team, making the documentation public is an obvious way to attract people and set expectations.

Opens you up for input from the community

Making your documentation and/or your source-code public opens you up to external contributions, whether via simple feedback comments or direct contributions to code. This risks overhead, particularly if your system becomes popular, but the benefit is that you get feedback and insights from a wider range of people.

Primer is open-sourced on GitHub. We’ve been increasingly working in the open and sharing issues and pull requests so people can see how we work. We’ve noticed a gradual increase in contributions from the community and internal GitHub contributors. People generally feel proud to contribute to an open-source project that can benefit anyone.

Conclusion

There’s a lot that goes into the rollout of your design system, and much of it will extend naturally from how you decide to build your system, who you’re working with, and the best way to spread adoption inside your company.

Creating a perfect rollout strategy is less important than ensuring you’re involving the right people, being clear about your end goals and how your strategy supports those, and documenting your plan methodically through each step.

Design systems are always evolving, and the way you share and encourage adoption of new iterations will evolve along the way as well. An intentional, thoughtful strategy with room to scale will go a long way to making sure adoption is treated as a crucial part of the building process.

05

Expanding your design system

More than the sum of its parts


by Marco Suarez and Sophie Tahran

As mentioned in Chapter 1, early software programming was limited by the speed and capability of hardware. But over time, hardware became increasingly faster and cheaper, and the inefficiency of software became even more noticeable.

As product teams are expected to move faster and faster, speed and efficiency is an ever-growing concern. However, design systems enable teams to find speed, efficiency, and consistency through reusability. As you experience these benefits, other areas of inefficiency that were once unnoticeable become glaring.

Alignment is often one of those areas. Aligning team members, teams, and a company around things like direction, expectations, and quality is critical to moving and scaling quickly. Without alignment, friction increases and velocity slows—something product teams cannot afford.

A design system is a fantastic way to create alignment around interface design and implementation. But beyond components, teams can build alignment with vision, design principles, process, and voice and tone.

Vision

A vision statement moves everyone toward a common destination. Vision is your North Star. It’s a reusable statement that gives context to your work to help your team stay on track and in sync. A vision statement declares what your team, product, or company is attempting to achieve and why it’s worth achieving. It’s comprehensive yet memorable, elevating yet attainable.

Vision creates clarity, making non-essentials easier to identify. Momentum is far easier to build once everyone knows where they’re going and why.

A few years ago, the Starbucks product team was reorganizing and needed to clarify—for themselves and the entire company—their reason for existing. In a corporation as large as Starbucks, it’s vital to clearly and succinctly express the purpose and value of your team.

“We create digital products that make our customers happy and our partners proud.” This statement became their rallying cry. The vision grounded decision-making to improve the experience for customers and partners (baristas, managers, office employees) as well as achieve business goals.

Informal vision statements for discrete projects also became useful. “Clarity first, then elegance if possible,” was the guiding principle of a recent redesign.

Nick Grossman of Union Square Ventures gives several examples of how a North Star impacts company alignment in his talk, “Purpose, Mission & Strategy.” One example he gives is about Foursquare’s product focus moving from the consumer app to the direction of being a location data platform that could power other applications. This was a massive shift in direction. It was the vision “making cities more delightful” that provided a much-needed North Star for employees to accept and embrace this new model. Grossman says, “It was a watershed moment for aligning the company around a new direction.”

It’s helpful to assess your progress as a team. At Etsy, we held retrospectives after every major launch. A retro is a meeting to celebrate the things that went well and identify the things that didn’t for a particular launch. It’s also an opportune time to check your alignment with your vision.

Design principles

Designers often operate with their own implicit set of standards to evaluate the quality of their work. But when teams grow, explicit standards become necessary to unify all with a shared language and a guide to evaluating the work. How do you define good design? How do you know what’s essential and what’s arbitrary? How do you know when something is ready to ship? How do you know if you’re on the path to achieving your vision?

A system of principles can provide the answers. Design principles act as a reusable standard for designers to measure their work. They replace subjective ideals with a shared understanding of what design must do for users. Just as guardrails keep you safe and on the road, design principles keep teams on the path to achieving their vision.

Posting your principles on the office walls, creating a computer desktop wallpaper, adding them to your design systems site, or printing them on notebooks are all great ways to keep them top of mind. Task your most senior designers with using them in every design critique to ensure the new language is adopted. This new system of language will become a vital part of your design system because it creates alignment, enabling your design team to scale.

While designing InVision Studio, the design team realized far too much time was spent debating solutions. So a set of principles was drafted to help navigate the complexity of designing software. These principles were used to guide individual decision-making, help reach agreements faster as a team, and acted as a transcendent standard to create harmony and cohesion throughout the product. The principles were modified over time as Studio evolved and needs changed, but these principles aligned the team and helped them keep the velocity they needed.

Process

Providing a clearly defined process for how user experience problems are approached and solved builds alignment within product teams. This consistency helps to remove friction and build velocity.

Process guide designers through a series of clearly defined milestones, each with different objectives and deliverables. These milestones act as interdependent components that, when used together, improve the probability of arriving at optimal solutions.

A repeatable process offers several key benefits:

  1. It provides clear expectations within each step, allowing you to focus solely on the tasks at hand without worrying about what to do next
  2. It builds data within each step that can be referenced and used to inform future iterations or course-correct low performing launches
  3. It creates an understanding of the roles and responsibilities of each team member involved—bringing the right people in at the right times, making everyone’s involvement beneficial to the quality of the output

A repeatable process will ensure progress is smooth, efficient, and predictable while also improving the quality and consistency of your work.

At InVision, our process has 6 steps:

  1. Understand: First, we use customer research and insights to gain a deep understanding of the problem space and identify how it aligns with our business goals. Product management leads this phase and works with the research team to conduct interviews, gather data, and perform competitive research.
  2. Explore: The design team then ideates and explores possible solutions. They work with product and research teams to produce wireframes, core flows, and user journeys.
  3. Define: Once a potential solution has been identified, the product team works to align everyone on what success looks like. The output of this work is a problem statement and defining measurements of success.
  4. Design: Refining the solution is design team’s responsibility. They work with the research, product, and engineering teams to develop core flows, prototypes, and identify tech requirements.
  5. Build: Engineering translates the design and prototypes into reality. The product team orchestrates quality assurance, support documentation, and the sales and marketing teams.
  6. Learn: At this point, we observe the effectiveness of our launched solution. The product team collaborates with the research, design, and engineering teams to gather insights to measure against our success metrics. We use these insights to inform our next steps and start the process over again.

Voice and tone

Sophie Tahran, InVision’s UX Writer, weighs in on the value of writing guidelines—and how to create them.

Great writing is an essential part of great design, but even in-house UX writers aren’t able to edit every single word in a product. That’s where writing guidelines come into play. A source of truth promotes good communication, credibility, and consistency—no matter who’s writing content.

Every writing guide should cover both voice and tone. While your voice generally stays the same (like a personality), your tone shifts according to the situation (like an attitude). Both are an essential part of communication—and you can’t ship a product without effectively communicating it.

Because voice identifies who we are and defines our relationships, building writing guidelines early on is one of the best ways to gain credibility with your users. They’ll begin to recognize you, and know that they can trust you.

Writing guidelines also help evolve your voice. Just as your personality matures over time, your voice will evolve as your company grows. Guidelines define what you should sound like right now, so when you do steer away from them, you’ll know that you’re doing so intentionally. (“I’ll just throw an emoji in this subject line,” turns into, “Hey, let’s test how emoji perform and see if they’re worth adding to our writing guidelines.”)

Without thoughtful writing guidelines, teams risk allowing their voice to be determined by patterns instead of users’ needs, and end up making decisions solely based on what they’ve done in the past.

Building writing guidelines

Start with an audit. Talk to people across (and outside) the company: designers, writers, support agents, co-founders, users, etc. Your goal is to get their impression of the company’s personality. Consider not only conducting interviews, but also creating mood boards—visual collections of colors, people, places, and more—to represent more emotional, intangible qualities.

Define the findings. Have a core group of people, normally writers, narrow down the best words to describe what you found. Is your voice human, real, and bold? Or is it kind, experienced, and empowering? Take into consideration not only how you sound now, but also what you aspire to be and avoid (“InVision is never clickbait-y or pandering”).

Tone can be more difficult to hammer down. It shifts according to the situation, so it’s sometimes more helpful to provide direction than it is to identify characteristics. State your key priorities, like, “Always provide clarity,” and, “Consider the user’s emotional and mental state.” This is also a good place to determine whether humor has a place in your writing, and where you fall on the formality spectrum.

Once you’ve identified the more nebulous aspects of your voice and tone, carry that same thinking into the tangible. What should your different channels look like? Do you use sentence case or title case?

You may find that you have a need for multiple guidelines—voice and tone within your design system, a company-wide style guide focusing on words only, and brand guidelines that also encompass visual design.

Get buy-in. Potentially more important than building voice and tone guidelines is encouraging everyone to follow them. Anyone who works with content should have a chance to sign off.

Find a home. Your guidelines need to be easily found and integrated. If you’re building voice and tone into your design system, follow Mailchimp and Shopify’s lead in giving writing its own section, separate from components, principles, and layers. You can also go one step further by creating a separate list of copy patterns (like Mailchimp did) for grab-and-go words.

Develop. Writing guidelines are living, breathing documents that require maintenance as your company grows. From the start, use an editable Paper or Google Doc—and better yet, schedule monthly check-ins.

Invest time in writing guidelines from the start. Most companies have more people representing their voice than you’d expect, from product designers to support agents. By having a source of truth—and creating it together—you can offer users a better experience.

Conclusion

Just as design is far more than the sum of its parts, your design system can serve as far more than a components-only guide. Vision, principles, process, and voice and tone expand your design system into additional areas where reusability can also increase speed and efficiency.

Design systems have changed the way we design and build applications—so much so that we must look at the future of design through the lens of systems. In a future where design systems gain wide adoption, design could take on many new, exciting forms.

About the Authors

Marco Suarez
Product Designer, InVision
Katie Sylor-Miller
Staff Software Engineer, Etsy
Roy Stanfield
Design Lead, Airbnb
Diana Mounter
Design Systems Manager, GitHub
Jina Anne
Design Systems Pioneer, Independent
Design Systems Handbook
Design Systems Handbook

Design better. Faster. Together.

Transform your products with the world's leading digital product design platform

GET STARTED NOW