Go back to portfolio

Syndigo · Commerce

Syndigo: 400+ Clashing Components Consolidated Into 200 for a Platform With 18,000+ Customers

Rebuilt a fragmented enterprise design system as one governed component library connected to production code.

Role
Senior Manager, UX Design
Scope
Design system, syndication, and nutrition tools
Focus
Commerce
Designer
Gideon Awolesi
Syndigo: 400+ components consolidated into 200 case study cover

My contribution · Syndigo

Design system, syndication, and nutrition tools

The work focused on component governance, shared review between design and engineering, and a prototyping workflow built on the real product components instead of generic placeholders.

200
components consolidated
1
governed component library
UI Relay
Figma plugin

What I owned

  1. 01Audited duplicate components across products and consolidated them into approved patterns.
  2. 02Connected Figma components to Storybook so design and implementation could be reviewed together.
  3. 03Managed designers and configured AI prototyping to use the real product components.

Clickable prototypes

Open the Syndigo prototypes

Each project has its own clickable prototype. Fix a product in the publication tracker, map attributes to what your recipients ask for, configure the Nutrition Panel in an import job, or apply a recipe yield.

Overview

About the project

Project overview

  1. Role: Former Senior Manager, UX Design at Syndigo, from June 2025 to April 2026.
  2. What Syndigo does: Brands and manufacturers use Syndigo to manage their product content and send it to the retailers, distributors, and data pools that sell their products. The platform serves more than 18,000 customers in 60 countries.
  3. What I worked on: I rebuilt the design system and managed two product designers. On the product side, I designed the publication tracker and the container mappings for import jobs. I also led the UX on attribute mapping and directed the design of Nutrition Analysis. In 2026, I also redesigned the error popup and the GDSN bulk publish results, and I built a Figma plugin that connects designs to the component code.
  4. Solution: A single code-connected design system across Syndigo’s product suite. It replaced the duplicated component libraries and linked the approved components to Storybook, GitHub, and the company’s AI prototyping tools.
  5. Objective: Give designers, frontend engineers, and product managers the same components to work from, so there was less drift between Figma and production and the accessibility requirements stayed visible.

I partnered with the VP of Design, the Director of Design, and frontend engineering on design-system governance and delivery. In 2026, I rebuilt four of the product tools as clickable coded prototypes, one for each project.

Prototypes

These were separate projects at Syndigo, so each one has its own tab below, and each product tab has its own interactive prototype.

Each prototype follows what the team designed or reviewed at Syndigo, from the meeting notes and the design files. The attribute mapping screen follows the version the team groomed in August 2025, and a contract designer drew that screen. The prototypes run on sample products, recipients, and recipes, and they aren't Syndigo's production software.

Design system: process

The audit told me what needed to change and in what order.

  1. Audit: I inventoried every component across the products, mapped Figma against production, and flagged every duplicate and inconsistency.
  2. Consolidation: I reduced each set of duplicates to one canonical component and documented its anatomy, variants, and version history. Each design frame also showed if the work was in ideation, in progress, or complete, and had the relevant ticket attached.
  3. Code Connect and Storybook: I wrote the Code Connect and component files for all 200 components. In Storybook, you could see the design and the coded component side by side.
  4. Repository work: Engineering gave me access to the codebase, where I maintained the component and Code Connect files directly.
  5. Coded prototypes: I introduced Figma MCP to turn designs into clickable prototypes before development. I also configured Lovable and Claude Design to use the approved components, so anything they generated stayed within the system.
  6. Accessibility: I built semantic structure, labels, and implementation guidance into the components, so the accessibility requirements could still be reviewed during design and delivery.
Design system, Design system: process, figure 1

Context and problem statement

The design system didn’t have a clear structure, and there was very little governance. The same component often existed in several inconsistent versions across products, and nothing connected design to shipped code. There wasn’t a Storybook, the components weren’t connected to code, and UX had no presence in GitHub.

Designers, engineers, and product managers each read the system differently. Delivery slowed down because engineers kept rebuilding interface patterns from inconsistent specifications.

Design system, Context and problem statement, figure 1
Design system, Context and problem statement, figure 2

Stakeholder analysis

  1. Frontend engineers: They needed components that matched the approved design and could go into production without another round of interpretation.
  2. Product designers: They needed one governed component kit, so they could spend their time on product problems instead of recreating common interface elements.
  3. Product managers: They needed to test ideas quickly with prototypes that still matched the real product.
Design system, Stakeholder analysis, figure 1

System audit

I started by looking at how teams were actually using the existing system, in Figma and in production.

  1. Component inventory: I catalogued the components in use and identified duplicates.
  2. Figma-to-production mapping: I compared the design libraries with the shipped interfaces to find where the two had drifted apart.
  3. Team interviews: I spoke with designers and engineers about where the system helped and where they had to work around it.
  4. UI Relay Figma plugin: I built a Figma plugin that maps components to code, tracks coverage and code health, generates and syncs component code, manages tokens and templates, and flags gaps. With it, keeping the system maintained became part of the team’s normal workflow.
Design system, System audit, figure 1
Design system, System audit, figure 2

Challenges and solutions

Design and code weren’t connected. I got access to the repository and maintained the Code Connect and component files myself, so approved design decisions could reach production without anyone having to interpret them again.

The library was also fragmented. I consolidated the duplicate patterns and built the UI Relay plugin to catch drift whenever new work came into the system.

To get teams to adopt it, I connected the system to coded prototypes, Lovable, and Claude Design. That way, teams could keep using the tools they preferred and still work with the approved components.

Design system, Challenges and solutions, figure 1
Design system, Challenges and solutions, figure 2
Design system, Challenges and solutions, figure 3

Accessibility

The components used semantic structure, ARIA roles, and clear labels. They came with representative screen-reader checks and written guidance for teams extending the system, and information didn’t rely on colour alone. This case study does not claim a universal conformance level.

Design system, Accessibility, figure 1
Design system, Accessibility, figure 2

Impact metrics

I consolidated more than 400 clashing, inconsistent components into 200, in a single code-connected source of truth.

Syndigo got its first design-to-engineering pipeline, and designers and developers tested more than 50 coded prototypes before development.

Product and design teams adopted component-based prototyping through Lovable and Claude Design.

Before Lovable supported design systems of its own, I translated the Figma design system into Storybook code, pushed it to GitHub, and connected it to Lovable, so the team of seven to eight designers could attach the design system when they created new designs there.

Because the components were connected to code, designers and frontend engineers repeated less work.

On the product side, the dietitians approved the recipe yield flows in October 2025, and the product manager approved the container mappings modal for grooming the same month.

The publication tracker research with six supplier customers showed that they start from what's broken, and it's the basis for the three buckets in the prototype.

Design system, Impact metrics, figure 1
Design system, Impact metrics, figure 2

Need this level of detail in your product?

Work through the hard product decisions early.

If you’re a product team, that can mean a focused design, system, or prototype project. If you’re hiring, it’s a chance to look closer at how I work across research, interfaces, and code.