This guide is for heads of product, design leads and engineering managers whose design system exists but is not used consistently in code. It sits under Netbase's software product engineering work and complements our UI/UX design service, which builds design systems in code.
In this guide
- Why do engineers bypass a design system?
- Where does adoption stall on the adoption ladder?
- Which metrics show whether engineers use the design system?
- How strict should enforcement be?
- A phased rollout for engineering teams
- Where AI fits
- What delivery record exists, and what does not?
- Alternatives: other ways to get consistency
- Limits of this guide
- Frequently asked questions
- Next step
Why do engineers bypass a design system?
Engineers rarely bypass a design system out of taste. They bypass it because a deadline is closer than the answer to "which component do I use?", because the component lacks a state the ticket needs, or because the system lives in a design file while the product lives in code.
Four causes explain most bypasses:
- The system is not in their stack. A design file and a style guide are not a component an engineer can import. If the team writes React and the system ships as pictures, every screen is rebuilt by hand.
- A needed variant is missing. The button exists, but not the loading, disabled and destructive states. The engineer copies the button and adds the state locally, and the copy never returns to the system.
- Changes break things without warning. A component update that changes spacing or an API without notice teaches teams to pin old versions or to avoid the package.
- Nobody answers quickly. When a question waits days for a reply, the engineer decides alone and ships a one-off.
Each cause has a different fix. Documentation alone fixes none of them, which is why "write better docs" so often fails as an adoption plan.
Where does adoption stall on the adoption ladder?
Adoption is not one switch. Teams climb four rungs, and each rung has its own blocker and its own tactic. Find the rung where most teams sit, then work on that blocker only.
-
Aware
- What the engineer does
- Knows the system exists
- Typical blocker
- Cannot find the right component or token
- Tactic that moves them up
- One search-friendly catalogue with live code examples
-
Trial
- What the engineer does
- Uses a few components on a new screen
- Typical blocker
- Missing states and variants
- Tactic that moves them up
- Fill gaps fast; publish a request path with a named owner
-
Default
- What the engineer does
- Starts every screen from the system
- Typical blocker
- Old screens still use copies; upgrades hurt
- Tactic that moves them up
- Codemods and a deprecation policy with versioned releases
-
Contributor
- What the engineer does
- Adds or improves components
- Typical blocker
- Review is slow or unclear
- Tactic that moves them up
- A contribution guide, review rota and credit in release notes
A team stuck at "aware" needs discovery, not rules. A team stuck at "default" needs migration help, not more components. Enforcement belongs only at the top rungs, once the system can cover the screens the team ships.
Which metrics show whether engineers use the design system?
Use three layers of metrics. Coverage shows how much of the product is built from the system, friction shows why engineers leave it, and outcome shows whether release work got easier. One layer alone misleads.
Coverage, from code. Count what the code uses instead of asking teams. A static scanner such as react-scanner analyses a codebase and extracts which React components are rendered and with which props, so you can trend system components against local ones per repository. A production measure is another option: the engineering team at Mews describes an adoption metric that marks every DOM element created by a design-system component and reports their share of all elements on the page. Add a token measure: the share of colour, spacing and type values that use tokens rather than hard-coded values.
Friction, from the engineer's side. Track open component requests and the time to a first answer, the number of local copies of system components, version lag (teams on an old major release) and lint suppressions. Rising suppressions mean a rule blocks real work.
Outcome, from release work. Track visual defects found in design QA, the effort to ship a cross-product change such as a new brand colour, and the number of screens that needed a one-off component. These are the numbers leadership cares about.
-
Coverage
- Metric
- Share of components or DOM elements from the system
- What it misses
- A one-off can be correct when no component fits
-
Coverage
- Metric
- Token usage rate
- What it misses
- Says nothing about component behaviour
-
Friction
- Metric
- Request response time, local copies, version lag
- What it misses
- Shows pain, not its cost
-
Outcome
- Metric
- Design QA defects, effort of a cross-product change
- What it misses
- Needs a baseline before the rollout
Do not set a single adoption target for every team. A data-heavy admin area legitimately needs more custom components than a sign-up flow.
How strict should enforcement be?
Enforcement should follow coverage. Rules that block work before the system can cover the screen create suppressions and resentment, not adoption.
| Criterion | Guidance only | Lint warning | CI block |
|---|---|---|---|
| When it fits | The system covers few screens; most teams are at "aware" or "trial" | Core components and tokens are stable; most teams are at "default" | Tokens and core components are complete and versioned |
| Typical tool | Catalogue, office hours, pairing | A rule such as stylelint-declaration-strict-value, which requires variables or functions for named CSS properties | The same rules set to error in the pipeline, plus visual tests |
| Risk | Drift continues unseen | Warnings ignored if they are noisy | Blocked releases and copied components to dodge the rule |
| Escape hatch | Not needed | Suppression with a comment | Documented exception reviewed by the system owner |
Start with guidance, add warnings for hard-coded colours and spacing once tokens are stable, and block in CI only for rules the system can always satisfy. Do not enforce when the system has no owner who can answer requests quickly; enforcement then pushes engineers to work around the system instead of through it.
A phased rollout for engineering teams
-
Measure the baseline
Run a scanner on every front-end repository and record component coverage, token usage and the list of local copies.
-
Ship the system in the stack
Publish components as a versioned package in the product's framework, with every state a ticket needs and a Storybook visual test baseline for each story.
-
Name an owner and a request path
One owner answers component requests and reviews contributions on a fixed rota.
-
Migrate the most-copied components first
Replace the top local copies with system components, using codemods where the API allows.
-
Publish a deprecation policy
Follow Semantic Versioning: mark deprecations in a minor release with documentation, and remove them only in a later major release.
-
Turn on lint warnings
Warn on hard-coded colour, spacing and type once tokens follow a shared format such as the Design Tokens Community Group format.
-
Review metrics and enforce selectively
Compare the three metric layers with the baseline, then promote only the low-noise rules to CI errors.
Where AI fits
AI tools can shorten the dull parts of adoption: grouping scanner output into likely duplicates of system components, drafting codemods that swap a local copy for the system version, and suggesting the token for a hard-coded value. An engineer reviews every suggested change and runs the visual tests before merging. Netbase works with the major commercial and open-source AI tools and models, chosen per project, under human control.
- In delivered work
Recommendation engine
A recommendation engine delivered for 4over4's online printing store; it is not a design-system tool.
- Available capability
Code-migration assistants
Duplicate-component grouping, codemod drafts and token suggestions reviewed by engineers; not yet tied to a published case.
What delivery record exists, and what does not?
Netbase JSC was founded in 2012 and has served 500+ clients. It designs, builds and runs software across technologies and industries. Its delivery teams combine business analysts, project managers, solution architects, developers, QA and UI/UX designers, so the people who design a component also see it built and tested.
Netbase's delivery lifecycle includes modular and productized components, and in custom development the client owns the IP created for it, including component code. One registered record shows interface work on a live product: for a large-format printing company, Netbase redeveloped the website's UX, UI and most of the system in several phases.
Netbase does not publish an adoption percentage, a before-and-after figure or a named design-system engagement. This guide explains a method; it is not a case study.
Alternatives: other ways to get consistency
A design system is not the only route to a consistent interface. Choose by team size and how many products share the interface.
- A shared UI kit without governance. Fits one small team on one product. It breaks when a second team arrives and copies drift.
- An adopted open-source component library. Fits teams that accept its look and limits; customising it heavily recreates the cost of your own system.
- A full design system with an owner. Fits several teams or products sharing one interface language; it needs a funded owner, or it decays.
To check that system components work for real users, see usability testing without a research team. If you are still choosing a design partner rather than rolling out a system, our guide to UI/UX design agencies lists questions to ask, including who owns the design system. For reusable components on content-heavy public platforms, see interactive Earth-observation storytelling. If the product itself is not yet scoped, start with product discovery and roadmapping.
Most Netbase projects are delivered on fixed-price contracts; milestone-based and monthly team retainer models are also offered.
Limits of this guide
- It describes a method for products that already have a design system; building one is a separate decision.
- Metric thresholds depend on the product; no benchmark percentage is given.
- Tools are named as examples of a technique, not as recommendations over alternatives.
Plan the next step with a Netbase consultant
Frequently asked questions
Only after it covers the screens your teams ship and has an owner who answers requests quickly. Before that, a mandate produces suppressed lint rules and copied components. Start with guidance, then warnings, and block in CI only for rules the system can always satisfy.
Scan the code. A static scanner counts system components against local ones per repository, a production script can measure the share of rendered elements that come from the system, and a lint report shows hard-coded values. Track the trend per team, not a single company-wide percentage.
Treat it as data. Find the missing states, slow answers or breaking changes behind the complaint, fix the most frequent one first and publish the fix. Adoption follows when the system is the faster path.
Next step
If your design system exists but your teams still ship one-off components, send us your repositories' situation and your release plan and we will reply with a rollout proposal.
Related services and solutions
AI-enabled software product engineering from discovery to operation Netbase provides software product engineering for companies that need a web, SaaS, mobile or custom platform built and kept running, with AI features and AI-assisted engineering where they pay off. We cover the full lifecycle, from discovery to operation, and the same team stays accountable for architecture, delivery and handover, so nothing important gets lost between phases.
Learn More
Product discovery that validates AI features and ends in a release roadmap Netbase provides product discovery workshops for founders and product leaders to turn a product idea into validated scope, architecture options and a release roadmap. We test the problem with real users, prototype the riskiest flows, check whether planned AI features have the data and accuracy they need, and agree what the first release must prove before committing a build budget.
Learn More
UI/UX design services: research, interfaces and design systems built in code Netbase designs the interfaces of web apps, SaaS products, mobile apps and online stores: user research, flows, wireframes, clickable prototypes and visual design, plus a design system shared by designers and developers. Because UI/UX designers sit inside the delivery team, the same people who design a screen see it built, tested and released.
Learn More
Digital product accelerators for SaaS, mobile and AI products Digital product accelerators are Netbase-built modules and delivery patterns that help founders and product teams launch SaaS, mobile and AI products faster. Instead of rebuilding accounts, billing, workflows and integrations from scratch, you reuse proven components, spend engineering time on what makes your product different, including the AI features buyers now expect, and own the custom code built for you.
Learn More
Work with Netbase remotely
Every Netbase engagement is delivered remotely, so clients in any country and any industry can work with us; Netbase has worked with clients in 80 countries. Contracts and invoices are issued by Netbase JSC, and payment is made by bank transfer to Netbase JSC's company account or PayPal Business. Talk to the CEO, Huy Nguyen (David), on WhatsApp or by email.
Discuss a project
Netbase JSC helps organizations design, build, modernize, and operate digital products and AI-enabled business systems.project@netbasejsc.com
+84 937 869 689
91 Nguyen Chi Thanh, Dong Da, Hanoi, Vietnam
Get in touch
Tell us what you want to build, modernize, or operate.