Um ein Designsystem zu erstellen, prüfen Sie Ihre bestehenden Interfaces, legen Prinzipien und Umfang fest, definieren Design Tokens, gestalten und programmieren die Kernkomponenten, dokumentieren ihre Verwendung, erproben das System an einem echten Produkt und richten eine Governance ein, damit es sich weiterentwickelt. Die Reihenfolge zählt: Systeme, die aus echten Produktanforderungen entstehen, werden genutzt; Systeme, die isoliert entworfen werden, überleben selten ihr erstes Release.
Dieser Ratgeber geht jeden Schritt durch, stellt die Tools hinter skalierbaren Designsystemen vor und zeigt die Fehler, die wir beim Aufbau von Designsystemen für Web- und Mobile-Produkte am häufigsten sehen.
Kurz gesagt: Ein Designsystem aufzubauen heißt, wiederkehrende Interface-Entscheidungen in gemeinsame, wiederverwendbare Assets zu verwandeln. Beginnen Sie mit einem Audit der bestehenden Screens, definieren Sie Tokens für Farbe, Typografie und Abstände, gestalten und programmieren Sie die Kernkomponenten, dokumentieren Sie ihre Verwendung und erproben Sie sie an einem Live-Produkt. Governance, Verantwortlichkeit und Versionierung halten das System nützlich, wenn Produkte und Teams wachsen.
Was brauchen Sie, bevor Sie ein Designsystem aufbauen?
Vier Dinge sollten feststehen, bevor jemand Figma öffnet:
- Ein klarer Grund. Schnellere Releases, ein zweites Produkt, ein Rebranding, Anforderungen an die Barrierefreiheit. Der Grund bestimmt den Umfang. Wenn Sie noch abwägen, lesen Sie, wann Ihr Unternehmen ein Designsystem braucht.
- Ein Sponsor. Jemand in der Produkt- oder Technologieleitung, der Zeit und Budget für das System schützt.
- Ein interdisziplinäres Team. Mindestens ein erfahrener Produktdesigner und ein Frontend-Entwickler, mit Input aus Produktmanagement, Marke und QA.
- Ein erstes Produkt. Ein echtes Produkt, an dem gebaut und getestet wird, kein hypothetisches.
Das Budget ergibt sich aus diesen Entscheidungen; unser Ratgeber zu den Kosten eines Designsystems nennt die Spannen.
Designsystem erstellen in 8 Schritten
1. Bestehende Interfaces prüfen
Machen Sie Screenshots aller wichtigen Screens und gruppieren Sie, was Sie finden: Buttons, Eingabefelder, Farben, Schriftgrößen, Icons, Abstandswerte. Zählen Sie die Varianten. Die meisten Audits fördern weit mehr Versionen desselben Elements zutage, als irgendjemand erwartet hat, und schon die Zahl wird zum Argument für das Projekt. Ein formales Designsystem-Audit ergänzt Prüfungen zur Barrierefreiheit und einen priorisierten Umfang.
2. Prinzipien und Umfang festlegen
Formulieren Sie drei bis fünf Prinzipien, die Diskussionen entscheiden, zum Beispiel „Klarheit vor Dekoration“ oder „standardmäßig barrierefrei“. Legen Sie dann fest, was zu Version 1 gehört: welche Produkte, welche Plattformen (Web, iOS, Android) und ob das Ergebnis nur Design oder Design und Code umfasst.
Halten Sie auch fest, was nicht dazugehört. Marketingseiten, E-Mail-Vorlagen und Datenvisualisierung folgen oft anderen Regeln als das Produkt-Interface; sie in Version 1 aufzunehmen, kann den Aufwand verdoppeln. Ein kurzes Scope-Dokument, das Design, Engineering und Produkt gemeinsam abstimmen, verhindert, dass das System zur Wunschliste wird.
3. Die Grundlagen schaffen: Design Tokens
Tokens sind benannte Werte, die Designer und Entwickler gleichermaßen verwenden: `color-primary`, `space-200`, `radius-sm`, `font-heading-lg`. Organisieren Sie sie in Ebenen:
- Primitive Tokens: die Rohpalette und die Skalen (blue-600, 16 px).
- Semantische Tokens: die Bedeutung (color-action-primary, color-text-error).
- Komponenten-Tokens, wo nötig (button-padding-x).
Die semantische Ebene ermöglicht es, später Dark Mode, eine Submarke oder ein Rebranding durch neu zugeordnete Werte umzusetzen, statt Screens neu zu gestalten. Leiten Sie Palette und Typografie aus Ihren Markenrichtlinienab und prüfen Sie den Farbkontrast schon jetzt nach WCAG 2.2 AA, nicht erst nach dem Launch.
4. Die Kernkomponenten gestalten
Beginnen Sie mit den 15–25 Komponenten, die auf den meisten Screens vorkommen: Button, Link, Eingabefeld, Auswahlliste, Checkbox, Radiobutton, Schalter, Card, Modal, Navigation, Tabs, Tabelle, Hinweis, Tooltip, Avatar. Gestalten Sie für jede alle Zustände (Standard, Hover, Fokus, aktiv, deaktiviert, Laden, Fehler) und jede Größe, die Sie tatsächlich brauchen.
Priorisieren Sie anhand der Häufigkeiten aus dem Audit. Eine selten genutzte Datumsbereichsauswahl kann warten; das Formularfeld, das auf jeder Seite vorkommt, nicht.
5. Die Komponenten im Code umsetzen
Ein Designsystem, das nur in Figma existiert, lässt Entwickler jede Komponente von Hand nachbauen. Setzen Sie die Komponenten im Tech-Stack Ihres Produkts um, etwa React, Vue, SwiftUI oder Flutter, mit denselben Tokens wie in den Designdateien. Schreiben Sie sie als barrierefreie, getestete, versionierte Pakete und entwickeln Sie sie isoliert, meist in Storybook.
Mit diesem Schritt zahlt sich das System in der Entwicklung von Web- und Mobile-Appsaus, denn jeder neue Screen beginnt mit getesteten Komponenten.
6. Die Verwendung dokumentieren
Die Dokumentation beantwortet die Fragen, die tatsächlich gestellt werden: wann diese Komponente eingesetzt wird und wann nicht, welche Variante, was im Text stehen soll, wie sie sich mit der Tastatur verhält. Zeigen Sie Beispiele für richtige und falsche Verwendung, fügen Sie Code-Snippets hinzu und halten Sie die Dokumentation nah an den Komponenten, damit sie aktuell bleibt.
Schreiben Sie für die Menschen, die sie unter Zeitdruck lesen: einen Entwickler, der das richtige Prop sucht, einen Content-Designer, der das Muster für Fehlermeldungen braucht, eine externe Agentur, die am Montag gebrieft wurde. Kurze Seiten mit Beispielen sind besser als lange Abhandlungen über Philosophie.
7. An einem echten Produkt erproben

Bauen Sie einen Live-Flow wie das Onboarding, den Checkout oder ein Dashboard mit den neuen Komponenten neu auf. Der Pilot deckt fehlende Zustände, umständliche APIs und Lücken bei den Tokens auf, die kein Review-Meeting findet. Beheben Sie sie und weiten Sie das System dann auf den nächsten Flow oder das nächste Produkt aus.
Für die ESA-Plattform Solar Eclipse Trilogyhaben wir die visuelle Identität und das digitale Designsystem gemeinsam entwickelt, von Wireframes und Figma-Prototypen bis zu responsiven Interfaces und wiederverwendbaren Komponenten im Produktivbetrieb. Weil Identität, Komponenten und Code im selben Team entstanden, gab es nicht die übliche Lücke zwischen Brand Book und Produkt.
8. Governance und Versionierung einrichten
Legen Sie fest, wer für das System verantwortlich ist, wie Teams neue Komponenten vorschlagen, wie Änderungen geprüft werden und wie Releases versioniert werden (Semantic Versioning mit Changelog ist der übliche Standard).
Definieren Sie von Anfang an einige Kennzahlen, damit das System sein Budget rechtfertigen kann:
- Akzeptanz: der Anteil der Produkt-Screens, die mit Systemkomponenten gebaut sind.
- Abgelöste oder überschriebene Komponenten in Figma, ein Signal, dass etwas fehlt.
- Time to Ship für ein Standard-Feature, verglichen mit der Zeit vor dem System.
- Barrierefreiheitsprobleme , die pro Release in der QA gefunden werden.
Prüfen Sie diese Werte jedes Quartal mit dem Sponsor. Ohne diesen Schritt bauen Produktteams innerhalb weniger Monate wieder eigene Varianten. Unser Ratgeber zur Wartung eines Designsystems beschreibt die Verantwortungsmodelle genauer.
Was sind die besten Lösungen für skalierbare Designsysteme?
Tools allein machen ein System nicht skalierbar, aber die richtige Kombination hält Design und Code synchron.
| Bedarf | Gängige Lösungen | Was sie lösen |
|---|---|---|
| Designbibliothek und Tokens | Figma (Bibliotheken, Variablen, Modi) | Gemeinsame Komponenten und themefähige Tokens für Designer |
| Token-Pipeline | Style Dictionary, Tokens Studio | Export einer Token-Quelle nach CSS, iOS, Android und auf andere Plattformen |
| Komponentenentwicklung | Storybook | Codierte Komponenten isoliert entwickeln, testen und präsentieren |
| Dokumentation | zeroheight, Supernova, eine eigene Dokumentationsseite | Ein Ort für Richtlinien, Design- und Codebeispiele |
| Ausgangspunkt | Open-Source-Systeme wie Material Design oder IBM Carbon | Bewährte Muster zum Anpassen, statt bei null anzufangen |
| Qualität | Automatisierte Tests für Barrierefreiheit und visuelle Regression | Regressionen bei Kontrast, Fokus und Layout vor dem Release erkennen |
Die besten Lösungen für skalierbare Designsysteme haben eines gemeinsam: eine zentrale Quelle für Tokens, die automatisch auf jede Plattform fließt. Wenn wir ein System über mehrere Produkte skalieren, wie in ein Designsystem skalierenbeschrieben, ist diese Pipeline wichtiger als jedes einzelne Tool. Praktiken speziell für Figma finden Sie in unserem Ratgeber zu Designsystemen in Figma.
Wie lange dauert der Aufbau eines Designsystems?
Richtwerte für ein Senior-Team:
- Grundlagen und Kernkomponenten in Figma: vier bis acht Wochen.
- System auf Produktebene in Design und Code, mit Pilot: drei bis sechs Monate.
- Multi-Produkt-System: sechs bis zwölf Monate in Phasen, danach kontinuierliche Weiterentwicklung.
Ein Designsystem parallel zu einem neuen Produkt aufzubauen, ist effizient: Komponenten werden einmal gestaltet und sofort genutzt. Wenn Sie ein MVP launchen, halten Sie das System schlank; mehr dazu in Wie lange dauert die Entwicklung eines MVP?.

Was sind die häufigsten Fehler beim Aufbau eines Designsystems?
- Alles gestalten, bevor etwas ausgeliefert wird. Hundert Komponenten in Figma und keine im Produktivbetrieb helfen niemandem.
- Den Code auslassen. Entwickler interpretieren die Designs dann unterschiedlich, und die Inkonsistenzen kehren zurück.
- Das System eines anderen Unternehmens komplett übernehmen. Material oder Carbon lösen die Probleme ihrer Urheber; anpassen, nicht blind übernehmen.
- Keine verantwortliche Person. Ein System ohne benannte Verantwortung verfällt innerhalb eines Jahres.
- Barrierefreiheit als spätere Phase behandeln. Fokuszustände und Kontraste nachträglich in jede Komponente einzubauen, kostet weit mehr, als sie von Anfang an einzuplanen.
- Zu starr. Wenn das System einen berechtigten neuen Bedarf nicht abdecken kann, umgehen Teams es. Bieten Sie einen Weg für Beiträge an.
Designsystem intern aufbauen oder mit einem Partner?
Der interne Aufbau funktioniert, wenn Sie erfahrene Kapazitäten in Design und Frontend und eine stabile Roadmap haben. Ein Partner hilft, wenn Sie schneller vorankommen müssen, Erfahrung mit Systemen fehlt oder Marke, UI/UX und Engineering in einem Team liegen sollen. Viele Unternehmen kombinieren beides: Der Partner richtet mit dem internen Team Grundlagen, Komponenten und Governance ein und übergibt dann die Verantwortung.
Bei Morpheon entwickeln wir Designsysteme im Rahmen der Produktarbeit, oft bei einem Neugestaltung der Webseite oder einer neuen Plattform, sodass das System ab dem ersten Sprint an echten Screens getestet wird.
Häufige Fragen
Sollten wir ein Designsystem von Grund auf erstellen oder auf einem bestehenden aufbauen?
Ein Open-Source-System wie Material Design oder IBM Carbon als Ausgangspunkt spart Zeit bei Verhalten und Barrierefreiheit, bringt aber dessen Bildsprache und Einschränkungen mit. Die meisten Unternehmen passen eines auf Komponentenebene an und bauen eigene Tokens und eine eigene Markenebene. Ein kompletter Neuaufbau ist gerechtfertigt, wenn Ihr Produkt oder Ihre Marke sehr spezifische Anforderungen hat.
Wer sollte für ein Designsystem verantwortlich sein?
Eine benannte verantwortliche Person, meist ein erfahrener Produktdesigner oder eine Leitung für Design Engineering, unterstützt von einem kleinen Kernteam aus Design und Frontend. Zur Verantwortung gehören die Roadmap, die Prüfung von Beiträgen und die Veröffentlichung von Versionen. In größeren Organisationen bedient ein eigenes Designsystem-Team die Produktteams als interne Kunden.
Was ist der Unterschied zwischen einem Designsystem und einer Komponentenbibliothek?
Eine Komponentenbibliothek ist die Sammlung wiederverwendbarer Interface-Elemente, in Design und/oder Code. Ein Designsystem umfasst die Bibliothek, aber auch die Tokens, Prinzipien, Dokumentation, Barrierefreiheitsstandards und die Governance darum herum. Die Bibliothek ist der Werkzeugkasten; das System erklärt auch, wie und warum man ihn nutzt.
Braucht man Entwickler, um ein Designsystem zu erstellen?
Ja, wenn das System die Umsetzung beschleunigen soll. Designer können Grundlagen und eine Figma-Bibliothek allein erstellen, aber erst codierte, getestete Komponenten beseitigen doppelte Entwicklungsarbeit. Beziehen Sie ab dem Audit einen Frontend-Entwickler ein, damit Tokens und Komponenten in beiden Welten gleich benannt und strukturiert sind.
Wie viele Komponenten braucht ein Designsystem?
Weniger, als die meisten Teams zu Beginn denken. Fünfzehn bis fünfundzwanzig Kernkomponenten decken die meisten Screens eines typischen Webprodukts ab. Fügen Sie Komponenten hinzu, wenn mindestens zwei Teams oder Features sie brauchen, nicht auf Vorrat. Ein ausgereiftes System auf Produktebene erreicht mit der Zeit oft 40–80 Komponenten.
Bereit, Ihr Designsystem aufzubauen?
Bei Morpheon gestalten und entwickeln wir Designsysteme gemeinsam mit den Produkten, die sie nutzen, von den Tokens bis zum Produktionscode.

