"We should build a design system" is one of the most expensive sentences a small team can say out loud.
It sounds responsible. Big companies have them. Every conference talk about consistency ends with one. But a design system as usually pictured — a documented component library with tokens, variants, a Storybook, a versioning policy and a team to maintain it — is infrastructure. Infrastructure has a cost, and for a three-person startup shipping its first product, that cost often arrives long before the benefit.
What the team actually wants is smaller: screens that look like they belong together, and fewer arguments about padding. You can get most of that with ten decisions written down on one page.
What a design system is really for
Strip the ceremony away and a design system does three things:
- It removes repeated decisions. Nobody re-picks the button radius every time they build a form.
- It makes inconsistency visible. If the rules are written down, a deviation is either a bug or a deliberate exception.
- It lets more people build without a designer in every thread.
The third one is the only one that truly needs scale. The first two work with a team of two. So the question isn't "should we have a design system?" It's "which decisions are we making over and over, and can we make them once?"
The ten decisions
Here is the list we'd write before building any component library. Each is a short answer, not a document.
1. Colors, with jobs. One ink color for text, one background, one surface for cards, one accent, and the status colors (success, warning, error). Name them by job — text, surface, accent — not by hue. "Blue-500" tells you nothing about when to use it.
2. Neutral scale. Four or five greys for borders, muted text, disabled states and dividers. Resist adding a sixth.
3. Type scale. A handful of sizes — say body, small, large, and two or three heading levels — with line heights attached. Pick one typeface, maybe two. Decide the weights you'll use and ignore the rest.
4. Spacing scale. A short list of values built on a base unit (4 or 8 pixels is common). The value isn't in the specific numbers; it's that everyone picks from the same list instead of typing 13px.
5. Radius. One or two values. Cards and buttons usually share one; pills and avatars get another.
6. Borders and shadows. Decide whether the interface separates things with lines, shadows, or background shifts, and then mostly stick to that one. Mixing all three is a common source of "something feels off."
7. Button hierarchy. Primary, secondary, and a quiet text-style button. Decide the rule: one primary per view. Write down the destructive variant too, because it will be needed at 11 p.m. before a release.
8. Form fields. Height, label position, error message placement, focus ring. Forms are where inconsistency is most visible to users and most painful to fix later.
9. States. Every interactive element has hover, focus, active, disabled, loading. Decide once what each looks like. Empty states and error states belong here too — they're the screens teams forget to design.
10. Motion. One easing curve and two or three durations. If you use animation at all, it should feel like one product moved it.
That's the whole list. If a team can answer all ten, it already has a design system in the sense that matters. It just lives in a page instead of a package.
Where to write it down
The best format is the one people will actually open. For most small teams that means one of:
- CSS variables (or a theme file) in the codebase. The decisions become code, so they can't drift from what's shipped. This is the most durable option.
- A single page in your design tool, showing the colors, type, spacing and the five or six core components.
- A short README next to the code explaining the rules in words: "one primary button per view," "errors appear under the field, never in a toast."
Notice what's missing: a documentation site. That can come later, if ever.
The crucial part is that design tokens exist in the code, not just in the mockups. A mockup that says "16px" and a codebase with 14 different paddings is the usual gap. Close that gap first.
Components: build the boring ones, late
Once the ten decisions exist, you can build components. But build them from real screens, not from imagination.
A reliable sequence:
- Build the product screens first, using the tokens.
- When you copy the same thing a third time, extract it into a component. Two is a coincidence; three is a pattern.
- Start with the boring components: button, input, card, modal, tag. These show up everywhere and have the clearest shape.
- Leave the clever ones (data tables with every feature, multi-step wizards) until the product demands them.
Extracting too early is a real cost. You guess at the variants people will need, guess wrong, and then work around your own abstraction. A component with eleven props and three of them unused is a sign it was designed before it was needed.
What to skip at the start
- Full documentation for every component. If the component is used in four places, the code is the documentation.
- Dark mode, unless your users ask. If your tokens are named by job, you can add it later without a rewrite. If they're named by hue, you'll be sorry.
- A separate "design system team." At small scale, whoever builds the screen owns the rules.
- Pixel-perfect parity between tools. Matching your design file to your code to the last decimal is a time sink. Match the decisions, not the decimals.
- Perfect naming. A decent name that everyone uses beats a perfect one that's argued about.
When it's time for the full version
A real component library starts to pay for itself when some of these become true:
- More than one product or surface shares the same look (marketing site, app, admin, mobile).
- More than a few people ship UI, and review comments are mostly about consistency.
- You've started to see the same bug fixed in multiple places because the same pattern was copied.
- New hires spend their first weeks asking "which button do we use?"
- Accessibility has become a requirement you need to guarantee, not just hope for. A shared, tested component is the best place to get focus handling and keyboard behaviour right once.
If you recognize two or three of these, it's time to promote the page into a package. And because you wrote the ten decisions first, the migration is mostly mechanical.
A one-afternoon exercise
If your product already exists, here's a quick way to start:
- Open five of your main screens side by side.
- List every distinct text size, color and corner radius you can see.
- Circle the ones that look like accidents.
- Pick the survivors. Those are your scales.
- Replace the strays in code with the tokens, one screen at a time.
You'll probably discover that you have nine greys and five border radii, and that nobody chose any of them on purpose. That's normal. It's also the cheapest consistency win available.
The short version
- A design system is a tool to cut repeated decisions, not a deliverable.
- Ten written decisions — color, neutrals, type, spacing, radius, borders/shadows, buttons, forms, states, motion — cover most of the value.
- Put them in code first, docs second.
- Extract components when something repeats a third time.
- Graduate to a full library when more people and more surfaces make consistency expensive.
Which of the ten does your team still decide from scratch every time?
We're nothink, a small team that designs and builds products for startups — more at nothink.site.
