One source of design decisions for Android, iOS, web, Figma and TV

Head of Product Design

Design-led infrastructure, with an engineering partner. Hamburg / Berlin

Bibel TV's app had no design tokens: every value was hard-coded. I built a token repository that Style Dictionary turns into a served API, so Android, iOS, web and Figma read their values from one source, and so do the video and series detail views on connected TV. Figma is one consumer, not the source.

One source, five platforms reading it today

The setting
Bibel TV, a German broadcaster moving from linear TV to streaming apps. The app was hard-coded, with no tokens or variables, and almost all development depended on an external agency.
My part
I designed and built the token infrastructure: a Git repository in four tiers, Style Dictionary builds in CI, a token API, and automated sync to the platforms and a Figma plugin.
What changed
Android, iOS, web, Figma and the detail views on connected TV read one source today. For the design system and tokens, 95–100% of the code behind the redesigned Home and detail views of the Android app (release 6.0, in beta) comes verbatim from my prototype, by code comparison.
Three takeaways
Put the source of truth where the build reads it. Hold standard and flexibility apart by architecture, not by policy. Design the control surface for the organization you have.

Every change started as an hour estimate

Sprint planning at Bibel TV worked the way agency work does. The development agency estimated each ticket in hours, and with the hours came a cost estimate. Then the sprint started and the tickets were pulled into development.

The app made that expensive by construction. Everything was hard-coded; there were no design tokens and no variables. It got its data from the API and then applied its own custom behavior to it, and that made any change expensive.

Even with the agency using AI for its own development work, change still took a long time.

Where engineering sits outside the company, the standard has to travel with the code

If your developers work for another company, every design change crosses that boundary as a ticket. A library in a design file describes the standard; it gives nobody outside the file a way to change a running app. This study is about putting the standard where the apps read it.

Built for how this company works, not for a textbook

In my own words at the time: "in a way it is not what others would call best practice." The system had to hold without a design team to police it. Two product managers and two product owners call the shots and define the direction, and development sat with external agencies. The system had to work in that reality, with agentic tools baked into the process. Today far more is built in-house, by product managers and product owners working with AI.

The company also had a stated goal: move toward server-driven UI and external control, and reduce the dependency on the development agencies. For the streaming section of the app, that means becoming a renderer of what the API feeds it. Design tokens are a step toward that, and only a step.

Two of the four tiers add no new values, and that is their job

The tokens live in a Git repository in four tiers: primitives (OKLCH colors, spacing, type), then semantic, component, and page or view. Style Dictionary builds the platform outputs from that one definition in CI, and automation pushes each build to the platform endpoints and the Figma plugin.

Diagram: one token repository is built by Style Dictionary in CI and served by a token API. Android reads the API on launch, the web build pulls the same tokens into Storybook, Figma syncs through a plugin; the iOS redesign in development reads the same tokens, and so do the video and series detail views on connected TV. View full size ↗
Fig. 01

Android, iOS, web, Figma and the video and series detail views on connected TV all read the same build today. On iOS the redesign is in development, as it was on Android. Adding a platform is an implementation task, not a system change.

The component and page-or-view tiers only alias downward to semantic and primitive tokens. Each is a place where the company can change a component's text size or spacing, or a view's, without going through the agency that owns the code. Read as a taxonomy it is redundant. Read as a control surface it is the whole point.

The agency was enthusiastic about it, even though, as I said in an interview at the time, they would probably lose some business over it.

How a token change travels

A token change needs no code deploy.

  1. Propose the change

    A token change goes in as a pull request against the repository and is reviewed like any code.

  2. Style Dictionary builds

    CI runs Style Dictionary and generates the platform-specific token files from the single definition, in the Design Tokens Community Group format rather than a proprietary schema.

  3. Automation distributes

    The built tokens are pushed to the platform endpoints and to the Figma plugin.

  4. Platforms read it

    The Android app reads the API on launch and caches the tokens locally. Storybook reads the live token API. Figma updates through the plugin.

What changed, and what the code shows

Figma with the BibelTV Design Tools plugin open: a 'Sync Tokens to Figma' button with the token API as source, beside the primitive color ramps (blue, brand, green, marianBlue, neutral, orange, purple) it wrote into the file. View full size ↗
Fig. 02

Figma as a consumer, not the source: the plugin pulls the primitives from the token API into the design file, and every component page binds to them.

One token on two platforms. Left: the play button on an episode page of the Android app, version 6.0.7, dark on a light page and white on a dark page. Middle: the token API entries component.light.button.primary (background #252F35, text #EBF0F2) and component.dark.button.primary (background #FFFFFF, text #252F35). Right: the same play button, labeled Abspielen, rendered in the web Storybook from the live token API, in both themes. View full size ↗
Fig. 03

One token, two platforms. The Android app's 6.0.7 release build loads this payload at launch, and Storybook reads the live token API. On both, the primary button's fill and label match the token to the hex, in light and in dark. The sizes differ; the figure compares color.

A change
Hard-coded values, so a change went to the agency as a ticket with an hour estimate A token change is a reviewed pull request; Android reads the API at launch, Storybook reads it live, Figma syncs through a plugin
Reach
Android, iOS, web, Figma and the video and series detail views on connected TV receive the tokens today. The API is platform-agnostic: adding a platform is an implementation task, not a system change.
Structure
Four tiers: primitives, semantic, component, page or view. Standardization and flexibility are held apart by architecture rather than by policy.
In the Android code
For the design system and tokens, 95–100% of the code behind the redesigned Home and detail views of the Bibel TV Android app (release 6.0, in beta) comes verbatim from my prototype, by code comparison against release 6.0.8. It is a lower bound: adapted or renamed code is not counted.

I would not hand this architecture to another company as a template

This architecture answers one organization, where product managers and product owners set direction and development sat with an outside agency. It covers the streaming section of the app, including the redesigned home screen, and not yet the other surfaces such as Bible reading.

Server-driven UI stays a direction here, not a shipped state. The tiers are a step toward it.

The radius change is meant to be a pull request

The plan, as I described it in May 2026: if we decide the border radius of our cards is too round or too small, we change it in the token API, and the app pulls it and applies it. Small and medium changes on the home screen would then become free, because the API or the tokens can carry them.

The trip I have verified end to end is a button. The 6.0.7 Android build loads the token payload at launch, and its primary button's fill and label match the token to the hex, in light and in dark, as they do in Storybook.

Questions to ask of your own token architecture

  1. Put the source of truth where the build reads it.

    Change one value in your design file and follow it. If someone has to copy it into each platform by hand, the file describes your standard but cannot hold it.

  2. Hold standard and flexibility apart by architecture, not by policy.

    Tiers that only alias downward give a product team room without new values. Test it: can a team change a component's spacing without inventing a number?

  3. Design the control surface for the organization you have.

    Write down who sets direction, who owns the code and what a change costs. Build the tiers your company can actually reach, not the ones a conference talk recommends.

A company with its own platform team should build less

Where platform engineers sit down the hall, a maintained token pipeline belongs with them, and a Head of Design building CI workflows would be expensive overkill. On a single platform, four tiers and a served API buy little; a well-governed token file does most of the work.

Want to hear more?

  • If you're weighing whether your design system should be a file or a service, I can show you why two of the four tiers here were built to add no new values, and what one button looks like when Android and Storybook read the same token.
Get in touch