Daniel VinersarGet in touch

Fortune: building a design system for a multi-property publisher

A design system built from scratch for one main site, four microsites and an internal app, with four brand themes on one core. The build took two months; adoption took much longer. Here's how it worked, how it got into code, and what I'd do differently.

products on one system
6
brand themes
4
days per prototype, down from 1–2 weeks
1–2

July 2022 – March 2026, through AscentCore

What this shows

  1. One design system served a main site, four microsites and an internal app, with brand set at the role level so a component never had to know which brand it was in.
  2. Prototypes went from one to two weeks to one to two days, close to drag and drop from existing components.
  3. The build took about two months and adoption much longer; the lesson is to bring evidence first, before asking anyone to change their roadmap.

What this is

From July 2022 to March 2026 I led design for Fortune, through AscentCore: a team of three to six designers, working with twelve to thirty developers. In that time we built a design system from scratch and moved one main site, four microsites and an internal app onto it.

The system was built in late 2022 and early 2023, before AI was writing UI. Nobody designed it for a model to read. It's here because the foundations it needed are the same ones AI needs today, and because the build turned out to be the easy part.

Where it started

When I joined, there was no design system. Figma projects had no clear structure, so designers, PMs and developers wasted time finding things. There were no standard components, which meant inconsistencies and a slow handoff to development. Nothing was documented. Fortune Recommends, the product-review section, had outdated flows and navigation.

None of that is unusual for a team shipping on several properties at once.

Structure before components

The first thing I changed wasn't a component. It was where things lived.

Decision

Fix where things live before building components

Why
Designers, PMs and developers wasted time finding things, and the handoff to development was slow.
Result
Every Figma file got the same pages in the same order, and every feature a dedicated hand-off file, marked ready for development and separate from the working versions. The design process went into Confluence.
The page list of a Fortune Figma file: Documentation, Wireframes, High-Fidelity, A/B Test Design, Archive/Bin and Thumbnail.
The same pages, in the same order, in every Figma file.
A Figma project for the My Account feature, with a pinned hand-off file marked Ready for development next to the V1 and V2 working files.
One project per feature: the hand-off file, marked ready for development, is separate from the working versions.

That sounds like housekeeping. It's also the precondition for a system.

You can't make people reuse components they can't find.

One system, four brands

The system had three levels of tokens: raw values at the bottom, roles in the middle, components on top. Variables were split across four brand themes. A role like brand-primary had a different value on each microsite, while neutrals and semantic colors (success, warning, error) stayed the same everywhere.

That split was the main design decision.

Decision

Brand at the role level

Why
One system for every property, with each one keeping its own brand.
Result
A component never had to know which brand it was in. It asked for brand-primary, and the theme answered.
Two Brand Colors sheets from the design system. The neutral and semantic swatches are identical; the brand and accent swatches differ.
Two brand themes side by side: neutrals and semantic colors are shared, brand colors change with the theme.

On top of tokens sat a grid with breakpoints, then components, then patterns, then page templates. Typography was part of it too: Graphik Cond and Saol Text for headings, Graphik Cond, Graphik Compact and Georgia for body text, each with responsive values documented next to the styles.

Typography boards: headers in Graphik Cond and Saol Text; body styles in Graphik Cond, Graphik Compact and Georgia; responsive variables; links.
Typography styles for headings and body, with their responsive values documented alongside.

Building it took about two months. I did it with one other designer, as side work, next to the feature tickets from product. That detail matters later.

Getting it into code

The system lived in Figma, and the developers implemented it in code. Two developers owned that work.

Decision

Migrate token by token

Why
Feature work always came first, so the system could only arrive in pieces, alongside it rather than instead of it.
Result
Tokens first, then page by page and component by component. I made the case for what would pay off first; the tech lead decided the order.

Adoption took much longer than the build. Feature work always came first, and for a long time the system wasn't seen as a priority: people didn't yet see how much it would help. That changed once it was ready and they saw what it saved. After that it got real priority.

In later phases, we used the Figma MCP server to migrate system components into Storybook.

What it changed

Before the system, a prototype took one to two weeks, depending on complexity. After it, one to two days, close to drag and drop from existing components.

The clearest proof was Fortune Recommends. We redesigned it on the system: card comparisons, review templates, landing pages, and a new navigation.

Fortune Recommends home page before and after the redesign, side by side.
Fortune Recommends home, before and after.

What I'd do differently

Bring evidence first. The system itself went to plan. Adoption is where I'd change my approach. I asked for priority with an argument, and the evidence (one to two weeks down to one to two days) only existed after the system was built. Next time I'd bring the evidence for why a design system matters at the start, before asking anyone to change their roadmap.

Make the code layer part of the system. I didn't have visibility into how the tokens landed in code. Today I'd make the code layer part of the system, not a separate implementation.

Two sources of truth that happen to agree, until they don't.

Why it matters for AI

This system wasn't built for AI. But look at what it had: roles instead of raw values, so a component asks for brand-primary instead of a hex code; tokens in three levels; documented process and styles; templates that turn a new page into assembly.

Those are the foundations a model needs to produce on-brand UI. The demo on this site shows the difference in practice. The piece Fortune didn't have is the one I'd change anyway: a code layer that comes from the system instead of being rebuilt next to it.

What a client gets

Someone who has built a multi-brand system and lived through its adoption. The AI-Readiness Review is the Fortune lesson turned into a first step: it brings the evidence first, before anyone is asked to change a roadmap.

  • AI-Readiness Review: your Figma library, tokens and documentation, scored, with a prioritized fix list.
  • Audit + Roadmap: the code side as well, plus a roadmap that plans adoption, not just the build.
  • Design System Partner: senior help every month to carry that roadmap out with your team.
See all three offers