Book a call

WritingFundamentalsPart 3 of 3 in Planning the system

Why design systems fail: ten failure modes and their antidotes

Design systems rarely fail because of their buttons. The same ten organisational problems come up in audit after audit. What each looks like, its antidote, and the warning signs that appear months before a system is quietly abandoned.

On this pageAn agreement, not a library
  1. An agreement, not a library
  2. Ten ways design systems fail, and the antidote
  3. The two that cause the most damage
  4. Early warning signs
  5. A quick self-check
  6. The short version
  7. Frequently asked questions
  8. Further reading

The short answer

Design systems rarely fail because of the quality of their buttons. They fail for organisational reasons, and the same ten come up again and again: built by design and ignored by engineering; treated as a project and abandoned after launch; started with the fun components; components before tokens; a system team that became a bottleneck; components that grew forty settings; Figma and code that drifted apart; updates that broke products without warning; nobody could find anything; and success measured by usage instead of value. Each has a well-tested antidote.

  • A design system is an agreement, not a library. Most failures are broken agreements, not broken components.
  • The two most common causes are the first two: no engineering commitment, and no team after launch.
  • Early warning signs show up months before failure. Watch for them.

An agreement, not a library

A design system is a shared set of decisions, reusable parts and working agreements. The components and tokens are how the agreement is written down; the people, processes and rhythms are how it stays alive. When we audit systems that are struggling, the components are usually fine. What's missing is the agreement: who owns it, who builds with it, how changes happen safely, and how anyone knows whether it's working.

Ten ways design systems fail, and the antidote

#How it failsWhat it looks likeThe antidote
1Built by design, ignored by engineeringA beautiful Figma library; products still built with custom codeEngineering commitment before you start; engineers on the team from day one
2Treated as a project, then abandonedA launch, a party, then no owner; the library slowly goes staleRun it as a product, with a team that stays after launch
3Started with the fun componentsA carousel and a data visualisation kit; no consistent buttonStart with an audit and the everyday basics
4Components before tokensEvery component hard-codes colours; dark mode means a rewriteTokens first, components second
5The system team became a bottleneckA long queue; teams build their own while they waitContribution levels, local components and the rule of two
6Components grew forty settingsEvery request became a prop; nobody can change anything safelyScope statements, composition, and "build it locally"
7Figma and code drifted apartDesigns use options that don't exist in codeSame names and props; monthly twin checks; one definition of done
8Updates broke products without warningTeams pin old versions and stop updatingVersioning that counts visual changes; release notes; notice periods
9Nobody could find anything"Tag", "Tag v2", "Chip" and "Pill/Status" side by sideA tidy library, clear names, one documentation template
10Success measured by usage, not value"80% adoption" and no idea whether anything got fasterA baseline first; report time saved and change made cheap
The ten failure modes we see most often in audits. Practitioner view

The two that cause the most damage

1 · No engineering commitment

A design system that exists only in Figma isn't a system; it's a style guide with better organisation. If engineering leadership hasn't agreed to build and use coded components, designers will hand over screens using the library and engineers will rebuild them by hand, differently each time. The minimum effective team is a designer and an engineer, and the engineering commitment needs to be in writing before any components are built. See design system team structure.

2 · A project instead of a product

Projects end; products are run. A system launched by a temporary team, then left to "the community", goes stale within a year: bugs wait, requests pile up, and teams quietly fork. Fund a permanent team, however small, with the rhythms of a product: support, releases, a roadmap and health checks.

An illustration: the launch nobody remembered

The situation

A design system launches with an all-hands presentation and a link to the documentation. The project team moves on to other work.

What goes wrong

Six months later, half the designers hired since launch have never heard of it. Engineers who hit a setup problem gave up. Adoption is stuck at a third of the product.

What works instead

A permanent owner, onboarding for every new joiner, office hours and champions. Teaching never stops, because hiring never stops.

Early warning signs

Failure is slow. These signals usually appear six to twelve months before a system is quietly abandoned:

  • Detach rates rising in Figma, or components being copied in code instead of imported.
  • Old versions lingering: products several major versions behind and not planning to update.
  • The request queue only grows, and the median wait passes a month.
  • Questions repeat in the support channel because the docs don't answer them.
  • Office hours empty out, or are cancelled "for now".
  • Local versions multiply: a second date picker, a third dropdown.
  • Leadership stops asking about the system in reviews.

Each of these is fixable when caught early. Put the first four on a one-page monthly dashboard; see design system metrics.

A quick self-check

QuestionIf the answer is no…
Is there a named owner with protected time?Failure mode 2. Name one this month.
Is at least one engineer building system components?Failure mode 1. Get the commitment before more design work.
Do components use only tokens?Failure mode 4. Add a lint rule and fix the worst offenders.
Can a team get a small request answered within a week?Failure mode 5. Add contribution and local components.
Do visual changes come with release notes and a version bump?Failure mode 8. Adopt versioning rules.
Did you measure anything before you started?Failure mode 10. Take a baseline now; it's still useful.
In practice

At CARS24, one front door for requests, a 70-point scorecard any team could apply and three ownership tiers kept the system team from becoming a bottleneck. Read the case study.

The short version

  • Systems fail for organisational reasons, not component quality.
  • Get engineering commitment and a permanent team before anything else.
  • Tokens first, basics first, composition over forty settings.
  • Keep Figma and code in step, and never break products without warning.
  • Measure value from a baseline, and watch the early warning signs.

Frequently asked questions

Why do design systems fail?

Most often because engineering never committed to them, or because they were run as a one-off project with no team after launch. Other common causes are starting with the wrong components, skipping tokens, bottlenecks, drift between Figma and code, and breaking updates.

How do you know a design system is failing?

Rising detach rates, products stuck on old versions, a growing request queue, repeated questions, empty office hours and a growing number of local versions of the same components.

Can a failing design system be rescued?

Usually. Start with an audit, name an owner, get engineering commitment, fix the most visible drift and restart the rhythms. Rescues often succeed faster than first attempts because the problems are known.

Is low adoption a sign of failure?

Not on its own. Adoption grows with enablement and time. The bigger warning is teams actively working around the system, by detaching, copying or building their own.

Further reading