Design systems and localization for Next.js sites, built into the code you already have
For Next.js websites whose styles were set page by page, we build one design system into the code and set up the language versions on top of it. Colors, type, spacing and breakpoints become tokens, the parts your pages repeat become components with all their states, and existing pages move onto them in small pull requests your developers review. Checks in CI compare pages with approved screenshots and reject hard-coded values, so the system stays in use after handover. The work can stop at the system and its checks, or continue through every page and language.
Norml designs the system from your brand guidelines and builds it into your Next.js code: tokens, components, a styleguide page, CI checks, the conversion of existing pages and the language setup. Translations come from your team, and your developers review and merge every change.
What design system and localization work covers
Every project starts from the code and brand material you already have. Some need the whole system plus new languages; others need only tokens and checks, or only the language setup on an existing system.
Tokens from your brand guidelinesColors, type sizes, spacing, radii, shadows and breakpoints are defined once as tokens in the code, on short scales with names your designers and developers share. Components and pages read their values from the tokens, so a brand change is made in one place.
01
Components with all their statesButtons, fields, cards, navigation and other recurring parts are built as components with hover, focus, disabled, loading and error states. Desktop and mobile copies of the same section become one component that adapts to the screen width.
02
A styleguide page and a written guideA page inside the site shows every token and component state, rendered from the real code, so anyone can check what exists before building something new. The written guide sits in the repository and explains when to use each token, when a new component is justified and how a page is assembled from existing parts.
03
Screenshot checks set up before restylingBefore any styles change, each page is captured at the agreed screen widths, and the comparison runs in CI on every pull request. A difference nobody planned holds the merge; an intended one is approved and becomes the new reference.
04
Lint rules against hard-coded valuesLint checks in CI reject inline styles, raw color values and one-off sizes in new code. On a large codebase they start as warnings for files not yet converted and become errors as each part moves onto the system, so existing work isn't blocked on the first day.
05
Existing pages moved onto the systemPages are converted a section or a page at a time in small pull requests. Inline styles and duplicated markup are removed, and each change passes the screenshot comparison before the next one starts.
06
Language versions on one domainEach language gets its own path prefix on the same domain. Text moves out of components into translation files, every page carries language tags and alternate entries in the sitemap, and an automatic translation widget, if the site has one, is removed. Missing translations fall back to the source language, except on pages you mark as required in full, such as legal pages.
07
Components that hold longer translationsEvery component is shown on the styleguide page with your longest translated labels at each screen width. Fixed-width labels give way to ones that wrap or grow, so a longer language doesn't push buttons, menus or cards out of shape.
08
Brand systems, multilingual structure and release safeguards in our projects
Shows brand rules turned into theme code: the brand book another agency made for a dietitian-led nutrition site became the design system of a custom WordPress theme that replaced its Elementor build, with pages moved over in stages.
Shows language versions planned together with the page structure: the multilingual website of a personal injury firm, where each practice area and sub-practice has its own page and URL.
Shows the route a code change takes before it goes live: a Manhattan co-working company's WordPress code moved onto Git, with QA, CI/CD and a staging copy in between, and we started an incremental refactor of it.
Shows reusable parts in a custom WordPress build: FAQ and call-to-action components on an AI/ML engineering studio's site, where adding a service or industry page extends the structure we built instead of rebuilding it.
Repository accessAccess to the repository by invitation, a branch to work on, and the notes your developers use to run the site locally. We don't need production access: changes go live through your own review and deployment.
01
Brand guidelines and design filesLogo files, colors, fonts and their licenses, and the Figma file or UI kit if there is one. When the guidelines leave a value open, such as a spacing step or a hover color, we propose one for your approval.
02
Your CI and merge rulesThe CI service the repository runs on, the checks a pull request must pass today, and who reviews and merges changes. New checks are added alongside the existing ones.
03
Languages and translationsThe source language, the languages to add, who writes and approves each translation, and which pages must exist in full in every language before they go live.
04
Pages and prioritiesWhich pages or sections matter most, and which must not change visually during the conversion. They set the order in which pages move onto the system.
05
Who signs offA named decision-maker who approves tokens, components and screenshot changes, and settles design questions for your team.
06
How the work moves through your codebase
[Review the code and the brand]
We run the site locally, map where colors, spacing and type are set today, list duplicated sections and compare them with your brand guidelines. You receive a short plan for the token structure, the first components and the order of the work.
Step 01
[Capture the screenshot baseline]
We record the current pages at the agreed screen widths and switch the comparison on, so the first restyling pull request is already checked against them.
Step 02
[Build tokens and core components]
Tokens and the first components are built with their states and shown on the styleguide page. You approve them before any page uses them.
Step 03
[Convert one section completely]
One section goes through the whole process: tokens, components, lint rules and screenshot checks. Problems it reveals are fixed in the system before the other pages follow.
Step 04
[Move the remaining pages]
The other pages follow in small pull requests, and the lint rules tighten as each part is converted.
Step 05
[Add the language versions]
Text moves into translation files, language routes and tags are set up, and each page is checked for layout with your translations at every screen width.
Step 06
[Leave the system with your developers]
Your developers get the styleguide page, the written guide and the CI checks, and we walk them through adding a component and building a page with it.
No account layer between you and them. These are the Norml specialists this work runs through.
Let's chat
“I've spent 10 years working across development and marketing. I started as a developer, but design, SEO and advertising were already part of the job. That taught me to treat a website as one system: the business, the content, the design and the code have to work together. At Norml, I lead the architecture behind our work and stay involved wherever strategy, design, development and search meet.”
Questions about Next.js design systems and localization
Do you rebuild the site or work in our existing Next.js code?
We work in the code you have. Pages move onto the system one pull request at a time, so the site keeps running and your developers can follow every change. If the review shows that part of the code can't take the system, we explain why and scope that part separately.
Can our developers do part of the conversion?
Yes. We can set up the tokens, the first components, the styleguide page and the CI checks, and your developers convert the remaining pages. The same checks run on their pull requests as on ours.
Will the Figma file and the code use the same names?
Yes. Token and component names are agreed once and used in both. If you have no Figma library, we can build one that mirrors the coded components, or your designers can work from the styleguide page.
Do you translate the content?
No. Translations come from your team or your translator, and your team approves them. We move the text into translation files, set up the language routes and tags, and check every translated page for layout problems before release.
How do the checks keep the system in use after handover?
A pull request that adds a raw color, an inline style or a one-off size fails the lint check, and one that changes a page unexpectedly fails the screenshot comparison. The design can still change, but through a token or component that someone approves.
How do you keep the written guide accurate?
It lives in the repository next to the components it describes. We can add a check that flags a pull request when it changes a component without updating that component's description.
Does our styling setup need to change first?
No. Tokens are added to the styling approach the code already uses, and components read them from there. If the code mixes several approaches, we agree which one stays before any page is converted.
Do you build with Next.js yourselves?
Yes. We rebuilt our own website on Next.js and Sanity, and for client sites we build custom WordPress themes or use headless WordPress, Next.js or Sanity when a site needs them. On a project like this we keep your framework, hosting and deployment setup unless the review shows a reason to change them.
Can the website and our product share the system?
Yes, when both read the same tokens. This work covers the public website. Product screens behind a login are designed and built as their own project, and they can use the tokens and components set up here.
Which parts of a design system project are scoped separately?
Brand identity, copywriting and back-end changes are scoped on their own, and translation stays with your team. A domain change with its redirect map, or analytics set up around your consent rules, can be added as its own part of the scope. We don't promise a conversion or speed figure for the converted pages.
Read the full write-ups of these four projects
They were built on other platforms, so look at them for the approach: a brand turned into components, language versions planned with the pages, and checks around each release.