Skip to main content
Web // Design systems

Design systems: so button #47 matches button #1.

Tokens, components, and documentation that let designers and developers build consistent, accessible interfaces faster, across web apps and Odoo views.

anvexisstack.com/web/ui-ux-design-systems
Foundations
Tokens · type · spacing
Components
React · OWL
Quality
WCAG checks

Tokens in code, components with tests, docs people actually open.

How we build a design system

  1. Step 01

    Audit

    Inventory existing screens and the dozen slightly different grays.

  2. Step 02

    Tokens

    Color, type, spacing, radius, and motion defined once in code.

  3. Step 03

    Components

    Accessible primitives with keyboard support and tests.

  4. Step 04

    Documentation

    Usage guidance and live examples in a style guide.

  5. Step 05

    Adoption

    Migrate high-traffic screens first and measure consistency.

Tokens, not magic numbers

tokens.csscss
:root {
  --brand-primary: #22c55e;
  --text-primary: #f8fafc;
  --text-secondary: #cbd5e1;
  --radius-card: 0.75rem;
  --space-4: 1rem;
  --ease-out-expo: cubic-bezier(0.16, 1, 0.3, 1);
}

Why a design system

As a product grows, small inconsistencies multiply: five shades of the same blue, buttons that behave differently on each screen, forms that validate in three different ways. Each one is minor; together they make a product feel unreliable and slow every team down.

A design system fixes this with shared foundations: design tokens for color, type, and spacing; a library of accessible components; and guidelines that explain when to use what. Designers and developers work from the same source, so new screens are faster to build and consistent by default.

We build design systems that are actually used: small enough to adopt, documented with real examples, and wired into the codebase so the system and the product never drift apart.

What a design system contains

LayerContents
FoundationsColor, typography, spacing, radius, shadows, and motion as tokens
ComponentsButtons, inputs, tables, dialogs, navigation, and feedback states
PatternsForms, empty states, errors, onboarding, and data-heavy views
AccessibilityContrast, focus, keyboard support, and screen-reader behavior
DocumentationUsage guidance, do's and don'ts, and live examples

How we work

UX research

Interviews and usability tests to find where users struggle before redesigning.

Design in Figma

Components and variables that map one-to-one to code.

Coded components

React components with tests, typed props, and Storybook documentation.

Accessibility built in

WCAG checks in design and automated tests in code.

Building the system

  1. Step 01

    Audit

    Week 1

    Inventory existing screens, components, and inconsistencies.

  2. Step 02

    Foundations

    Week 2

    Define tokens for color, type, spacing, and themes.

  3. Step 03

    Core components

    Week 2–5

    Build the most-used components in design and code.

  4. Step 04

    Adoption

    Week 5–7

    Migrate key screens and document usage.

  5. Step 05

    Governance

    Ongoing

    A process for proposing, reviewing, and releasing changes.

Scope at a glance

Included

  • UX audit and research
  • Tokens, components, and documentation
  • Migration of key screens

Not included

  • Brand identity and logo design
  • Rewriting every screen at once

Common pitfalls we help you avoid

The first pitfall is designing a system in isolation. Components built without real screens in mind look good in a library and fail in practice, so we design from real use cases.

The second is a system that exists only in Figma. If code doesn't use the same tokens and components, the two drift apart within weeks.

The third is trying to migrate everything at once. We start with the most-used components and high-traffic screens, so value arrives early.

What we measure

MeasureWhy it matters
Component adoptionShare of screens using system components
Accessibility issuesAutomated and manual findings over time
Design-to-build timeHow quickly new screens ship
Visual inconsistenciesOne-off styles remaining in the codebase

Who does what

We handle

  • Research, design, and component development
  • Documentation and tooling
  • Accessibility testing

Your team handles

  • Product priorities and decisions
  • Brand guidelines and approvals
  • Adopting the system in new work

A worked example

Picture a company with three internal apps built by different teams over several years. Each has its own buttons, colors, and form behavior, and users switching between them make mistakes.

A shared design system with themed tokens and a React component library gives all three a common look and behavior. New features ship faster because teams assemble screens instead of styling them from scratch.

What success looks like

Success is a product that looks and behaves consistently, accessible by default, where new screens are assembled from trusted parts instead of rebuilt each time.

Signs you need a design system

SymptomWhat it costs
Every screen looks slightly differentUsers relearn the interface on each page
Designers redraw the same componentsTime spent on repetition instead of problems
Developers style things from scratchSlower delivery and more bugs
Accessibility issues reappearLegal risk and excluded users
Rebrands take monthsChanges must be made screen by screen

Myths we hear

Myth: Design systems are only for big companies.

Reality: Small teams benefit too; a compact system of core components saves time from the first month.

Myth: A UI kit from the internet is enough.

Reality: A kit is a starting point. A design system adds your brand, your patterns, and rules for using them.

Myth: Accessibility can be added at the end.

Reality: Retrofitting is expensive. Building it into tokens and components makes every new screen accessible by default.

Before you start

  • Screenshots of current products
  • Brand guidelines, if they exist
  • The front-end framework you use

Questions to ask any provider

  • Will the design system be available in code, not just Figma?
  • How are accessibility standards verified?
  • How do new components get added later?
  • Who maintains the system after handover?

Keeping it maintainable

Components are versioned and released like any other package, with a changelog and visual regression tests. That way teams can upgrade on their own schedule and see exactly what changed before adopting a new release.

Standards a design system can stand on

Design tokens, the named values for colour, spacing, and type, are being standardized by the W3C Design Tokens Community Group, which published its first stable specification version, 2025.10, in October 2025Source [1]. Using a standard format means tokens can move between design tools and code without bespoke converters.

Accessibility belongs in the components themselves. We build to WCAG 2.2, the W3C Recommendation from December 2024, which added nine new success criteriaSource [2]. When contrast, focus, and target sizes are right in the system, every product built on it inherits them.

Frequently asked questions

Do we need a design system?
If several teams or products share an interface, yes. A single small app may only need a component library.
Can it work in Odoo?
Yes. Tokens and patterns can be applied to OWL components and QWeb templates.
Do you use Figma?
Yes, with tokens kept in sync between design files and code.
How do you handle accessibility?
Contrast checks on tokens, keyboard and screen reader support in components, and automated tests.
Can you extend our existing system?
Yes, starting with an audit of what exists.
Do you work with our existing designers?
Yes. We often pair with in-house designers, adding UX research, systems thinking, and front-end implementation.
Which tools do you use?
Figma for design, React and TypeScript for components, and Storybook for documentation, adapted to your stack.
Can a design system support dark mode and multiple brands?
Yes. Tokens make themes and brand variations a configuration change rather than a redesign.
How do you ensure accessibility?
With contrast-checked tokens, keyboard and focus behavior on every component, and automated plus manual testing.
Can you redesign just our worst screens first?
Yes. Targeted redesigns of high-impact screens are often the best way to start.
How long before we see results?
Core tokens and the most-used components usually reach real screens within the first weeks.
Can it work with an existing component library?
Yes. We can extend or theme libraries like Radix or MUI rather than starting from zero.
Do you run usability testing?
Yes, with real users on prototypes or live screens, followed by prioritized recommendations.
Can a design system improve conversion?
Consistent, accessible interfaces reduce friction. We measure the impact on key flows rather than promise a figure.
Do you document the system?
Yes, with usage guidelines, examples, and do's and don'ts in a living documentation site.
Can you audit our accessibility?
Yes. We combine automated scans with manual keyboard and screen-reader checks, and prioritize fixes by impact.
Can you train our team to use the system?
Yes. We run short sessions for designers and developers, covering components, tokens, and how to contribute.
Is there a standard format for design tokens?
Yes. The W3C Design Tokens Community Group published a stable specification, version 2025.10Source [1].
How does a design system help accessibility?
Accessible components, built to WCAG 2.2, make accessibility the default for every screen built with themSource [2].