- 01
Market
Saudi Arabia
- 02
Written for
Head of Digital, CTO
- 03
Decision
Stop rebuilding the same interface pieces across products and teams
- 04
Languages
EN · AR
The mechanism
One decision travelling from token to every product that consumes it
This is the property the whole investment buys: a change made once, in the system, arriving everywhere the system is used — correctly, in both directions, without a ticket per product.
A flow from a decision recorded as a token, to components consuming tokens, to products assembling from components, to a versioned update reaching them all — with a branch where new needs enter through a contribution path instead of local forks.
- 01
The decision becomes a token
A colour, a type size, a spacing step or a direction rule is recorded once as a named token — the atom both the design tool and the codebase read.
- 02
Components consume the tokens
Buttons, fields, tables and navigation are built from tokens, with right-to-left behaviour and accessibility inside the component rather than left to each team.
- 03
Products assemble from components
Feature teams compose screens from the library instead of redrawing primitives, and spend their time on the part of the product that is actually new.
- 04
A version updates them all
A brand adjustment or an accessibility fix ships as a versioned release, and every consuming product picks it up on its own schedule — one change, propagated, not re-implemented.
When a product needs what the system lacks
A real need the library cannot meet goes through the contribution path — proposed, reviewed, added for everyone — instead of being forked locally. The fork is how systems die; the path is how they grow.
The economics
The tenth screen should cost a fraction of the first — that is the system paying rent
Without a system, interface cost is flat: the tenth screen costs what the first did, because every button, empty state and error message is decided again by whoever is building that week. The evidence is visible in any organisation with a few products — the same date picker implemented four ways, dialogs that behave differently across one company’s tools, and an accumulating review burden as design police work replaces design.
For bilingual organisations the duplication doubles, because each team also solves right-to-left alone: one mirrors everything including the icons that should not flip, another leaves the layout untouched and swaps the text, a third does it well in ways nobody else can reuse. Building direction into the system once — as tokens and component behaviour — is the single highest-return piece of the work in this market, and the one an imported system never includes.
The honest cost sits at the start: the first product built on a young system is slower, because the system is being built alongside it. The return arrives from the second product on, and compounds with each one after. That shape — an investment, not a purchase — is why the decision belongs to whoever owns the roadmap across products, not to any single delivery team.
The contents
The four layers a bilingual design system actually consists of
A system is not a style guide with a logo. These are the layers that have to exist for it to be consumed by real products, and the bilingual layer is the one this market cannot import.
Tokens — the decisions
- Colour roles
- Type scale
- Spacing steps
- Elevation
- Motion timing
- Direction rules
Components — the behaviour
- Forms and validation
- Navigation
- Tables and lists
- Dialogs and feedback
- Empty and error states
The bilingual layer
- RTL mirroring logic
- Arabic type styles
- Numeral and date handling
- Mixed-direction text
- Icon flip rules
Governance — the survival
- Living documentation
- Versioned releases
- Contribution path
- Usage analytics
- Deprecation policy
Our role
What we build into the system and what your teams govern after handover
- 01
Foundations from your real products
We start from an audit of the interfaces you already ship, so the first release of the system covers the components your teams rebuild most — value from the first consuming product, not after a year of foundation work.
- 02
Both directions as first-class
Every component ships with its right-to-left behaviour designed, built and tested — the mirroring, the type, the numerals — so an Arabic product consumes the library as directly as an English one.
- 03
Governance installed, not just documented
We set up the versioning, the documentation site and the contribution workflow, and coach the team that will own them — because a system without a working owner starts decaying the week we leave.
The brand and the product roadmap stay yours; we turn them into infrastructure every team can build on, and leave the governance running so the system is still coherent — in both languages — long after the engagement ends.
Common questions
What buyers ask
At what size does an organisation actually need a design system?+
Count surfaces and teams, not employees. One product built by one team gets little from a formal system — a well-organised component folder does the job. The economics turn when the same interface decisions are being made independently in more than one place: two products, a product plus a portal, separate front-end teams, or an agency roster shipping under one brand. Bilingual delivery lowers the threshold further, because right-to-left work is expensive to duplicate and hard to do consistently ad hoc. If two teams would consume it tomorrow, the system pays; if not, it is early.
Can we adopt an open-source component library instead of building our own system?+
Often, as the engine — rarely as the whole car. A mature open-source library supplies tested component mechanics, which is real value you should not rebuild. What it does not supply is your brand as a token architecture, your products’ specific patterns, the governance that keeps teams consistent, or — decisively in this market — a bilingual layer that handles Arabic type, mirroring and numerals properly, since most libraries treat right-to-left as an afterthought setting. The pragmatic build wraps a proven library in your tokens, your direction layer and your governance: less work than from scratch, and it behaves like yours.
Our teams already ignore the brand guidelines. Why would they adopt a design system?+
Because guidelines ask for effort and a system removes it. A PDF of rules makes the correct way extra work: read, interpret, implement, get reviewed. A design system inverts that — the correct button is the one already in the code, with its states, accessibility and right-to-left behaviour done, and the deviant path is the one that costs effort. Adoption follows self-interest, which is why we measure a system by consumption rather than compliance, and why the first release targets the components teams are most tired of rebuilding. When the system is genuinely the fastest route to shipping, policing it becomes unnecessary.
In this cluster
Start the conversation
An audit of the interface duplication across your current products, and a scoped first release of the system that removes the most expensive of it.
Start the conversation
