Three companies, one design system: who decides what ships?
How IBM, Riyadh Air and Publicis Sapient ran one library without it becoming the bottleneck: roles, one front door, four gates and a sprint rhythm.
- 3
- companies, one system
- 6
- named roles
- 4
- quality gates
- 10
- playbook cases

01 the room:
Three companies, one library, and requirements that changed every week
Riyadh Air was building an airline from zero, so everything was new at once: the brand, the apps, the teams.
Picture the people working on Riyadh Air's apps in 2023. IBM was the lead digital partner, with product squads, a design system team and the front-end engineers who built it in code. Riyadh Air had its own design team, a Digital Experience Director and the business owners who signed things off. Publicis Sapient's designers were building their own product areas on the same library and contributing back to it.
None of these teams had worked together before. Every squad had a product owner and a business analyst, and the client brought new requirements, redesigns and quick iterations every week. All of it landed on one Figma library and one Storybook.
A design system is easy to start and hard to run. This is the story of the operating model behind this one: who owned what, how a request got in, how it got checked, and the routines that kept dozens of people moving in one direction.
02 the problem:
Everyone could change it. Nobody owned it.
The same six problems every growing system hits, all in the first few months.
None of these were unique to us. Ask anyone who has run a design system at scale and they'll name most of them. What made Riyadh Air different was that all six showed up early, because the system and the product were being born together.
Snowflakes. Three squads built three date pickers, because nobody knew the other two existed.
Drift. The Figma library said one thing and Storybook another, and QA couldn't tell which was right.
A bottleneck. Every change waited on the central team, so squads detached components to keep moving, which created more snowflakes.
No owner. When two companies disagreed about a component, there was no one whose call it was. Decisions went to whoever spoke last.
A moving target. A component approved on Monday could be redesigned by Friday.
Silent changes. Library updates landed without notice and broke screens that had already been signed off.
How might three companies move fast on one design system, without it falling apart every time the product changes?
03 the belief:
Start with people, not files
A solid design system begins with people and sound processes. It goes beyond detailed design files and reusable code.
Everything that followed came from three ideas.
Treat it as a product. The system has customers (the squads), a backlog, a roadmap and releases, like anything else the airline ships.
Give every decision an owner. Not a committee: one named role per decision, so nothing waits on a meeting.
Make everyone a contributor. Every designer is a co-owner. The central team curates; it doesn't gatekeep.
04 who decides:
Six roles, six clear calls
The first thing we did was write down who decides what. Not job titles, but the one question each role answers.
The DLS Custodian asks: do we need this, or does it already exist? They own the front door: triage, the backlog, and the announcement when something ships.
The DLS Design Team asks: what should it be? They design and update components, with every state, both languages and both themes.
The Design Director asks: is it good enough? They hold the quality bar in design reviews and in the final review before release.
The Digital Experience Director asks: is it right for Riyadh Air? This is the business owner's approval. Nothing goes to development without it.
The Front-end Team asks: can we build it well? They join technical review early, build the component and publish it to Storybook.
The Product Development Teams ask: what do our users need? These are the squads. They raise requests, contribute components and use what ships.
Once the names were on a page, half the arguments stopped. Most process arguments are really ownership arguments.
Underneath sat a small core team with three owners: a product owner keeping the system delivering the most value to squads, a design owner leading component design and handoff, and an engineering owner leading development and release.
05 the operating model:
Central owners, federated contributors
Somewhere between one team building everything and everyone building anything.
There are three classic ways to run a design system. In a solitary model one team builds for itself, which works until the second product arrives. In a centralised model one team builds for everyone; it stays consistent, and everyone waits in one queue. In a federated model everyone contributes; it's fast, until nobody can say no.
We took the middle path that most mature systems end up on. A small central team owned and curated the system. Every squad had three seats, a designer, an engineer and a product owner, and each seat had a counterpart in the system team. Squads didn't wait for the system; they fed it, through one front door.
The central team stopped being the place where all the work happened and became the place where all the work was checked.
06 one front door:
Ten kinds of work, one way in
Requests used to arrive in chats, in reviews and in corridors.
We gave the system one front door, a ticket in Azure DevOps, and wrote a playbook for the ten kinds of work that came through it: a new component, a change to an existing one, a contribution from a squad, a changelog from Figma, a design-to-development handoff, an audit of an existing component, documentation, a library publish, file distribution and the approval checklist. If you knew which case you were in, you knew the next step.
The first question at the door was always the same: is a component required? The DLS Custodian checked the library first. If the answer was no, the requester got a link to the existing solution in Figma and Storybook, often the same day. If it was yes, the request went into the backlog to be defined, prioritised and planned into a sprint.
The cheapest component is the one you don't have to build.
Many requests ended at no. That was the point: a fast no kept squads moving and kept the library from filling up with near-duplicates.
07 request to release:
A gate, with an owner, at every handoff
Every component went through the same five steps: propose, design, code, document, release.
Each step ran the same small loop inside it: start, compose, test, present, review, deliver. Between the big steps sat a gate, and every gate had a named owner and a written list of criteria. Fail a gate and the work went back one step, not back to the start.
Gate 1, definition of ready. Is the request ready to plan? A use case, where it's used, and a Figma playground link.
Gate 2, proposal criteria. Is it used in more than one place? Can it be solved by an existing component? Is it new, or a variant?
Gate 3, development handoff. Every state, both languages, both themes, tokens only, annotated for developers. The Digital Experience Director signs off before development starts.
Gate 4, component handoff. QA passed, Figma and Storybook match, documented and ready to announce. Changes were announced, not discovered.
A review without a checklist is an opinion. A review with one is a decision.

08 squad reviews:
Four pairs of eyes before a developer
The same thinking applied to product screens, not just components.
With three companies designing at once, a screen passed four reviews, each by a different pair of eyes. First a peer review, by another designer in Figma and Slack. Then the design lead. Then Riyadh Air's own design team, in Teams. Finally a handover, where engineers walked through the screen with the designer before it moved to development.
Every no went back to the designer with comments, so feedback was a loop, not a wall. And because each review had a different owner, no single person became the place where screens piled up.

09 contribution:
Anyone could be the one to make things change
The library was the status quo, and anyone was allowed to challenge it.
A designer, a developer, even a copywriter: if a component fell short, the person who hit the problem started the contribution, owned together with the design owner. It had four steps.
Identify. Copy the Figma playground file, which holds a checklist, a space for the use case and a space for research.
Submit. Raise a ticket or post in the design system channel, answering five questions: is it new or existing, where will it be used, what's the use case, why do we need it, and where's the playground.
Proposal review. An open forum. Anyone could join, whatever their discipline, and the checklist decided: will it be used more than once, is it a new problem, and is it a new component or a variant of one we have? Most proposals ended up as a variant.
Define requirements. A consolidation review with at least one developer to agree variants, states and props, then a ticket in the backlog.
DS-214In reviewSeat selector: add a “blocked” state
- New or existing?
- Existing · G06/B05
- Where will it be used?
- Booking, check-in, manage trip
- Use case
- Seats held for crew or exit rows
- Why do we need it?
- Today squads grey it out by hand
- Playground
- Figma file linked
An illustrative ticket, following the five questions every submission answered.
10 rituals:
A heartbeat every sprint
Process on paper only works if it has a rhythm people can plan around.
Seven routines ran every sprint, so people knew when to bring a proposal, when a decision would be made, and when they'd see what had shipped.
Contributions were welcome any day. At the start of the sprint came definition and prioritisation: agree a component's states, behaviour and priority before anyone opens Figma. Mid-sprint, component design reviews for critique from designers and stakeholders, and engineering handoffs to walk through details and agree requirements. Engineering QA ran asynchronously, with designers and engineers reviewing the build together. At the end of the sprint, design approvals checked the work against the definition of done, and demos and release packaged it, showed it and told every stakeholder.
The tools were the same for all three companies, one per job: Azure DevOps for requests and the backlog, Figma for the library and playground files, Storybook as the source for developers, Teams, Slack and Webex for reviews, and mail for release announcements.
Routines on the calendar did more for adoption than any document.
11 what changed:
Fast and consistent, at the same time
Clarity. Every decision had one owner. Disagreements between companies had a named person to settle them, and new joiners learnt the process from one page.
Speed. Squads proposed and contributed components themselves, through one front door, instead of waiting in a queue. Many requests ended the same day with a link to something that already existed.
Quality. Every component passed the same four gates before release, so what was approved in Figma was what shipped in code. Changes were announced, not discovered.
Adoption. IBM, Riyadh Air and Publicis Sapient ran the same routines, and the model held through weekly changes from zero to launch.
Write down who decides before you write down how.
Build one front door, and make “no” fast.
Let anyone contribute, but curate centrally.
12 for your team:
The same operating model, set up for you
If your design system team has become the slowest step in shipping, this is how we'd start.
Audit
$1,500
In this case studyMap who decides what today, where requests come from, and where design and code drift.
See what's includedFoundations
$5,900
In this case studySet up the front door, the gates and the roles alongside your core system.
See what's includedPartner
$2,900/mo
In this case studyRun the rituals with your teams until they run themselves.
See what's includedThe work above was done by our founder as an IBM employee. Layer One now runs the same method as a studio, for product teams of any size.
Told by Aniket Pandey, who worked on this as a design system designer at IBM (2023–24), with IBM design and engineering, Riyadh Air's design team and business owners, and Publicis Sapient. “We” is the IBM design system team. This is IBM client work done as an employee, not Layer One client work. Diagrams belong to Riyadh Air and IBM and are shown for portfolio purposes.


