Omegaswift
Solutions

UI & UX Design

Design that gets used rather than admired. We work out what the job actually is, draw the flows around it, and hand over a system your developers can build from without guessing.

How We Help

What ui & ux design looks like as a piece of work.

Pretty Is Not The Problem You Have

Almost nobody comes to us because their software is ugly. They come because a form gets abandoned two thirds of the way through, because support answers the same question every day, because the team has quietly built a spreadsheet to do the thing the software was bought for. Those are design problems, and none of them is solved by a restyle. So the first work is finding out what the job actually is: watching somebody do it, counting the steps, and asking what they do when the system will not let them. That routinely produces a smaller product than the one that was specified, which is the point. The cheapest screen to design is the one you establish nobody needs.

Design Against Real Content

Placeholder text is the most expensive shortcut in this discipline. A card designed around a two word title falls apart when the real one runs to nine, and it always runs to nine: somewhere in your data there is a customer whose company name is a sentence. So we design against the actual content early: your longest product name, an empty state on a new account, an error the user cannot fix themselves, a list with three items and the same list with eight hundred. Those four cases catch more defects than any amount of polishing the happy path, and they are the ones a specification never mentions because everyone imagines the middle of the range.

A System, Not A Set Of Pictures

A folder of screens is a description of one moment. What a team needs is the rules underneath: the type scale and what each step is for, the spacing steps and when to use which, the colour roles rather than a palette, the components with every state drawn: hover, focus, disabled, loading, error, empty. The states are the half that gets skipped and the half that costs the most later, because a developer who has not been given the error state will invent one, and each one they invent will be different. Handover is the system plus the reasoning, so the next decision your team makes without us is consistent with the ones we made together.

Accessible Because It Was Designed That Way

Accessibility is decided in design and blamed on engineering. A colour pair that fails contrast, a control identified only by colour, a flow that cannot be completed on a keyboard, an interaction that depends on hover: those are all choices made before a line of code exists, and each one is expensive to correct once it is built into a component every screen uses. We check contrast on the palette rather than on the screen, define the focus order with the flow, name every control in text rather than in an icon alone, and design the reduced-motion version of anything that moves. It is also worth saying plainly that this overlaps almost entirely with what makes software usable in bright sunlight on an old phone by somebody in a hurry.

Design That Ships Is The Only Kind That Counts

The most common failure in this work is not a bad design, it is a good design that never survives contact with the build. It happens when design finishes and throws the result over a wall: developers hit a case that was not drawn, make a reasonable decision, and the product drifts a little further from the intent with each one. So we stay in it. Components are reviewed as they are built, not as they were drawn. Someone is available for the question that starts with what should happen if. And the design file is updated when the build teaches us something, rather than being left as a record of what everybody meant in March. If your team would rather own it after handover, the system is documented for exactly that.

What we build

The shapes ui & ux design work actually takes

  • Discovery and research

    Watching people do the job the software is supposed to help with. Usually produces a smaller product than the one specified, which is the most valuable thing it can do.

  • Flows and prototypes

    Clickable flows in front of real users before anything is built. This round is meant to change the plan; if it does not, it was run too late.

  • Interface design

    The screens themselves, drawn against your real content: longest names, empty states, errors a user cannot fix, and lists at both extremes of length.

  • Design systems

    Type scale, spacing steps, colour roles and components with every state drawn. The states are the half that gets skipped and the half that costs most later.

  • Accessibility

    Contrast on the palette, focus order with the flow, controls named in text, and a reduced-motion version of anything that moves. Designed in, not audited after.

  • Redesigns

    Software people already use, where the risk is different: you are changing something they have learned, so the work is knowing what not to touch.

How we work

How a ui & ux design engagement runs

  1. 01

    Watch the job

    Somebody doing the actual work, with the actual data, including the workaround they have built outside the system. That workaround is the brief.

  2. 02

    Draw the flow

    The path through the task before any screen is styled. Cheapest possible place to discover that two steps can become one, or that one of them belongs to a different team.

  3. 03

    Test it early

    A clickable prototype with real users. Five people will find most of what is wrong, and finding it here costs a day rather than a release.

  4. 04

    Build the system

    Components, states and rules rather than a folder of screens, so the twentieth screen your team makes without us still looks like the first.

  5. 05

    Stay through the build

    Reviewing components as they are made and answering the cases nobody drew. Design that stops at handover drifts, quietly, one reasonable decision at a time.

Who it is for

You probably need this if

  • People have built a spreadsheet to avoid it

    The clearest signal there is. Somebody is doing the job outside the system you paid for, and what they built is a specification for what it should have done.

  • The form gets abandoned two thirds through

    You have the analytics and no explanation. That is a flow problem and it is findable in an afternoon of watching five people attempt it.

  • Every screen looks slightly different

    Which means there is no system, only screens, and each new one is a fresh set of decisions made by whoever is free that week.

  • Accessibility came back as a list

    Usually after a procurement questionnaire or a complaint. Most of what is on that list was decided in design and is cheapest to fix there.

FAQ

Questions we get asked

We already have a brand. Do you need to redesign it?

No, and we would rather not. A brand and an interface are different jobs: a brand is built to be recognised across a poster, a business card and an app icon, and an interface is built to be operated for eight hours. We take your brand and work out what it means in a product context: which of your colours can carry text and which cannot, what the type scale becomes at 13px, how the logo behaves in a 48px header. Where something genuinely does not survive that translation we will tell you and propose the smallest possible change rather than a rebrand.

How much research do we actually need?

Less than agencies sell and more than teams want. Five people doing the real task in front of you will surface most of what is wrong with a flow, and that is a day of work rather than a phase. What justifies more is a domain nobody on the team has lived in, clinical, regulated, industrial, where the risk is not that the design is unclear but that it is confidently wrong about how the job is done. We scope research against that risk rather than by default, and we would rather do one honest day than four weeks of interviews that produce a deck.

Do you hand over Figma files, or something developers can build from?

Both, and the second is the one that matters. A file full of screens is a description of one moment. What a team builds from is the system underneath it: named type and spacing steps, colour roles rather than a palette, components with every state drawn, and the rules for when to use which. We also write down the reasoning, because the next decision your team makes without us is only consistent if they know why the last one went the way it did.

Can you work with our existing developers?

Yes, and it produces a better result than designing at them. Our designers work in your review process, look at components as they are built rather than as they were drawn, and are available for the question that starts with what should happen if. The alternative, design finishes, throws the file over a wall, and moves on, is how a good design becomes an average product, one reasonable developer decision at a time.

How do you handle design for an existing product people already use?

More carefully than a new one, because you are changing something they have learned. The failure mode of a redesign is not that it looks worse, it is that it costs your most experienced users their muscle memory and they tell you so loudly. So we find out what people actually rely on before touching it, change the things that are genuinely broken, leave the things that are merely dated, and where a change is large we ship it to a slice of accounts first. Sometimes the honest recommendation is a smaller redesign than the one that was requested.

What do you need from us to start?

Access to somebody who does the job, and real data. Those two, in that order, are worth more than any brief. Beyond that: whatever you have on how people currently use it, the questions support answers most often, and the list of things everybody already knows are wrong. We do not need a finished specification: if you have one, it is useful, and part of our job is to find out which parts of it survive contact with a user.

Will this make the product accessible enough to pass a procurement questionnaire?

It gets you most of the way, and the remaining distance is engineering rather than design. What design decides is contrast, focus order, whether controls are identified by more than colour, whether flows can be completed by keyboard, and whether anything depends on hover. What engineering decides is the semantics: real headings, real labels, correct roles, and what a screen reader announces when something changes on the page. We do our half properly and tell you plainly what the other half involves, rather than implying a design pass makes a product compliant.

How long does design take?

The drawing is rarely what sets the date. A design phase waits on the same things a build does: access to users, decisions from people who are busy, and content that somebody has to write. A contained flow is a matter of weeks. A system for a product with many screen types takes longer and pays for itself the moment your team builds the twentieth screen without asking us anything. We give you a date against a written scope and tell you which parts of it depend on you rather than on us.

What you get

What is different once the ui & ux design work is done

  • Flows tested with real users before the screens are built, not after
  • A component library your developers build from, with the states drawn
  • Screens checked against your longest real content, not against placeholder
  • Contrast, focus order and keyboard paths verified as part of the design

Ready to talk about your IT?

We are happy to answer any questions you have and help you work out which of our services fit your needs.