Design System for Startups: The Day-One Minimum
A design system for startups, cut to the minimum: the tokens, 12 core components and naming rules to set up in a week, plus what to skip until you scale.

This is for founders, early PMs and the first designer at a startup who keeps hearing "we need a design system" and wonders how much of one. You get the exact minimum to set up in your first week, the order to build it in, naming conventions that survive growth, and a list of things you can safely postpone.
TL;DR: On day one, a startup design system is a small set of tokens (colour, type, spacing, radius, elevation) plus about a dozen components built from them, documented on one page. Name tokens by role, not value, and keep the source of truth in one place that both design and code read from. Everything else, from contribution processes to a docs website, can wait until more than one team builds the product.
What a design system means at startup scale
At a large company, a design system is a product with its own team, roadmap and documentation site. At a startup, it is something much smaller and more useful: a shared set of decisions so nobody has to make them twice.
The real problems it solves early on:
- •Five slightly different greys and three button heights creeping into the app.
- •Developers guessing spacing values from screenshots.
- •Every new screen taking longer than the last because nothing is reusable.
- •A rebrand or dark mode becoming a rewrite instead of a token change.
If those are not hurting yet, you still want the foundations, because they are cheap now and expensive later. What you do not need yet is governance, versioning ceremonies or a public docs site.
The day-one minimum
Layer 1: tokens
Tokens are named values. They are the part of a design system that pays off fastest, because they let you change your whole app by editing one file.
| Token group | Minimum set | Example names |
|---|---|---|
| Colour | Brand primary, surfaces, text, borders, status | color.primary, color.surface, color.text.primary, color.border, color.danger |
| Typography | 6 to 8 text styles | text.display, text.title, text.body, text.label, text.caption |
| Spacing | One scale on a 4 or 8 base | space.1 = 4, space.2 = 8, space.3 = 12, space.4 = 16, space.6 = 24, space.8 = 32 |
| Radius | 3 to 4 values | radius.sm = 8, radius.md = 12, radius.lg = 20, radius.full |
| Elevation | 2 to 3 levels | elevation.1 for cards, elevation.2 for sheets and menus |
That is roughly 30 to 40 tokens in total. Resist adding more until a real screen needs one.
Colour: use two tiers
The single most valuable decision is to separate primitive tokens (the raw palette) from semantic tokens (what a colour is for).
Primitives Semantic (light) Semantic (dark)
blue.600 #2563EB color.primary → blue.600 color.primary → blue.400
gray.50 #F9FAFB color.surface → white color.surface → gray.900
gray.900 #111827 color.text.primary → gray.900 color.text.primary → gray.50
red.600 #DC2626 color.danger → red.600 color.danger → red.400
Components only ever use semantic tokens. That is what makes dark mode, a second brand or a rebrand a mapping change instead of a hunt through every screen. Check every text and surface pairing with a contrast checker before you lock it in; our mobile app color palette guide walks through building the palette itself.
Typography: map to platform styles
Keep your scale short and map it to the platform's text styles so it respects Dynamic Type on iOS and font scaling on Android. A practical mobile scale:
| Token | iOS size / weight | Android size / weight | Use |
|---|---|---|---|
| text.display | 34pt bold | 32sp medium | Big screen titles |
| text.title | 22pt semibold | 22sp medium | Section and card titles |
| text.headline | 17pt semibold | 16sp medium | List item titles, emphasis |
| text.body | 17pt regular | 16sp regular | Body copy |
| text.label | 15pt medium | 14sp medium | Buttons, tabs, chips |
| text.caption | 13pt regular | 12sp regular | Metadata, helper text |
The full reasoning is in our mobile app typography guide.
Spacing: one scale, no exceptions
Pick a 4pt base with mostly 8pt steps and never use a value outside the scale. If 20 is not on the scale, either add it deliberately or use 16 or 24. Our mobile app spacing system guide covers how to apply the scale to padding, gaps and section rhythm.
Layer 2: twelve core components
These twelve cover the large majority of screens in a typical early-stage app. Build them in this order, because later ones are made of earlier ones.
- •Button: primary, secondary, tertiary (text), destructive; default, pressed, disabled, loading. Minimum height 44pt on iOS, 48dp on Android.
- •Icon button: same states, 44pt or 48dp hit area even when the icon is 24.
- •Text input: label, placeholder, helper text, error, disabled, with and without leading icon.
- •Select / picker trigger: looks like an input, opens a native picker or sheet.
- •Checkbox, radio and switch: all states, with labels.
- •List item / cell: leading slot (icon or avatar), title, subtitle, trailing slot (chevron, value, switch). This one component builds settings, menus, search results and more.
- •Card: surface, radius, padding, optional media.
- •Top bar: title, back, up to two actions.
- •Tab bar or navigation bar: 3 to 5 items, selected and unselected states.
- •Bottom sheet and dialog: title, body, actions.
- •Toast / snackbar: message plus optional action.
- •Empty, loading and error states: a reusable pattern, not a one-off per screen.
Each component needs only three things documented: its variants, its states and the tokens it uses. A screenshot with labels is enough.
Layer 3: one page of rules
Write a single page (Notion, Google Doc or the first page of your design file) with:
- •The token tables above.
- •The component list with a picture of each.
- •Five to ten written rules, for example: "One primary button per screen", "Destructive actions always confirm or offer undo", "Never hard-code a colour", "Icons come from one set only".
- •Where the source of truth lives and who can change it.
That page is your design system documentation. It will be read far more than a polished docs site would be at this stage.
How to set it up in a week
- •Day 1: audit. Screenshot every existing screen and lay them out side by side. Circle every colour, font size, spacing value and button style. You will usually find far more variations than you thought.
- •Day 2: tokens. Collapse the variations into the token tables above. Decide the primitive palette and the semantic mapping, including dark mode if you plan to support it.
- •Day 3: set them up in tools. In Figma, create variables for colour, spacing and radius, with light and dark modes on the semantic collection, and text styles for type. In code, mirror the same names as theme constants, CSS variables, a Tailwind theme, or the theme objects in SwiftUI, Compose or Flutter.
- •Day 4 and 5: components. Build the twelve components using only tokens. In Figma, use components with variants and auto layout so they resize properly.
- •Day 6: rebuild two real screens. Pick your busiest screen and your simplest. If they cannot be built from the system, adjust the system, not the screen.
- •Day 7: write the one-page rules and walk the team through it in 30 minutes.
Naming that survives growth
Bad names are the main reason startup design systems get abandoned. Follow these rules:
- •Name by role, not value. color.text.secondary, not gray-500. space.4, not sixteen.
- •Same names in design and code. If Figma says color.surface.raised, the code says the same thing (allowing for syntax differences like surfaceRaised).
- •Use a consistent order: category, then element, then variant, then state. For example: color.button.primary.pressed.
- •Avoid names tied to today's brand. color.primary survives a rebrand; color.ocean does not.
A token file both sides can read might look like this:
{
"color": {
"primary": { "value": "{blue.600}" },
"surface": { "value": "#FFFFFF" },
"text": {
"primary": { "value": "{gray.900}" },
"secondary": { "value": "{gray.600}" }
}
},
"space": { "1": { "value": "4" }, "2": { "value": "8" }, "4": { "value": "16" } },
"radius": { "md": { "value": "12" } }
}
What to skip until later
Postpone these until at least two teams build the product or you have a dedicated designer for the system:
- •A public or internal docs website.
- •Contribution and approval workflows.
- •Formal versioning and changelogs (a short "what changed" message in your team channel is enough).
- •Complex component APIs with dozens of props.
- •Motion tokens beyond one or two standard durations.
- •Multi-brand theming, unless you genuinely ship white-label apps.
- •Building everything from scratch. Starting from Material 3, Apple's native components or a mature open-source UI library and theming it with your tokens is usually the right call.
Signs you need to invest more
Your minimum design system is ready to grow when:
- •Developers regularly ask "which button do I use here?"
- •The same component exists twice in code under different names.
- •New hires take more than a day to build a screen that matches.
- •Product launches a second app or platform.
At that point, add a component changelog, a contribution process and design-to-code checks. Our design to developer handoff checklist is a good next step.
Common mistakes
- •Building the system before the product. Systems should be extracted from real screens, not designed in a vacuum.
- •Too many tokens. If you have 14 greys, nobody knows which to use. Six to eight neutral steps is plenty.
- •Design and code drifting apart. Pick one source of truth and sync from it, even if the sync is manual.
- •Skipping states. A button without disabled and loading states is half a component.
- •Treating it as a project with an end date. It is a living set of decisions; schedule a 30-minute review once a month.
If you generate screens with AI, a small token set makes the output far more consistent. In floow you can generate screens from a description of your tokens and components, then refine them in chat until they match the system.
FAQ
Does an early-stage startup need a design system?
It needs the foundations: tokens, a handful of components and a page of rules. That takes about a week and saves time on every screen after. A fully governed design system with its own team is only worth it once several teams ship the product.
Should a startup build its own design system or use an existing one?
Most should start from an existing foundation, such as Material 3, Apple's native components or an open-source UI library, and theme it with their own tokens. Building every component from scratch rarely pays off before product-market fit.
What should be in a minimum design system?
Colour, type, spacing, radius and elevation tokens; around twelve core components like buttons, inputs, list items, cards, navigation and sheets; and a one-page set of rules covering usage and where the source of truth lives.
How many colours should a startup design system have?
Usually one brand primary, optionally one accent, six to eight neutral steps for surfaces, text and borders, and four status colours (success, warning, danger, info). Define them as semantic tokens so dark mode is a mapping change.
Design it with floow
Once your tokens are set, describe them to floow and generate screens that use them from the start. Try: "Design a set of iOS screens for a task app using primary #2563EB, an 8pt spacing scale, 12pt card radius, SF Pro with 17pt body text, and a consistent list item, primary button and bottom tab bar across Home, Tasks and Settings."
Design your mobile app with AI.
Generate pixel-perfect iOS and Android screens in seconds, then export to Figma or code.
You might also like…
Guides22 November 2026Mobile App Accessibility: Designer and Founder ChecklistMobile app accessibility made practical: contrast, touch targets, Dynamic Type, VoiceOver and TalkBack labels, motion and a full pre-launch checklist.By floow.design
Roundups22 November 2026ScreensDesign Alternatives: 9 Places for Real App ScreensScreensDesign alternatives compared: Mobbin, Page Flows, Refero and more, with what each library is best for and how to turn references into your own screens.By floow.design
Insights21 November 2026Music App Design: Player, Library and DiscoveryMusic app design guide: home and discovery, search, library, mini player, now playing, queue and offline, plus lock screen, car and widget surfaces, with.By floow.design