Marcus Andrey Study
Ler em português Library

Design Systems · Step 6 · 6 min read

Bringing teams onto the system

A design system nobody uses is a very well-organised Figma file. How teams actually move onto a system: treating it as a product with users, a pilot before a mandate, migration screen by screen, the help that makes the right thing easy, and what to do when a team says no.

Teams don't adopt a design system. They adopt a faster way to ship the thing they were already going to ship. Launch emails, mandates and posters don't move people. What moves them is the first time Harbour saves them a day, on their own screen, with someone from the system team next to them. Adoption is earned one team at a time, and the system team's job is to make the right thing the easy thing.

What you'll be able to do after reading:

  • Treat product teams as the users of the system, with needs to research
  • Plan a pilot that earns trust and shows what's missing
  • Migrate a product screen by screen, without a big-bang rewrite
  • Respond to a team that doesn't want the system, without forcing it

1. The system is a product, and teams are its users

Brad Frost quotes Nathan Curtis's line that a design system is "a living, funded product with a roadmap & backlog, serving an ecosystem", and adds: "A system isn't a project with an end" (Brad Frost, Atomic Design, chapter 5). If the system is a product, its users are the designers and developers on the product teams, and everything you learned about users applies:

  • Interview them before you pitch. What slows them down? What do they rebuild every sprint? (See Short user interviews.)
  • Watch them use it. Sit with a designer while they build a screen with the library. Where they hesitate is where the docs or the component are wrong.
  • Know their deadlines. A team two weeks from launch won't migrate anything, however good the system is.

2. Five steps onto the system

  1. Hear about it

    A 15-minute demo at each team's planning: their own screen, rebuilt with Harbour.

    Signal: the team asks for access

  2. Try it

    Starter file in Figma and a starter app in code, with the library already enabled.

    Signal: first file or branch using Harbour

  3. Pilot

    One team, one real flow: the console check-in. Someone from the system team sits with them for two sprints.

    Signal: the flow ships on Harbour

  4. Migrate

    A plan per product, screen by screen, starting where the next feature lands. Migration guide and office hours.

    Signal: new screens start on Harbour by default

  5. Contribute

    The team proposes a pattern back: the Sailing card's delay status came from the console team.

    Signal: contributions from outside the system team

How Tidewater's teams move onto Harbour, in five steps. Each step says what the system team does, and the signal that the team is ready for the next one. Nobody jumps from hearing to migrating: the pilot is where the system earns trust, and where it finds out what it's missing.

At Tidewater, the staff console team goes first, because their screens are dense, repetitive and full of tables, where shared components pay off fastest. The booking app comes after, when Harbour has been tested on real work.

The step that does the most is the pilot: one team, one real flow, with someone from the system team embedded for a couple of sprints. Three things come out of it: a flow that shipped on Harbour (proof for other teams), a list of what Harbour was missing (the next roadmap, see A roadmap for the system), and a team that knows the system well enough to help the next one.


3. Make the right thing the easy thing

People take the path of least effort. So make Harbour that path:

  • On by default. In Figma, admins can set default libraries for a team or organisation, which "automatically enables them in every file" (Figma, Guide to libraries). In code, the starter app ships with @tidewater/harbour installed.
  • Starter kits: a Figma file with Harbour's page templates and a code template, so a new screen starts on the system.
  • Real code in Dev Mode through Code Connect, so the developer copies Harbour's Button instead of writing a new one (Code Connect and the design-code bridge).
  • Office hours: a fixed hour a week where anyone can bring a screen. Cheaper than a training course, and you learn what's confusing.
  • One channel for questions, answered within a day. Every question is a doc page you haven't written (Component docs people use).

4. Migrate screen by screen

Rewrites stall. Harbour's rule for an existing product is new work first, then the screens that change anyway:

  1. New screens start on Harbour, always.
  2. Screens a feature already touches move to Harbour as part of that feature, budgeted in the estimate.
  3. The rest move in small batches, starting with the most-used screens, when the team has room.

Give each migration a short guide: which old component maps to which Harbour component, what changes visually, and the gotchas. Measure one migration and publish the number ("the check-in screen took two days"), so other teams can plan.


5. When a team says no

A team that doesn't want the system is giving you research. Ask why, and listen for which of these it is:

  • "It doesn't have what we need." Then the system is missing something. Either add it, or let them build it locally and propose it back (Contribution models).
  • "It's slower than our own components." Find out where. Usually it's a missing variant, a confusing API or slow answers.
  • "We have no time." True, often. Agree the screen where they'll start, on a date they choose.
  • "Our product is different." Sometimes it is. A system that allows a documented exception is stronger than one that pretends there are none.

Mandates from leadership help with priority, not with belief. A team forced onto a system they don't trust will detach every component they can. That shows up in the numbers in Measuring adoption.


6. Common mistakes

  • Launching to everyone at once, with a big announcement and no support.
  • Skipping the pilot, so the first team to use Harbour finds all its gaps in production.
  • Planning a full rewrite instead of migrating where work is already happening.
  • Treating teams that don't adopt as the problem, not as feedback.
  • Training sessions with no follow-up, and no one to ask the week after.
  • Measuring adoption by the number of teams that "signed up".

7. Vocabulary

Term Meaning
Adoption Teams actually using the system in what they ship
Pilot One team using the system on one real flow, with close support
Migration Moving existing screens from old components to the system
Starter kit A ready file or app with the system already set up
Office hours A regular, open slot where anyone can bring questions or screens
Default library A Figma library switched on automatically for a team or organisation

8. Try it (no tools needed)

  1. Pick one team that doesn't use your system, or would be the first to use a new one.
  2. Write the one screen or flow where the system would save them the most time.
  3. Write what you'd need to give them for a two-sprint pilot on that flow: people, files, answers.

Reflection questions: What would that team say if you asked them why they don't use the system today? Which of the four "no" answers would it be?


9. If you already practise

  • Run a short interview round with your system's users every quarter.
  • Turn on default libraries for every team, and ship the package in every starter app.
  • Publish the time each migration took, and the list of gaps each pilot found.
  • Keep a list of documented exceptions, and review it: some of them are the system's next components.

Checklist

Learn more

Books, courses and videos to go deeper

Book links go to Amazon. As an Amazon Associate I earn from qualifying purchases, at no extra cost to you.

Measuring adoption · Contribution models · A roadmap for the system · Short user interviews · Who does what on a product team · Design system adoption playbook

Saved only on this device.

↑ ↓ to move · Enter to open · Esc to close