← Back home
View
Design Systems · 2026

Design System

One token-based system for a bilingual product. Arabic and English, light and dark, from the first color variable to the last line of developer handoff.

I led it end to end: audit, research, foundations, a 49-component library, documentation, testing and handoff, working closely with engineering and product.

Foundation Tokens cover with ten-step color ramps
Component Library cover with buttons, inputs, toggles and an alert
Arabic data table in dark mode
RoleSenior Product Designer, design system lead
Year2026
PlatformWeb and mobile
TeamDesign, frontend, product, QA
LanguagesArabic and English
ToolsFigma variables, tokens, Dev Mode

Every team was solving the same problems in its own way. Buttons that looked alike but behaved differently, colors picked by eye, and Arabic screens flipped by hand the night before a release.

0color variables, light and dark
0components, atoms to organisms
0variants with every state
0themes and reading directions
The problem

Several products, no shared language

The platform grew fast. Each product team built its own screens, so the same pattern ended up designed and coded several times. That cost us speed, consistency and trust, and it hit Arabic users hardest.

Inconsistent UI

The same action looked and behaved differently from one product to the next.

Slow delivery

Designers redrew and developers rebuilt the same components every sprint.

Arabic as an afterthought

RTL screens were mirrored by hand, with icons pointing the wrong way and fonts swapped late.

No shared names

Figma layers did not match code, so handoff meant redlines and long threads.

No dark mode, weak contrast

Hard-coded colors made dark mode impossible and contrast was checked late, if at all.

How might wegive every team one source of truth that speaks Arabic and English, works in light and dark, and is as easy for a developer to use as it is for a designer?
Principles

Five rules we agreed on before drawing a single button

1

Tokens first

No raw values. If it is not a token, it is a bug.

2

Bilingual by default

Every component ships in LTR and RTL, not just English.

3

Accessible by default

AA contrast verified in both themes before anything ships.

4

One name everywhere

The same name in Figma, in code and in conversation.

5

Never detach

Switches and slots cover real cases, so nobody has to break a component.

Process

From audit to adoption

A design system is a product that serves other products. I ran it like one: research, a roadmap, releases and feedback loops.

Phase 1

Audit

I collected every screen across the products and grouped them by pattern. Seeing near-duplicate buttons, tables and date pickers side by side made the case without a slide deck.

Phase 2

Research

I benchmarked Material 3, IBM Carbon, Atlassian and Shopify Polaris for naming and structure, and interviewed designers and developers about where work got stuck.

Phase 3

Foundations

Ten-step color ramps, semantic tokens, type, spacing, radius and elevation, with Light and Dark modes and an Arabic typography mode.

Phase 4

Components

An atomic library, built atoms first: every state, size and direction, all bound to tokens.

Phase 5

Documentation

Every component page explains anatomy, usage, do's and don'ts, accessibility and the tokens it uses. Written for designers, developers and AI tools.

Phase 6

Testing

Accessibility checks, usability sessions with designers, RTL reviews with native Arabic speakers and visual QA with engineering.

Phase 7

Handoff and governance

Tokens exported to CSS and JSON, code names on every variable, versioned releases and an open contribution model.

Foundations

A language before a library

Components change. Decisions should not. So the system starts with three layers of tokens, and a naming pattern anyone can read out loud.

Primitiveprimary/70

The raw palette. Hidden from designers so nobody picks a hex by eye.

Semanticbackground/primary/bold

The meaning. It points to a different primitive in Light and Dark.

ComponentButton / Primary

Components only use semantic tokens, so a theme change reaches everything.

Try it: tap each part of the token name
///-
ElementWhat you paint: background, text, icon or border.
Light and Dark theme scale, mirrored ramps
Dark mode mirrors each ramp, so step 100 in Light becomes step 10 in Dark.
Verified text and background pairs with contrast ratios
Every same-hue pair is verified for 4.5:1 contrast in both themes.
Elevation levels in light and dark mode
Six elevation levels, each paired with the surface token it belongs on.
Type scale from display to code
Font family and weight are variables. Switching to Arabic is one mode change, to Alexandria.
One component, four contexts

Light or dark. Arabic or English. Same component.

Designers never redraw for a theme or a language. They flip a mode or a property and the tokens do the rest. Switch it yourself.

Data table, light, English Data table, light, Arabic Data table, dark, English Data table, dark, Arabic

Real screens from the Figma library. The data is sample content.

Components

Atoms, molecules, organisms

Built in dependency order, so a fix to Button reaches every modal, table and toolbar that uses it.

Button hierarchy and states

Button

Primary, Secondary, Tertiary and Danger, with six states and a loading state that keeps its width.

Input field states

Input field

Eight states including error, success and read-only, with helper text tied to each one.

Dropdown menu in English and Arabic

Dropdown menu

Nested items switch to RTL automatically, keeping their icons and shortcuts.

Calendar in English and Arabic

Date picker

The grid, weekdays and navigation arrows all follow the reading direction.

Modal variants

Modal

Three sizes, a danger variant and a content slot, in both directions.

Sidebar expanded and collapsed

Sidebar

Expanded and collapsed, with nested navigation items and badges.

Alert variants

Alert and toast

Four status colors in subtle and bold, each pair contrast-checked.

Slider variants

Slider

Single and range, where the fill runs from the right in Arabic.

Deep dive

Tables were the hardest problem, so I rebuilt them around columns

Most Figma tables are built in rows. Change one cell and its column drifts out of line. Designers ended up detaching tables to fix alignment, which broke every future update.

Row based

Each row sizes itself, so cells drift and nobody trusts the table.

Column based

One component per column holds the header and up to ten cells, so alignment is locked.

Pick a type per column

Each column has a Type property. Rows stay in sync through one Rows setting on the table, and each column can be turned on or off, up to ten side by side.

AvatarNameStatusTagsDateTextNumberActionsCheckbox

A toolbar made of switches

The toolbar is its own component, exposed inside the table. Title, search, filter and both buttons are switches, and a slot takes tabs or a date range. No detaching needed.

Column types in the Table column component
Table toolbar options
Right to left

Arabic is not a translation. It is a direction.

Every component has a Direction property. RTL is not a flipped image: each variant is rebuilt with the right rules, so designers get production-ready Arabic screens. Drag to compare.

Arabic data table English data table LTRRTL
Layout mirrorsRows reverse, start and end padding swap, text aligns to the right.
Direction icons flipArrows and chevrons follow reading order. Logos, media controls and check marks stay put.
Arabic content built inEach text property has an Arabic twin, so one instance switches cleanly between languages.
Arabic typeخط الإسكندرية للنصوص العربيةAlexandria arrives through a typography mode, no manual font swaps.
Documentation

Docs people actually open

Every component lives on its own page with the same structure, so people learn where to look once.

  • Hierarchy, states and sizes
  • Anatomy and usage, with do's and don'ts
  • Accessibility notes and the tokens used
  • An Arabic RTL example on every page
The Button documentation page
Button do and don't rules

Rules are written as pairs: what to do and the mistake it prevents.

Collaboration

A system is only as good as its conversations

I spent as much time with engineers, product managers and stakeholders as I did in Figma. Each group needed something different from the system.

  • Same names in Figma and codeEvery variable carries its CSS name, so background/primary/bold is var(--color-background-primary-bold) in code.
  • Component properties match propsType, Size, State and Direction in Figma map one to one to component props.
  • A weekly design and dev syncWe reviewed what shipped, what drifted and what was next, in 30 minutes, with Figma and the browser side by side.
  • Pairing on hard componentsTable, date picker and RTL rules were designed with a frontend engineer, not handed over.

If a developer has to ask what a color is called, the system failed, not the developer.How I framed naming for the team

  • A roadmap ordered by reuseComponents used across the most screens came first, so the system paid off early.
  • One-page proposalsNew components start as a short proposal: the problem, the screens that need it and the cost of not building it.
  • Release notes in plain languageWhat changed, who is affected and what to do, with no jargon.
  • Trade-offs made visibleBuild now or later, custom or shared. Product managers made the call with the facts on the table.

I never pitched the system as design work. I pitched it as fewer bugs and faster releases.My line in roadmap reviews

  • Show, do not presentLive demos of a screen switching to Arabic or dark mode in one click did more than any slide.
  • Adoption tracked openlyWe tracked which screens used library components, so progress was visible to everyone.
  • Brand and accessibility reviewsBrand owners and accessibility reviewers signed off on foundations before components were built.

Stakeholders do not buy tokens. They buy confidence that every product looks and works like one organization.What I kept in mind for leadership updates

  • Office hoursA weekly open slot for questions, reviews and ideas for the library.
  • A clear way to contributePropose, review, design, build, document, release. Anyone can start the flow.
  • Onboarding in one fileA Read me page explains structure, naming and how to use the library in the first hour.

A component nobody asked for is clutter. Every addition starts from a real screen.Our rule for new components

Testing

Tested by the people who use it

A system has two kinds of users: the people building with it and the people using what gets built. I tested for both.

Accessibility

Every text and background pair checked against WCAG 2.2 AA in both themes: 4.5:1 for text, 3:1 for icons and borders.

Usability with designers

Designers built a real screen with the library while I watched where they searched, hesitated or wanted to detach.

RTL review

Native Arabic speakers reviewed mirrored screens for icon direction, dates, numbers and font readability.

Visual QA with engineering

Coded components compared against Figma in light, dark, LTR and RTL before each release.

Pilot team

One product team adopted the library first. Their feedback shaped the release the other teams got.

Verified contrast matrix

The verified matrix: every foreground token on every surface, Light and Dark.

Developer handoff

Handoff became a conversation about behavior, not pixels

Because every value is a token with a code name, developers read the design instead of measuring it. Logical CSS properties meant RTL came almost for free.

  • Tokens exported as CSS variables and JSON
  • Code name on every Figma variable
  • Anatomy and specs on every component page
  • States, sizes, LTR and RTL all covered
  • Accessibility notes for each component
  • Changelog and a version tag on every release

How a new component gets in

Propose→Review→Design→Build→Document→Release
Outcome

What changed

→

One source of truth for every product team, in Figma and in code.

→

Arabic and English from the same component, with no manual mirroring.

→

Dark mode became a setting, not a project.

→

Accessibility built into the tokens instead of checked at the end.

→

Tables that stay aligned, and toolbars nobody needs to detach.

→

New team members productive from the Read me on day one.

A design system isn't a project. It's a product, serving products.Nathan Curtis, design systems consultant

What I learned

Start with naming. Every hard argument later was really a naming argument. Ship small and early: a pilot team taught me more than a month of planning. And governance is product work. A system without an owner and a release rhythm slowly drifts back into chaos.

What is next

Code Connect, so developers see real code next to every component in Figma. Motion tokens for consistent transitions. And a data visualization palette tested for color blindness in both themes.