Case study · Government technology · Public-service design system
One system for every stack government runs on.
I built the design system a government technology company's public-service software runs on: design tokens, a React library, framework-agnostic web components, and the AI and Figma tooling that keeps code on-system. Then it got put to work. The company is redacted here. Unlock to see the real names, links and screenshots.

- Design Systems
- Design Tokens
- W3C DTCG
- Web Components (Lit)
- React
- Vue
- ASP.NET Core
- MCP / AI tooling
- Figma plugin
- Storybook
- Nx monorepo
- WCAG 2.2 AA
The problem you’re reading about
The client builds the software counties and courts use every day. Clerks record deeds at a recording desk. Attorneys and court staff work criminal cases. Residents search for unclaimed property or report a short-term rental.
That product line has piled up over a long time, so the frontends are spread across several technologies: React, Vue, Angular, server-rendered .NET and Razor, and older WinForms systems. A component built in React did nothing for a Vue, Angular or .NET team. Every stack paid for its own button, its own form fields and its own bugs.
Accessibility was left to each team. For government software it is a legal requirement (ADA, Section 508, WCAG 2.2 AA), and handling it team by team was, in the team's own words, slow, inconsistent, and invisible until an audit surfaces it. Design and code drifted apart the same way: hard-coded hex values, spacing chosen by eye, and Figma frames nobody could check against the build.
The company was also in the middle of a rebrand. Values named for how they look, like purple-600, do not survive a rebrand or a dark mode. Engineers were already writing UI with Cursor and Claude, and without context the models produced generic markup instead of the company's components and tokens. And starting a new product took a week of wiring: private packages, stylesheet import order, the theme provider, dark mode. Prototypes lived as files in people's Downloads folders.
Each of those problems comes from the team's own roadmap, architecture decision records and documentation. The rest of this page is how the system answers them.
Approach
Keep design decisions separate from framework code. Tokens and component CSS are plain CSS that any stack can load. React and web components are two thin, idiomatic ways to deliver the same design. Around them sits tooling that keeps code and design aligned, and that gives AI assistants the real system to build from.
Then prove the claim. One Figma design, built three times, each the way that stack is normally written. And let someone else build on the packages, because the best test of a design system is a teammate shipping on it without me in the room.
“Public service software must work for everyone.” That line is from the company's design handbook, accessibility standard, and it is why accessibility lives inside the components rather than in a checklist each team is asked to follow.
What I rejected
- A React-only library with wrappers for everyone else. Wrappers would have kept every other stack a second-class consumer.
- Values named for how they look. A rebrand and a dark mode both showed why the only layer allowed in design or code is the semantic one.
- Fighting the AI tools. Engineers were already using them, so the system had to be legible to them instead.
Build
8 phases. Each one is a discrete deliverable that ships before the next starts — token foundation first, then the system makes everything above it possible.
- 01
A layered system: tokens up, tooling around it
Eight packages in one Nx monorepo, published as @client/ds-*. Foundations at the bottom: tokens plus component CSS, utilities, a grid and fonts. Components above them: a React library, Lit web components and an icon set. Tooling around the edge: an MCP server, the Figma Toolkit plugin, validators and the Figma parity tools. Consumers on top: the product apps on React, Vue, Angular and .NET, plus the knowledge base and the Design System Starter a teammate built.
Evidence · Nx monorepo with a Storybook for each library, Chromatic visual regression, Jest and Storybook interaction tests, Playwright for the web components, and automated releases with changelogs.

A platform, not a library. Tokens feed two runtimes, the build emits a manifest, and the AI layer reads both. - 02
Tokens in three layers
A raw value (#6640c2) is wrapped by a primitive (--primitive-purple-600), which is aliased by a semantic token (--color-primary-600). Only the semantic layer is allowed in design or code. That is why the rebrand and dark mode were cheap: the brand and theme change in one place, and every product follows. The tokens follow the W3C DTCG format.
Evidence · Three layers, raw to primitive to semantic. Semantic color tokens tuned for 4.5:1 contrast in both themes. Dark mode is [data-mode="dark"] rules in the foundations package, not a second design.

The token language: color roles, spacing, type, radius, weights, borders and elevation, from one source, in light and dark. Withheld: the knowledge base carries the company's brand.
Design tokens, documented. The teammate's knowledge base explains the three-layer model in language designers use. Withheld: the knowledge base carries the company's brand.
Color foundations, built on the semantic ramps from the foundations package. - 03
Two component runtimes, accessibility inside
The React library (@client/ds-react) is the most mature and the closest to Figma: typed compound components styled with CSS Modules against the foundations. The Lit web components (@client/ds-wc) are the same design for every other stack, used as <ds-*> elements with standardized ds-* custom events. Every interactive component in both has visible focus-visible rings, finishes actions on pointer-up, uses 32% opacity for disabled states and ships the contrast-tuned semantic colors, so a team gets accessibility just by using the system.
Evidence · 38 components tracked: 29 in React, 18 as web components, 17 shipping on all three platforms, with server-rendering support recorded for each one. Web components are the default for Vue, Angular and older stacks; React stays the default for React apps.

A sample of the surface, every paint resolved through the shared token layer. Withheld: the Storybook carries the company's brand.
Web Components Storybook. Lit-based, with docs, controls and accessibility checks for each component. Withheld: the knowledge base carries the company's brand.
The accessibility standard: ADA, Section 508 and WCAG 2.2 AA, written around the focus, state and contrast behavior the components already have. Withheld: the knowledge base carries the company's brand.
Which library to use. Web components for Vue, Angular and older stacks, React for React apps. Withheld: the knowledge base carries the company's brand.
Component guidance. Button, from principles to content rules. - 04
One Figma design, three stacks
To show that the multi-platform claim holds, I took one Figma design, a public waitlist page, and rebuilt it three times, each the way that stack is normally written. React uses the typed components from the React library. Vue 3 uses the web components through isCustomElement, .prop bindings for arrays and the standard custom events. ASP.NET Core uses the same web components as plain HTML inside Razor pages, with no build step; assets come from a CDN or are self-hosted for offline and strict-CSP government environments. The .NET build came first and served as the blueprint for the other two.
Evidence · Three builds of one page from one token set. The .NET build has its own study, linked below, including the delivery assumption that broke when the packages went private.
The .NET adoption study(opens in a new tab)
Withheld: the design names the company's product.
Figma, the source. Withheld: the build names the company's product.
React, from the React library. Withheld: the build names the company's product.
Vue 3, from the web components. Withheld: the build names the company's product.
ASP.NET Core, from the web components as plain HTML. - 05
AI and Figma tooling: guardrails for the way people build now
Engineers were already writing UI with Cursor and Claude. Rather than fight that, I gave the assistants the design system itself. The MCP server (@client/ds-mcp-server) runs locally and exposes components, tokens, usage examples and audit tools, so when an assistant writes UI it looks up the real component API or the right token instead of guessing. The Figma Toolkit plugin (@client/ds-toolkit) connects Figma to code editors over a live bridge. The Figma parity tooling snapshots Figma nodes and overlays them on Storybook stories, measuring the difference in position, size, fill, padding and radius.
Evidence · MCP tools: list-components, search-components and get-component for the real inventory and props. get-tokens and suggest-token to match a hard-coded hex to the nearest token or flag it as a new-token candidate. audit-spacing, audit-typography and score-alignment to find drift in a stylesheet. check-contrast and audit-a11y for WCAG 2.2 AA contrast and an axe-core scan of the rendered page. get-usage-example and remap-variables for working examples and moving off old variables. Two real catches: check-contrast flagged neutral-500 on white at 3.62:1 (fails AA) and neutral-600 at 4.83:1 (passes), a one-step fix already in the palette, after which audit-a11y reported 0 structural violations. suggest-token mapped the hero's #1b1035 to --color-primary-1000 and found that a gold eyebrow color had no close token, a real gap now handed to the design team.

The MCP tool surface. An assistant builds with the real system instead of guessing at it. Withheld: the knowledge base carries the company's brand.
MCP server overview in the knowledge base, which tells designers and engineers how to wire the server into their editors. Withheld: the knowledge base carries the company's brand.
Maturity status. 38 components, 29 in React, 18 as web components, 17 on all three platforms, plus server-rendering support for each one, and a tab for the MCP server. - 06
What a teammate built on it: the knowledge base
The best test of a design system is someone else building on it. A teammate built the company's design knowledge base on my packages: usage guidance, foundations, the accessibility standard and a live maturity tracker covering all three platforms. The guidance is written in the designers' language and the counts come from the packages, so the page stays honest about what is ready, what is in progress and what has not started.
Evidence · Runs on @client/ds-*. Tracks every component across Figma, React and web components, with server-rendering support noted per component.
Withheld: the knowledge base carries the company's brand.
The knowledge base home. Withheld: the knowledge base carries the company's brand.
Why the starter exists, in the knowledge base. - 07
What a teammate built on it: the Design System Starter
A teammate also built the Design System Starter, a deployed prototyping site plus a template teams copy out to start a product. Every prototype gets a live URL and uses the same components that ship in the product, so a yes in the prototype means a yes in the product. The court, portal and authentication prototypes below are the teammate's; they are built entirely from the design system components, and there is no separate dark design. Semantic tokens switch it.
Evidence · Prototypes use stub data only; no customer data appears. Screenshots captured November 3, 2026.
Withheld: the prototype carries the company's brand.
The attorney case-management product: Criminal Case Details. A court case-management screen for a county circuit court, built entirely from the system. Withheld: the prototype carries the company's brand.
The same screen in dark mode. No separate design; semantic tokens switch it. Withheld: the prototype carries the company's brand.
The product portal. A single app shell for Court, Records Management, Search and the rest of the product line. Withheld: the prototype carries the company's brand.
The portal, dark theme. Withheld: the prototype carries the company's brand.
Recording Desk. A county recorder's intake queue: table, badges, filters and a document side panel. Withheld: the prototype carries the company's brand.
Short-term rental incident form. A form residents fill in, with the radio, input and banner patterns. Withheld: the prototype carries the company's brand.
Tasks. A dense data table with sorting, grouping and status badges. Withheld: the prototype carries the company's brand.
Rebranded headers for every product: the rebrand applied consistently. Withheld: the prototype carries the company's brand.
React components reference. Every component at every size and state. Withheld: the prototype carries the company's brand.
Authentication flows: login and forgot-password. - 08
The feedback loop: gaps found downstream, closed upstream
The starter kept architecture decision records, and they are blunt about where the system fell short. That is what made them useful. Each gap a consumer found became work in the packages, and once a fix shipped, the consumer deleted its workaround. The starter found 8 of 31 foundations components with no dark styles and patched them locally in a holding cascade layer. I moved fifteen of those dark sheets into the foundations package as real [data-mode="dark"] rules. With 1.8.1 the starter dropped its local dark sheets and an input-focus workaround; loader, progress and tooltip now follow the page theme, which the local patches never managed. An audit found the starter maintaining 26 of its own versions of published React components; as the React library closed the gaps from 1.6.0 onward, the starter switched to the published Input and Select and deleted its own.
Evidence · The starter has moved from 1.4.x to 1.9.0 through routine package bumps, without rewrites.
Working with the teams
I built the platform, but not in a vacuum. These are the standing relationships it runs on.
Product teams on four stacks
React, Vue, Angular and .NET teams each consume the system the way their stack is normally written. The three-stack demo exists so the conversation with each team starts from a working page in their own language rather than from a promise. What they hit on day one, like reading a value off an element or listening for a component's own event, gets written down once instead of rediscovered per team.
A teammate, who built on the packages
A teammate built the knowledge base and the Design System Starter on my packages, and kept architecture decision records about where they fell short. Those records set a good part of my roadmap. The loop is simple: the starter finds a gap and patches it locally, I fix it upstream, the starter deletes the patch on the next version bump.
The design team
Tokens are the contract between us. When the MCP server's suggest-token found a color with no close token, the gap went to the design team as a new-token candidate rather than being hard-coded. Figma parity tooling measures the difference between a Figma node and the Storybook story, so design review has numbers to point at.
Outcomes
- Shipping on 3 stacks. React, Vue and .NET have each built the same Figma page from one token set. Web components are the planned default for new UI outside React.
- 17 of 38 tracked components ship in Figma, React and web components. React leads, and web components are about halfway to React parity and climbing.
- Accessibility moved into the system. Focus, states and contrast live in the components, and the MCP tools let teams audit their own product UI against WCAG 2.2 AA from their editor.
- AI writes on-system code. Assistants look up real components and tokens, and drift gets caught as it is written instead of in code review.
- A platform others build on. A company knowledge base, a prototyping site and a product template are all built on the packages by someone other than me.
- Dark mode gaps found by a consumer were fixed upstream and the consumer's workarounds deleted; the starter has moved from 1.4.x to 1.9.0 through routine bumps.
- What's next: harden the core 15 React components (unit, accessibility and Figma sign-off), add a WCAG gate to CI, Figma-baseline visual regression, and a timeboxed pilot with one product team.
Key Decisions
6 architectural decisions, and the reasoning behind each.
One token layer and one set of Lit web components that work in any stack, alongside the mature React library.
A component built once serves React, Vue, Angular and .NET. No stack pays for its own button, its own form fields and its own bugs.
ARIA, keyboard behavior, focus and contrast live inside the components.
Teams get accessibility by using the system. For a government vendor, that turns a compliance risk handled team by team into a property of the platform.
Three-layer semantic tokens in the W3C DTCG format, with only the semantic layer allowed in design or code.
The rebrand and dark mode changed in one place and every product followed. Values named for how they look would have survived neither.
An MCP server that gives AI assistants the real inventory, tokens and audit tools.
Engineers were already using Cursor and Claude. Giving the models the system is what stops them inventing generic UI, and it caught a real contrast failure before review.
Tooling that checks code against Figma and against the token set.
Drift stops being something a reviewer notices. The parity tools and the audits produce a number, and a number is something a team can act on without me in the room.
Packages stable enough that a teammate could build a starter, template and prototyping site on them.
Starting a product went from a week of wiring to copying a template. And the consumer's own decision records became the most honest roadmap the system had.
What this proves
A design system does not have to pick a framework. Keeping design decisions in plain CSS and treating React and web components as two thin ways to deliver them is what let one Figma page ship on React, Vue and .NET from one token set.
It also does not have to be the only thing its author builds. The knowledge base, the starter and the prototypes were built by someone else on the packages, and the gaps they found went upstream instead of staying as workarounds. That is the test of a platform: someone else can build on it and get something back.
And the AI layer is not a feature on the side. Engineers were going to use assistants either way. Giving the assistants the real components, tokens and audits is what keeps the output on-system, and it is the same move that makes drift measurable for people.