Capability 05 of 05 · Built to grow

System Design

Ten screens is a design. A thousand is a system.

System Design structures how a product’s parts fit together: tokens, components, patterns and the rules that hold them, in design and in code, so a new surface is assembled rather than redrawn.

Typical build
8–16 weeks to v1
Scope
Figma · code · docs
Standard
Accessible by default
Component architecture · Your platformIllustrative

An illustrative component architecture: three tokens feed four components, which build three patterns used on web, iOS and Android; changing a part shows everything downstream that inherits it.

Token · color.actionChange color.action once: 2 components, 3 patterns, 3 surfaces inherit it, each covered by a visual regression check.

What it covers · 6 parts

One system, every surface it has to serve

Foundations are defined once and consumed everywhere: web, mobile, email and whatever the product adds next.

Two monitors showing source code on a desk at night
01 / 06

Foundations & design tokens

Colour, type, space, radius, elevation and motion held as tokens in one source of truth and exported to each platform, rather than copied between files.

Tokens · one source
02 / 06

Component library in code

Components built once with their states, keyboard behaviour and ARIA, published as a versioned package and documented in Storybook.

Versioned package
03 / 06

Multi-brand & multi-platform theming

One component set themed for several brands, products or markets, with the differences held in tokens instead of forks.

Themes, not forks
04 / 06

Accessibility inside the components

Focus order, target size, contrast and screen-reader behaviour solved in the component, so every team that uses it inherits the fix.

WCAG 2.2 AA
05 / 06

Documentation & contribution

Usage guidance, do and do not, and a contribution path with review, so the system grows with the product instead of being worked around.

Docs · contribution
06 / 06

Adoption, versioning & migration

Semantic versioning, deprecation notices, codemods where they earn their keep, and an adoption measure per product team.

Adoption measured

How it runs

Audit, build, adopt. Then keep it alive.

The system is built from the screens you already have, so the first release covers most of the product on the day it lands.

  1. Audit Wk 01–03

    Every existing screen and component inventoried, duplicates collapsed, and the accidental inconsistencies separated from the deliberate ones.

    • Interface inventory
    • Duplication report
    • Scope for v1

    Gate · Do we know what exists today?

  2. Define Wk 03–06

    Tokens, naming, structure and the first components agreed across design and engineering, with accessibility acceptance criteria written per component.

    • Token set
    • Naming & structure
    • Component specs

    Gate · Have product teams agreed the foundations?

  3. Build Wk 05–14

    Design library and code package built together, documented in Storybook, and covered by visual regression and accessibility tests in CI.

    • Figma library
    • Code package
    • Storybook docs

    Gate · Is every component documented and tested?

  4. Adopt Wk 12–16

    One pilot team migrated first, then the rest, with office hours, a contribution path and an adoption measure per team.

    • Migration plan
    • Contribution model
    • Adoption dashboard

    Gate · Are teams actually building with it?

Timings are typical and shorten when the evidence already exists.

Change impact · what you will see

Change one token. See every component it reaches.

What a release note looks like when the system is wired properly: each token change, the components that inherit it and the visual-regression result before it merges.

Release 3.4.0 · token diff · Your platformIllustrative
Release 3.4.0 · token diff · Your platform
Token changeButtonInputCardDialogVisual diff
color.action.primary · contrast 4.1 → 4.8Inherits (Passes)Inherits (Passes)—Inherits (Passes)38 snapshots · approved (Passes)
radius.control · 6 → 8 pxInherits (Passes)Inherits (Passes)——24 snapshots · approved (Passes)
space.stack.md · 16 → 20 px—Inherits (Passes)Inherits (Passes)Override (Watch)1 unexpected · Dialog (Fails)
focus.ring.width · 2 → 3 pxInherits (Passes)Inherits (Passes)Inherits (Passes)Inherits (Passes)52 snapshots · approved (Passes)
Blocked: remove the Dialog override, then mergeIllustrative example. An override that breaks inheritance is exactly what the diff is there to catch.

What you keep

A system your teams can build with. Tokens to documentation.

Tokens, components, patterns and the guidance around them, versioned and published from your own repositories.

Hand-drawn wireframes of page layouts in white lines on a deep blue ground
The partsdrawn once, reused everywhere

/handover/05-systems/

System Design

  • Interface inventory & auditSheet · Figma
  • Design tokensJSON · platform exports
  • Figma libraryFigma
  • Component package in codeYour repos · package
  • Documentation siteStorybook
  • Accessibility acceptance criteriaPer component
  • Versioning & contribution modelDocs
  • Adoption dashboardDashboard

/handover/README

In every handover

  • Decision record, with evidence linksDoc
  • Assumption tracker, final statesSheet
  • Research consent & retention logSheet
  • Walkthrough session, recordedVideo

What changes

Fix it once, see it everywhere. Three measures that prove it.

A design system pays back when screens are built from it, fixes are inherited and teams stay on the current version. Baseline, target and instrument are agreed in week one.

  1. Outcome 01

    New screens in hours

    Common surfaces assembled from components that already carry their states, their keyboard behaviour and their accessibility.

  2. Outcome 02

    One fix, everywhere

    A contrast or focus bug is fixed in the component and inherited by every product that consumes it.

  3. Outcome 03

    A system that is actually used

    Adoption measured per team, and a contribution path that makes joining in cheaper than working around it.

Outcome review · Your companyIllustrative
  • 01 Screens built from system componentsCode scan of component imports
    84%from 22%target 80%
  • 02 Fixes shipped once, inherited everywhereAccessibility fixes made in a component, not a screen
    90%from 15%target 85%
  • 03 Product teams on the current versionPackage versions across repositories
    83%from 20%target 75%
Scale 0–100 on every row; row numbers match the outcomes. Figures are illustrative examples of the measures we set, not client results.

The stack

Figma variables to shipped packages. One source, every platform.

Design, component, testing and release tools a system runs on, from the design file to the package registry. Technologies we work with, not partnerships.

  • Figma
  • Storybook
  • React
  • TypeScript
  • Tailwind CSS
  • Next.js
  • GitHub
  • GitHub Actions
  • Jest
  • Swift
  • Kotlin
  • Notion
  • Jira
  • Playwright

Frameworks we build to

Built into the component. So every screen inherits it.

Frameworks every component is built and tested to, so compliance comes with the import. Frameworks we build to, not certifications we hold.

  • WCAG 2.2 AAWeb Content Accessibility Guidelines

    Perceivable, operable, understandable and robust content, including 2.2 criteria such as focus not obscured, target size and accessible authentication.

    How we apply itContrast, focus order and target size checked in the design file, then keyboard and screen-reader passes on every key journey before sign-off.

  • Core Web VitalsLoading, interactivity and visual stability

    Good at the 75th percentile of page loads: LCP ≤ 2.5 s, INP ≤ 200 ms, CLS ≤ 0.1.

    How we apply itLCP, INP and CLS budgets written into the design spec per template, and checked at p75 in field data after release.

  • ISO 9001:2015Quality management systems

    Requirements for a quality management system built on process control, risk-based thinking and continual improvement.

    How we apply itEvery stage ends at a written gate with an owner, and design QA against the approved source before anything is called done.

Services & packages

Build it once. Use it everywhere.

Commission the foundations, the component library, the documentation or the whole system. Everything here ships in Figma and in code together, because a library that exists in only one of them drifts within a quarter.

Categories
04
Services
16
Packages
04
Not sure what you need? Describe the problem

How to buy

  1. 01Pick services. Enquire about one, or add several to a brief.
  2. 02Choose how to engage. A sprint, a fixed project or an ongoing team.
  3. 03Send the brief. We reply within one working day.

Browse by category

Timelines are typical. Every quote follows a written scope.

01Foundations

4 services
Typical timeline: 2–4 weeks

Interface inventory & audit

Every screen and component you already have, catalogued, with the duplicates and the accidental inconsistencies separated from the deliberate ones.

What’s included

  • Screenshot inventory across products
  • Component and pattern duplication report
  • Colour, type and spacing variance count
  • Scope recommendation for a first release
  • Inventory
  • Evidence

Best forOrganisations arguing about whether they need a design system.

Typical timeline: 3–6 weeks

Design tokens

Colour, type, spacing, radius, elevation and motion held once and exported to each platform, instead of copied between files and codebases.

What’s included

  • Token structure and naming convention
  • Semantic layer over the raw values
  • Exports for web, iOS and Android
  • Light, dark and high-contrast modes
  • One source
  • Multi-platform

Best forTeams where a colour change means editing five places.

Typical timeline: 4–10 weeks

Multi-brand & market theming

One component set themed for several brands, products or markets, with the differences held in tokens rather than in forked components.

What’s included

  • Theme model and inheritance rules
  • Per-brand or per-market token sets
  • Runtime theme switching
  • Contrast validation per theme
  • Themes, not forks
  • Validated

Best forGroups running several brands or markets on shared components.

Typical timeline: 2–5 weeks

Accessible foundations

Colour, focus, target size and typography set so that anything built on them starts at WCAG 2.2 AA instead of being fixed afterwards.

What’s included

  • Contrast-validated palette including states
  • Focus style that works on every surface
  • Target size and spacing rules
  • Type scale checked for zoom and reflow
  • WCAG 2.2 AA
  • By default

Best forTeams whose accessibility bugs keep coming from the same few decisions.

02Components

4 services
Typical timeline: 4–10 weeks

Figma library

The design side of the system: components with their variants and states, structured so designers assemble screens rather than redraw them.

What’s included

  • Components with variants and every state
  • Token-driven styles
  • Usage notes on the component
  • Library publishing and versioning set up
  • Figma
  • Variants & states

Best forDesign teams whose files disagree with each other.

Typical timeline: 8–16 weeks

Component library in code

The components your products actually consume: built once with keyboard behaviour and ARIA, published as a versioned package and documented.

What’s included

  • Components in React and TypeScript
  • Keyboard behaviour and ARIA per component
  • Unit, visual regression and accessibility tests
  • Versioned package with a release process
  • Versioned package
  • Tested
  • Playwright

Best forOrganisations where each product team rebuilds the same components.

Typical timeline: 4–10 weeks

Component accessibility hardening

An existing library taken through the accessibility work component by component, so every product that consumes it inherits the fix.

What’s included

  • Component-level accessibility audit
  • Keyboard, focus and ARIA fixes
  • Automated accessibility tests per component
  • Acceptance criteria written into the docs
  • WCAG 2.2 AA
  • Inherited fixes
  • Playwright

Best forTeams with a library that predates their accessibility requirement.

Typical timeline: 4–10 weeks

Patterns & page templates

The layer above components: forms, tables, filters, empty states and page templates, so common screens are a decision rather than a project.

What’s included

  • Pattern set for the journeys you repeat
  • Page templates with responsive behaviour
  • Content and validation rules for forms
  • Worked examples in the documentation
  • Patterns
  • Templates

Best forProducts with many similar screens built slightly differently.

03Documentation & governance

4 services
Typical timeline: 3–6 weeks

Documentation site

One place that shows each component live, says when to use it and when not to, and stays true because it is generated from the code.

What’s included

  • Storybook or documentation site set-up
  • Usage guidance, do and do not, per component
  • Accessibility notes and keyboard behaviour
  • Search and navigation across the system
  • Storybook
  • Live examples

Best forSystems people cannot use because nobody can find anything.

Typical timeline: 2–5 weeks

Contribution model

A path for product teams to add to the system, with review and standards, so the system grows instead of being routed around.

What’s included

  • Contribution and review process
  • Definition of done for a component
  • Request and triage workflow
  • Roles and decision rights
  • Governance
  • Open to teams

Best forSystems maintained by one team and needed by five.

Typical timeline: 2–5 weeks

Versioning & release process

Semantic versioning, changelogs, deprecation notices and a release pipeline, so consumers can upgrade on their own schedule without surprises.

What’s included

  • Semantic versioning and changelog automation
  • Deprecation policy and notice period
  • Release pipeline with automated checks
  • Migration notes and codemods where they help
  • Semver
  • Automated

Best forSystems where every upgrade breaks somebody quietly.

Typical timeline: 2–4 weeks

Design system health check

An independent read on the system you already have: what is adopted, what is bypassed, what is undocumented and what to fix first.

What’s included

  • Adoption measured across products
  • Coverage and duplication analysis
  • Interviews with consuming teams
  • Prioritised plan for the next two quarters
  • Diagnostic
  • Adoption data

Best forOrganisations with a design system nobody seems to use.

04Adoption & run

4 services
Typical timeline: 8–20 weeks

Migration & adoption programme

Getting products onto the system without stopping their roadmaps: one pilot team first, then the rest, with support at each step.

What’s included

  • Migration plan per product team
  • Pilot migration with lessons applied
  • Codemods and migration guides
  • Support through each team’s first release
  • Staged
  • Supported

Best forOrganisations with a finished system and no adoption.

Typical timeline: 2–5 weeks

Adoption measurement

A measure of how much of each product is actually built from the system, so the conversation is about numbers rather than impressions.

What’s included

  • Component usage tracking across repositories
  • Adoption dashboard per team
  • Detached and bespoke component reporting
  • Targets agreed with each team
  • Dashboard
  • Per team

Best forSystem owners asked to prove the investment is working.

Typical timeline: Ongoing · weekly

Training & office hours

Sessions for designers and engineers on using the system well, plus a standing hour each week where teams bring real problems.

What’s included

  • Onboarding sessions for design and engineering
  • Contribution walkthrough
  • Weekly office hours
  • Recorded material for new joiners
  • Training
  • Office hours

Best forTeams who have the system and still build around it.

Typical timeline: Ongoing · monthly

Design system retainer

A reserved block of time each month to maintain and extend the system: new components, upgrades, accessibility fixes and support for consuming teams.

What’s included

  • Reserved monthly capacity
  • New components and pattern requests
  • Dependency and accessibility upkeep
  • Monthly release and adoption report
  • Retainer
  • Maintained

Best forOrganisations without a permanent design system team yet.

Your brief

Tick “Add to brief” on any service, choose a package, then continue. Or enquire about one service directly.

Start a project

Ways to engage. Same team, same standard.

Three ways in, from a two-minute question to a formal RFQ. Each is read in full by the lead for the work, and anything already in your brief goes with it.

Or book a thirty-minute call

What are you sending?

  1. 01

    About 2 minutes4 required answers

    For a first conversation, a press request, or anything that does not need a scope yet.

    You get A reply from a lead, not a sales queue

  2. 02Most useful

    About 8 minutes5 short steps

    Goals, audiences, a budget band and timing. Enough for us to come back with a shape, not only questions.

    You get Options and a first scope after one call

  3. 03

    About 15 minutesYour documents attached

    Your pack, your deadlines, and the procurement and security rules the work must meet.

    You get Receipt confirmed and a named bid lead

How it is priced

Each package shows how it is priced. Every engagement starts with a written scope and a quote agreed before work begins.

  • Typical length
    4–12 weeks
    Pricing
    Fixed price
  • Typical length
    3–9 months
    Pricing
    Fixed price per milestone
  • Typical length
    Ongoing · 6-month minimum
    Pricing
    Monthly fee
  • Typical length
    Ongoing · 3-month minimum
    Pricing
    Time & materials
Compare what each package includes
What every engagement package includes, and who it suits
PackageEvery engagement includesBest for
ProjectA defined scope, delivered for a fixed price.
  • Statement of work with deliverables and acceptance criteria
  • A named project lead and a fixed team
  • A shared plan with dated checkpoints
  • Source files and IP transferred on delivery
Work you can describe up front: an identity, a system, a set of tools
MilestoneA larger build, split into gated phases you approve and pay for one at a time.
  • Phases with their own scope, output and sign-off
  • A go or no-go review at every gate
  • Re-planning between phases as you learn
  • Payment tied to accepted milestones
Programmes too big to fix in one contract, and teams that want control at each step
RetainerReserved monthly capacity to run, improve and extend what we built.
  • A reserved block of team time every month
  • Agreed response times for requests and fixes
  • A monthly review and a rolling backlog
  • Continuous improvement, not just upkeep
Brands and products after launch that need a steady team without hiring one
SquadA dedicated team working inside your stack, tools and sprint cadence.
  • Named specialists matched to your roadmap
  • Your tools, your rituals, your backlog
  • Scale the team up or down each month
  • Knowledge transfer built in from week one
Teams with a clear roadmap that need more senior hands, fast

Questions

Asked before the audit starts.

Anything else goes straight to the people who would do the work.

Ask a question
Q01How is this different from Brand Systems in Brand Design?

Brand Systems governs how the brand behaves across every channel: expression, rules, assets and tone. System Design is the product’s structural layer: tokens, components, states and versioning, in design and in code. The brand system sets the constants; this consumes them and makes them buildable.

Q02Do we need a design system at our size?

If one team ships one product, probably not yet, and a small kit of patterns is enough. It earns its cost once several teams or several surfaces have to look and behave the same, or when the same accessibility fix keeps being made in more than one place.

Q03Figma library or code package?

Both, or it is not a system. A Figma library on its own drifts from production within a quarter. The token set is the contract between them, exported to each platform from one source.

Q04Which framework do you build components in?

Usually React with TypeScript, with tokens exported for iOS and Android. Web components are an option when several frameworks have to consume the same library. The choice follows your products, not our preference.

Q05Who maintains the system afterwards?

Your team, with a named owner, a contribution path and documentation, or ours on a retainer while the in-house team forms. Either way the versioning, release and deprecation process is part of the handover.

Let’s build what happens next.

Tell us what you’re building. We’ll answer straight.

Book a discovery call

Three ways to start

Every engagement starts with a written scope and a quote agreed before work begins.

Choose one of the three ways above