Home Categories The top ten Development agencies Consulting agencies Governance & DesignOps Guide Contact

The buyer's guide

How to hire a design system studio

Systems rarely fail during the build. They fail in the eighteen months afterwards, and most of what determines that is decided before you sign.

01

The internal groundwork

Name the owner before you name a budget

Not a committee, not a rotating responsibility, not “the design team.” One person with authority to approve components, reject off-system work, and allocated time to do it.

If you cannot name that person, you are not ready to buy a system. Buy an audit instead, or an embedded engagement where the studio stays, or scope something small enough that maintaining it is not a job. A system with no owner degrades into a stale library people route around, and you will have paid for the privilege.

Settle whether engineering is in scope

This single decision explains most of the price variation you are about to see in proposals.

A design library means your engineers build and maintain the code side. That is real work, needs planning, and needs someone to keep it in step with the design files. A coded system costs more and removes that dependency.

Deciding this after you have collected proposals produces the worst outcome, because you end up comparing quotes for two different jobs.

Get design and engineering agreeing before the studio arrives

Systems sit across both functions, and engagements go badly when the two sides have different expectations arriving in.

Agree in advance: what framework the components will target, whether an existing internal library is being replaced or wrapped, who reviews contributions, and where the system will live. If design wants Figma-first and engineering has already standardised on something, resolve it internally rather than paying a studio to mediate.

Audit what already exists

Almost nobody starts from nothing. There is usually a partial library, some inconsistent patterns, and at least one abandoned attempt.

Inventory it before briefing. What exists, what is used, what is quietly dead. This shortens discovery and stops you paying a studio to find out what your own team already knows.

02

Building the shortlist

Three, not ten

Every studio you add costs you time and costs them unpaid effort. Narrow lists produce serious proposals.

Match the studio type to the situation

Engineering-first studios, product studios with a systems service line, enterprise and DesignOps specialists, and full-practice studios price and behave differently.

Shortlist within one type. If you compare an engineering-first quote including a versioned package against a design-library quote, the gap will look like a discount and is actually a different scope.

Check whether they have maintained, not just built

The most useful filter available. Ask each candidate for a system they built more than two years ago and what state it is in now.

Studios that have stayed involved will tell you specifics. Studios that only launch will change the subject to a newer project. Both are legitimate businesses, and only one has watched what happens after the excitement fades.

Ask about the last system that failed

Everyone experienced has one. A candid answer about a system that stalled, and what they now do differently, tells you more than six polished case studies.

03

Evaluating properly

Ask to see the unglamorous artefacts

Request a contribution guide, release notes, a migration guide for a breaking change, and the governance model from a real engagement.

Studios that have run systems in production have all of these and will be pleased to be asked. Studios that have built libraries will offer more component screenshots.

Test the adoption story

Ask how they get product teams to actually use the system. Listen for whether the answer is about tooling or about people.

The technically correct answer involves easy contribution paths, fast turnaround on requests, and the system solving problems teams already have. Answers that rely on a mandate from leadership indicate a studio that has not had to win adoption on its own merits.

Ask what they will leave your team able to do

The difference between a delivered system and a capable team is enormous, and only the second one survives.

Ask what enablement is included: pairing, documentation for maintainers, training sessions, a period of supported contribution. Studios that treat handover as an afterthought leave you dependent on them or stranded.

Establish who is assigned

Named people, their role, what share of their time you get, and whether the engagement includes engineering as well as design. Ask what happens if that person leaves mid-build.

Do not ask for free component work

Speculative components reward studios willing to guess before understanding your constraints. Ask for relevant systems, a proposed process, a named team, and a point of view on your specific situation. If you need to see thinking applied to your product, pay for an audit phase.

04

Reading the proposal

Find the boundary

Where does the studio's responsibility stop. Audit only, foundations and components, full system with governance, or system plus a maintenance period. Proposals are frequently vague here and the vagueness always costs the client.

Check for what is routinely excluded

Commonly scoped separately and commonly assumed included: accessibility implementation in components, documentation site build, token pipeline and tooling setup, migration of existing products onto the system, training and enablement, and any maintenance after delivery.

That last one is the most expensive assumption in this category.

Understand the component count

Proposals often quote a number of components. Establish what counts as one, whether variants and states are included, and what happens when you need more.

A button with six variants, five states, and three sizes is not one component in effort terms, and the ambiguity here is a reliable source of mid-project friction.

Treat the timeline as conditional

Systems timelines assume your engineers are available for consultation, your stakeholders review promptly, and nobody changes the brand halfway through. Add contingency for your own side.

05

Contract points worth attention

  • Ownership of the system and its source. Design files, component code, documentation, and token definitions all transfer on payment. Confirm explicitly, since systems have more moving parts than a typical design deliverable.
  • Tooling dependencies. Establish what the system depends on and whether any of it is proprietary to the studio. Inheriting a system built on internal tooling only they use is a genuine problem.
  • Distribution and repository access. Where the package is published, who controls the registry, and whether you have repository access from day one rather than at handover.
  • Licensing inside components. Icon sets, fonts, and any third-party libraries embedded in components carry their own terms. Some are free at small scale and chargeable beyond it. Get the list.
  • Maintenance terms, if any. If the studio is staying on, specify what is included: response times, release cadence, how new component requests are handled and priced.
  • Enablement deliverables. If training and documentation for maintainers matter to you, name them as deliverables rather than assuming they arrive.

06

After delivery

  • Adoption is a campaign, not an announcement. Product teams need a reason to migrate. Pick one team, migrate them properly, and use the result to persuade the others. Mandating adoption without a contribution path reliably fails.
  • Make requesting a component fast. The moment teams believe asking is slower than building their own, the system becomes optional and drift begins.
  • Version deliberately from the start. Semantic versioning, deprecation notices, and migration guidance matter as soon as more than one product consumes the system. Retrofitting a release process onto an adopted system is painful.
  • Budget for the second year. Systems need continuous small investment rather than a one-off build. A modest ongoing allocation prevents the far larger cost of rebuilding an abandoned system in three years.
  • Measure adoption, publicly. Percentage of screens on system components, count of one-off components in the codebase, time to build a new page. Share the numbers. Visible progress sustains the internal support that keeps the system funded.

07

Common expensive mistakes

  • Commissioning a system with no named internal owner, then watching it drift out of step with production within a year.
  • Buying a design library when nobody has capacity to build the code side, creating two sources of truth that disagree by month three.
  • Scoping components and skipping governance, then discovering the system has no mechanism for handling the requests that immediately arrive.
  • Building for one product and later discovering three more need to consume it, requiring the token layer to be rebuilt for theming.
  • Treating delivery as completion, so nothing is budgeted for maintenance and the system quietly becomes the thing teams work around.

Ten design system studios, profiled in full, with an honest note on who each one suits.

Read the profiles
About this site