Skip to main content

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.

Insights11 min read2,022 words

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 groupMinimum setExample names
ColourBrand primary, surfaces, text, borders, statuscolor.primary, color.surface, color.text.primary, color.border, color.danger
Typography6 to 8 text stylestext.display, text.title, text.body, text.label, text.caption
SpacingOne scale on a 4 or 8 basespace.1 = 4, space.2 = 8, space.3 = 12, space.4 = 16, space.6 = 24, space.8 = 32
Radius3 to 4 valuesradius.sm = 8, radius.md = 12, radius.lg = 20, radius.full
Elevation2 to 3 levelselevation.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:

TokeniOS size / weightAndroid size / weightUse
text.display34pt bold32sp mediumBig screen titles
text.title22pt semibold22sp mediumSection and card titles
text.headline17pt semibold16sp mediumList item titles, emphasis
text.body17pt regular16sp regularBody copy
text.label15pt medium14sp mediumButtons, tabs, chips
text.caption13pt regular12sp regularMetadata, 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.

  1. •Button: primary, secondary, tertiary (text), destructive; default, pressed, disabled, loading. Minimum height 44pt on iOS, 48dp on Android.
  2. •Icon button: same states, 44pt or 48dp hit area even when the icon is 24.
  3. •Text input: label, placeholder, helper text, error, disabled, with and without leading icon.
  4. •Select / picker trigger: looks like an input, opens a native picker or sheet.
  5. •Checkbox, radio and switch: all states, with labels.
  6. •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.
  7. •Card: surface, radius, padding, optional media.
  8. •Top bar: title, back, up to two actions.
  9. •Tab bar or navigation bar: 3 to 5 items, selected and unselected states.
  10. •Bottom sheet and dialog: title, body, actions.
  11. •Toast / snackbar: message plus optional action.
  12. •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

  1. •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.
  2. •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.
  3. •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.
  4. •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.
  5. •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.
  6. •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.