AmwerahSolutions
Grow · Services

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.

Capabilities

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.

How it runs

The sequence

Same shape on every engagement, so you always know what week you are in and what happens next.

  1. 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.

  2. 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.

  3. System, then screens

    Tokens and primitives first, screens assembled from them second. Doing it the other way round produces a component library by accident.

  4. 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.

What you get

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.

Questions

UI/UX Design, answered

The things people ask on the first call, written down so you do not have to.

All twenty questions
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.

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.