Design Systems That Scale, Built First
Manav Bajaj · February 20, 2026 · 6 min read

The Template Trap
We build a design system before writing a single page because pages built from shared tokens get cheaper with every page, while template sites get more expensive with every page. Once the token set exists, a new landing page can take an afternoon.
Here's the pattern we keep running into: a business launches a website using a template. It looks great on day one. Clean, modern, professional. Everyone's happy.
Six months later, they need a new page type. The template doesn't support it. They hack it in with custom CSS. Then they need another page type. More hacks. Then the brand evolves slightly, with new colors and updated typography, and suddenly every hack breaks.
The template saves real time on day one. Every workaround after that is unpaid interest, and by the second brand refresh the interest exceeds the principal.
Templates optimize for first impressions. Design systems optimize for the 50th page.
What a Design System Actually Is
A design system isn't a Figma file with pretty components. It's a contract between design and code that answers three questions:
- What are our atoms? Colors, type scales, spacing, shadows, radii. These are the non-negotiable primitives.
- What are our molecules? Buttons, inputs, cards, badges: the reusable building blocks composed from atoms.
- What are our rules? How do molecules combine? What's the spacing between sections? How does responsive behavior work?
When these answers are codified in CSS custom properties, component APIs and documented patterns, you can build any page without inventing new solutions.
Our Stack for Design Systems
We're opinionated about this:
- Tailwind CSS 4 for utility-first styling with
@theme inlinefor design tokens - CSS custom properties for responsive typography (
clamp()scales) - Component-level APIs: every component accepts a constrained set of variants, not arbitrary props
- Motion tiers: animation intensity is defined per section category, not per component
In practice, every section, every page and every animation draws from the same token set, so adding a new page takes hours, not days.
The Anti-Template Stance
Here's what we mean: a template hands you finished sections, and you live inside their limits. A design system hands you the primitives underneath (section wrappers, motion variants, spacing and border tokens, adaptable components), and those combine into any layout you need, including the ones the template never imagined.
How We Implement This
Phase 1: Audit and Token Definition
Before opening a code editor, we map the visual language:
- Extract every color, font, and spacing value from existing materials
- Define a constrained palette (usually 3-5 primary colors, 2 font families)
- Set responsive breakpoints and typography scales
- Document dark/light section patterns
Phase 2: Component Library
We build the atoms and molecules in code, not Figma first. This is deliberate. Figma components drift from implementation. Code components are the source of truth.
- Buttons, badges, inputs and cards, all with variant props
- Section wrappers with standardized padding and max-widths
- Animation presets (we maintain a shared library of motion variants)
Phase 3: Page Assembly
With the system in place, pages become composition exercises. We're not designing from scratch. We're arranging proven components in new configurations. This is where the speed payoff hits.
The Trade-off
We won't pretend to have a spreadsheet proving this. What we can describe is how it usually plays out on a site that keeps growing on one token system.
The first page takes noticeably longer than a template would. Maybe half again as long, because the time goes into defining tokens and components instead of shipping pixels. By the third page you are ahead. After that, a new landing page is an afternoon, a sitewide color change is one line, and nothing drifts out of alignment because there is nothing to drift: every page pulls from the same source.
That is the honest shape of the trade: slower start, then compounding speed.
When Not to Build a Design System
We're not dogmatic about this. A design system doesn't make sense when:
- The project is a single landing page with no future pages planned
- The timeline is under a week and the scope is fixed
- The brand is still in flux (you need a stable foundation to systematize)
For everything else, any project where the website will grow, evolve, or be maintained, the design system earns back its cost.
The Bottom Line
If your developer is copy-pasting styles between pages, you don't have a system. You have debt. And like all debt, it compounds.
Build the system first. Your future self will thank you.
Ready to stop patching and start building? We design scalable UX systems that grow with your business. Explore our Websites service →
FAQ
Is a design system overkill for a small business site?
For a genuine one-pager with no growth planned, yes, use a template and move on. The system starts paying for itself around the third page, so the real question is whether your site will still be three pages in a year.
How much longer does the first page take with a design system?
The first build usually takes about half again as long as a template build, because the time goes into defining tokens and components rather than shipping pixels. Every page after that gets faster.
Do we need Figma for this?
No. We build components in code first and treat the code as the source of truth, because design files drift from what is actually deployed. A Figma library can mirror the system, but it should never lead it.
When is a template actually the right call?
A single landing page with no future pages planned, a fixed-scope job under a week, or a brand still in flux. A system needs a stable foundation to be worth systematizing.
What does Naavim Labs build design systems with?
Tailwind CSS 4 with design tokens declared once and consumed everywhere, CSS custom properties for responsive type scales, and components that accept a constrained set of variants rather than arbitrary overrides.
Manav Bajaj
Naavim Labs is a growth studio that develops custom software, web applications and AI-powered business systems. Since 2018, over 100 projects. We look at your business first, then build what fits.
More about us →Related service
Websites and E-commerce
Business websites, landing pages and online stores that explain what you do and help customers enquire, book or buy.
Get new posts by email.
One email when a new post goes up. Unsubscribe any time.
Start with a Consultation
Websites and E-commerce
Business websites, landing pages and online stores that explain what you do and help customers enquire, book or buy.
Or see what this service covers first. You get a plan: requirements, what to build and what can be bought, the build cost and the rollout plan.

