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 fails | What it looks like | The antidote |
|---|---|---|---|
| 1 | Built by design, ignored by engineering | A beautiful Figma library; products still built with custom code | Engineering commitment before you start; engineers on the team from day one |
| 2 | Treated as a project, then abandoned | A launch, a party, then no owner; the library slowly goes stale | Run it as a product, with a team that stays after launch |
| 3 | Started with the fun components | A carousel and a data visualisation kit; no consistent button | Start with an audit and the everyday basics |
| 4 | Components before tokens | Every component hard-codes colours; dark mode means a rewrite | Tokens first, components second |
| 5 | The system team became a bottleneck | A long queue; teams build their own while they wait | Contribution levels, local components and the rule of two |
| 6 | Components grew forty settings | Every request became a prop; nobody can change anything safely | Scope statements, composition, and "build it locally" |
| 7 | Figma and code drifted apart | Designs use options that don't exist in code | Same names and props; monthly twin checks; one definition of done |
| 8 | Updates broke products without warning | Teams pin old versions and stop updating | Versioning that counts visual changes; release notes; notice periods |
| 9 | Nobody could find anything | "Tag", "Tag v2", "Chip" and "Pill/Status" side by side | A tidy library, clear names, one documentation template |
| 10 | Success measured by usage, not value | "80% adoption" and no idea whether anything got faster | A baseline first; report time saved and change made cheap |
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
A design system launches with an all-hands presentation and a link to the documentation. The project team moves on to other work.
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.
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
| Question | If 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. |
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
- A design system isn't a project. It's a product, serving products.Nathan Curtis.
- How to run a design system auditThe usual first step in a rescue.
- A first-year design system roadmapA plan that avoids most of the ten.
