UI/UX design and design systems
Design is the cheapest place to be wrong. A misunderstanding caught in a wireframe costs an afternoon. The same misunderstanding caught after it is built costs a sprint, and after launch it costs a migration.
What design is actually deciding
Not what the buttons look like. Design decides what the objects in your system are, what a user can do to them, and in what order — which means it is deciding the data model too, whether or not anybody says so out loud. When design and the data model are worked out separately, one of them is wrong, and the discovery happens in the build.
That is why we design screens and model data in the same room. A screen that needs six joins to render is not a front-end problem; it is the model telling you something. A form with eleven required fields is not a layout problem; it is a process telling you something.
Design systems, and when to build one
A design system is worth building when you have more than one product surface, or more than one person building screens, or an expectation of both. Below that it is overhead. Above it, its absence is the reason your product ends up with forty-four slightly different buttons and a redesign in eighteen months.
What we build is a token layer — colour, type, space, radius, elevation — then a set of primitives, then patterns. Tokens first, because they are what makes a theme change or an accessibility fix a one-line edit rather than a two-week audit. And the system ships as code that the product actually imports, not as a library file that drifts out of sync with production within a quarter.
Research, at a proportionate size
Five users will show you most of the serious usability problems in a flow. Fifty will show you slightly more, three weeks later, for ten times the money. For most engagements the right amount of research is small, fast and repeated rather than large and one-off.
What we insist on is talking to the people who will actually use the thing, not only the people commissioning it. Those two groups describe different systems, and the gap between their descriptions is usually where the project’s real risk is sitting.
Accessibility is a design decision
Most accessibility failures are decided in design and merely implemented in code: contrast that does not pass, a colour-only status indicator, a focus order that follows the visual layout rather than the reading order, a control that only responds to hover. Fixing those after the fact means revisiting design anyway.
So we check contrast when we choose colours, define focus states as part of every component, and specify keyboard behaviour alongside pointer behaviour. WCAG 2.2 AA is the working target, and the design file carries the annotations that make it buildable.
What this actually covers
Product design
Flows, screens and states — including the empty, loading and error states that decide whether a product feels finished.
Design systems
Tokens, primitives and patterns, shipped as code the product imports rather than as a file that drifts.
UX research
Small, fast, repeated sessions with the people who will actually use it — not only with the people commissioning it.
Information architecture
What the objects are, how they nest, and what the navigation has to be for that structure to be findable.
Design-to-code handover
Annotated components with states, breakpoints and keyboard behaviour specified — not a flat image and a conversation.
Accessibility by design
Contrast, focus order and keyboard paths decided while choosing, not audited afterwards. WCAG 2.2 AA as the target.
The sequence
Same shape on every engagement, so you always know what week you are in and what happens next.
Understand the objects
What things exist in this system, what states they have, and who is allowed to move them between states. Design and data model together, in the same room.
Structure before surface
Information architecture and flows agreed as low-fidelity work, where changing your mind is free. Visual design comes after the structure stops moving.
System, then screens
Tokens and primitives first, screens assembled from them second. Doing it the other way round produces a component library by accident.
Test with five people
A short round of usability testing on the prototype, then the changes it implies. Repeated at the next milestone rather than done once at the end.
Handed over, in your accounts
Not a demo and a login. These are the artefacts you keep, and they are what makes leaving us possible.
- Flows and screens covering the empty, loading, error and permission-denied states
- A token set — colour, type, space, radius, elevation — with contrast ratios documented
- A component library in code, imported by the product itself
- Annotated handover: breakpoints, interaction states and keyboard behaviour per component
- Research findings written up with the specific design changes they imply
- The source files, in your workspace, under your account
Typically built with
- Figma
- Design tokens
- Storybook
- React
- CSS
- axe-core
- Maze
The selection principle is deliberately dull: largest hiring pool, longest support window. See why we choose these.
UI/UX Design, answered
The things people ask on the first call, written down so you do not have to.
Do we need a design system, or just screens?
A design system pays for itself when you have more than one product surface, more than one person building screens, or a reasonable expectation of both within a year. Below that threshold it is overhead you do not need and we will say so. Above it, its absence is exactly why products end up with forty-four slightly different buttons and a redesign eighteen months later. The middle path we often recommend is a token layer plus a dozen primitives — most of the benefit, a fraction of the effort.
Can you redesign our existing product?
Yes, and the first question is whether the problem is actually visual. Quite often a product that "looks dated" is really suffering from an information architecture problem — the objects are named confusingly or nested wrongly — and a fresh coat of paint over that structure will not help. We start with a short assessment covering both, and tell you which one is costing you more.
How do you hand designs over to developers?
Annotated components rather than flat images. Each component carries its states, its breakpoint behaviour, its keyboard interaction and its focus treatment, and the token values are named rather than described as hex codes. Where we are also building the product, the design system ships as code the application imports, which removes the handover gap entirely. Where another team is building it, we stay available for review during the build, because that is when the questions actually arise.
How much user research do you do?
Proportionate, and usually less than agencies propose. Five participants surface most of the serious usability problems in a flow; fifty surface slightly more, three weeks later, for ten times the cost. We prefer small rounds repeated at milestones over one large study at the start. The non-negotiable part is talking to the people who will actually use the software rather than only to the people commissioning it — those two groups describe different systems, and the gap between them is usually where the project risk is hiding.
What usually comes with this
- BuildWeb Application DevelopmentDashboards, portals and internal tools that hold up under real data volumes — not a prototype that falls over at ten thousand rows.Read more
- BuildCustom Software DevelopmentCustom platforms, marketplaces and SaaS. We write the parts that are specific to your business and buy the parts that aren’t.Read more
- BuildMobile App DevelopmentReact Native when one codebase is genuinely enough. Native when it isn’t — and we will tell you which before you commit a budget.Read more
- RunQA & Software TestingAutomated regression suites where they pay for themselves, and exploratory testing where they don’t. We tell you which is which.Read more
Thinking about ui/ux design?
Start with a call rather than a brief. Thirty minutes, no deck, and an honest answer about whether we are the right people for it.

