Figma + Chrome Plugin Suitedesign · engineering · less friction
Internal-tooling plugins that automate the hand-off between design and engineering — used across three design teams, saving a few hours a week per engineer, quietly.
The diagram, walked through in plain language
- 1Designers work in Figma, like always
No new tool, no training course. The first plugin sits inside Figma and exports the colours, fonts, and spacing of the selected design as a structured file.
- 2A shared 'tokens' git repo holds the truth
That exported file is committed to a small repo on GitHub. It is the single source of truth for which colours, fonts, and spacings the apps may use.
- 3A second Figma plugin polices drift
If a designer reaches for a custom colour that isn't in the shared tokens file, the plugin highlights it and suggests the closest official one — preventing a thousand slightly-different shades of grey from creeping into the apps.
- 4Engineers get a Chrome extension
Pointed at any design URL, the extension fetches the matching tokens, overlays component boundaries on the design, and produces ready-to-paste code snippets in the right framework (JSX for one app, Vue for two).
- 5A schema check guards everything
A Zod schema validates the tokens file at every commit. A typo in the design tokens fails CI on the design-tokens repo before it can break an engineer's build.
- 6Adopted by three teams, voluntarily
Each plugin does one thing well. Engineers report ~4 hours a week saved — not on heroic tasks, but on hundreds of fifteen-second interruptions that used to add up.
The brief
A product org with three designers, fifteen engineers, and a velocity problem that was not where anyone was looking. The designers were producing great specs; the engineers were implementing great components; and every week a few hours per engineer were being spent on the transition between the two — eyedroppering hex codes, transcribing spacing, exporting assets by hand.
The ask wasn't a big design system project. It was the boring work in between.
The constraints
- Adopted, not mandated. Nobody was going to install three plugins if the first one felt like a training course.
- Consistent design-token schema across Figma and the codebase, versioned, with zero ambiguity at the boundary.
- Work in the browsers and Figma versions engineers actually run — no VPN-only internal tooling.
- Keep the plugin surface small. Do two things well, not ten things poorly.
The shape we built
Three plugins, each tightly scoped. One Figma plugin exports a selected frame's tokens (color, type, spacing, radii) into a versioned JSON file committed to the design-tokens repo. A second Figma plugin rides alongside it to flag tokens that drift from the committed set — if a designer reaches for a custom hex that isn't in the token library, the plugin highlights it.
The Chrome extension is for the engineer's side of the wall. Point it at a design spec URL and it fetches the corresponding token snapshot, overlays component boundaries, and produces clipboard-ready snippets in the codebase's component language (JSX for one app, Vue for two). No copy-paste from Figma's sidebar, ever.
Every plugin validates against a shared Zod schema. A token file that doesn't parse fails CI at the design-tokens repo, long before it reaches the engineering side.
What was hard
- Figma's plugin API surfaces selected nodes asynchronously and inconsistently across file types. Dealing with that required a small adapter layer that the UI code never sees.
- Chrome MV3 service-worker lifetimes. A plugin that silently dies every five minutes is one support ticket away from being uninstalled. We moved state to extension storage and accepted slightly slower cold starts.
- Adoption. The tooling was built against one team's specific pain points; rolling it to two other teams required a week of shadowing them and watching what they did differently.
What it does today
Three teams are on the full suite. The design-tokens repo has 380 tokens under version control across four apps. Engineers report roughly four hours a week saved per person — not on any single heroic task, but on hundreds of fifteen-second interruptions that used to add up.
What I'd do differently
I'd have instrumented adoption from day one. We had anecdotes for six months before we had numbers, which meant prioritization discussions about the plugins were vibes-based arguments. A tiny telemetry line — opt-in, anonymous, counting invocations — would have changed the conversation in week two.
- TypeScript
- Figma Plugin API
- Chrome Extensions MV3
- Vite
- Zod (token schema)
Continue the tour
Have a similar problem?
If this shape of engagement fits what you're working on, I'd be happy to scope it.