A centralized design system that ended the "which blue is the real blue?" debate across Point of Sales, ERP, Loyalty, Ordering, and Kiosk.

Role | Principal Product Designer, Design System Core Team |
Team | 7 Designers, with a 3-person principal team (Abianto, Fei, Bambang Murwantoro) |
Timeline | 2023, weekly Friday cadence for 6 months |
Scope | Foundations and UI Kit for Desktop and Mobile |
Products | POS, ERP, Loyalty, Ordering, Kiosk (B2B and end customer) |
Tools | Figma (variables, libraries), Contrast Checker, Design Spec (documentation), manual token hand-off to engineering |
TL;DR
Every ESB product had grown its own design system. Each one was fine alone, but together they created inconsistent UI, duplicated work, and endless debates between designers and developers. We merged them into one system called Pujasera, a name borrowed from Pusat Jajanan Serba Ada, the Indonesian food court where many vendors share one roof. Different products, one shared place. The result: a single source of truth for foundations and components, a token-based hand-off to developers, and about 90% visual consistency across products.
1. Context
ESB builds software for the food and beverage industry. That means many products serving very different people: cashiers on a POS, back-office staff in ERP, and end customers using ordering apps, loyalty features, and self-ordering kiosks.
When I joined in 2022, each product team had already built its own design system. This made sense at the time. Teams needed to move fast, and a local system was the quickest way to ship. A year later, the cost of that speed became visible.

2. The Problem
With several systems living side by side, we kept running into the same three issues.
Inconsistency. The same element looked different depending on the product. Colors, heights, typography, and component behavior all drifted apart.
Broken distribution. When one system published a new or improved component, the others never received it. Each team had to notice the update and migrate it by hand, and most of the time nobody did.
Expensive communication. Designers and developers kept debating the "true" color, using different names for the same component, and resolving conflicts in how components were shared. These were not design problems. They were alignment problems, and they would never end as long as the sources stayed separate.
The real issue was not that our systems were bad. It was that we had many of them, and every difference was a new conversation.
Here are the example issues that we found
Colors


Components
Size

Radius

Each product has different dimensions, statuses, radii, heights, and so on, even though they all the same back-office platform ecosystem.
3. Objectives
We set four goals for Pujasera.
Consistency. Centralize interface elements into one source of truth across all ESB products.
Focused scope. Standardize components for Desktop and Mobile first, instead of trying to cover everything at once.
Firm hand-off. Use design tokens as the shared language between design and development.
Sustainable governance. Create clear ownership for who decides, builds, reviews, and publishes, so the system keeps improving after launch instead of decaying.
Scalable theming. Support brand differences between products without forking the components.
4. Design Principles
Before building anything, we agreed on how we would make decisions.
One name, one meaning. A component or token has a single name and a single purpose everywhere.
Unify, don't average. When we merged existing components, we did not pick a winner. We looked for the one spec that covers every product's real needs.
Purpose over value. Tokens describe what something is for, not what it looks like.
Ship small, ship often. A useful but incomplete system beats a perfect one that never arrives.
5. What We Did
5.1 Organizing the team
In 2023 we had 10 designers. To avoid a design-by-committee outcome, we formed a principal team of three: Abianto, Fei, and me.
Our responsibilities:
Run design system sessions
Decide which components to create and in what order
Distribute component work across the team
Review every component before it was accepted
Publish and educate the rest of the team
This gave contributors freedom to build while keeping one quality gate.

5.2 Auditing and unifying components
We started by inspecting what already existed. Take the button as an example. We compared every version across the existing systems and listed sizes, states, heights, and widths. Then we designed one button spec that covered all products' needs, instead of keeping five slightly different ones.
The same process applied to inputs, tables, navigation, and other core components.

5.3 Turning raw values into purposeful tokens
This was my main contribution. The existing files were full of raw values such as hex codes and pixel numbers. A hex code tells a developer what a color looks like, but not where or why to use it, which is exactly what fuels the "true color" debate.
I restructured these into tokens with a specific purpose:
Layer | Example idea | Why it matters |
|---|---|---|
Raw values | The base color palette, spacing scale, type scale | The ingredients |
Purpose tokens | Text primary, surface default, border subtle, action primary | Says what it is for |
Now, when a designer applies "action primary" and a developer reads the same name in code, nobody needs to negotiate. A brand or theme change touches the purpose layer, not hundreds of components.

5.4 Distribution that needs no effort
We reduced the system to two Figma files:
Foundations (color, typography, spacing, tokens)
UI Kit (Desktop and Mobile components)
Both files are automatically added to every new design file. A designer opens a new file and the correct foundations and components are already there. No searching, no importing old libraries, no choosing between versions.

6. Deliberate Trade-offs
Good systems are defined as much by what they leave out as by what they include.
Decision | Reason | What we accepted |
|---|---|---|
Wide-screen POS and Kiosk components postponed | These run on large displays with big touch targets and need different rules. Forcing them in would have delayed everything else. | Those teams build their own components in local files for now, until a future update. |
Manual token hand-off instead of automatic GitHub sync | Automatic sync can push unintended changes into production code. | A manual step for each update, in exchange for control and safety. |
Incomplete system, released weekly | Teams needed value early. | Coverage grew gradually instead of at once. |
7. How Updates Reach the Team
The principal team handles creating, publishing, and educating. A new component is announced in the team chat, and for bigger changes we run a short demo session. Education matters as much as publishing, because a component nobody understands is a component that gets rebuilt.
For six months, we kept a steady rhythm of one release every Friday.
8. Outcome
A single file setup that removed mismatched updates between systems
Faster design work with less friction at hand-off, since designers and developers now share the same token names
About 90% design consistency across multiple products
Fewer debates. Conversations moved from "which color is correct?" to "how should this component evolve?"
Sample screen

9. Reflection
What worked. A small principal team with clear ownership, plus automatic library distribution. Making the right thing the default removed most adoption problems.
What I would do differently. Define how we measure consistency from day one, so the 90% number is backed by a repeatable method. I would also bring a developer into token naming earlier.
What's next. Wide-screen components for POS and Kiosk, deeper coverage of the component library, and revisiting automated token sync once the team has a safe review process around it.
Pujasera works for the same reason its namesake does: many different vendors, one shared space, and everyone knows where to find what they need.