Spend an hour with a product design team and you’ll hear a lot of words that sound like English but aren’t quite. This is our dictionary. It’s written for people who are new to all this: founders, marketers, project managers, or anyone about to work with a studio like ours for the first time. No word is explained using another word you’d need to look up.
You don’t need to learn all of it. Skim to the section you need.
Research: finding out what people need
User research. Talking to and watching the people who will use what you’re making, before and while you make it. The aim is to replace guesses with evidence.
User interview. A one-to-one conversation, usually 30 to 60 minutes, about how someone does a task today and what gets in their way. Good interviews ask about what people actually did (“tell me about the last time…”), not what they think they’d do.
Discovery. The first phase of a project, where the team works out what problem it’s really solving, for whom, and what success looks like. We’ve written about what a good discovery session looks like.
Persona. A short profile of a typical user, built from research: their goals, frustrations and context. Useful as a shared reminder of who you’re designing for, as long as it’s based on real people rather than invented.
Journey map. A picture of every step someone takes to get something done (say, renewing their car insurance), including what they think and feel at each step. It shows where the pain points are.
Pain point. A moment where something is confusing, slow or annoying for the user. Finding these is most of the point of research.
Insight. Something you learned from research that changes what you’ll do. “People abandon checkout when they see the delivery cost” is an insight; “people like cheap delivery” isn’t.
Design: shaping the thing
UX (user experience). How it feels to use a product: whether people can do what they came to do, easily, without getting lost or annoyed.
UI (user interface). What people actually see and touch: the screens, buttons, text and layout. UX is whether the journey works; UI is what each stop looks like. More in our guide to design disciplines.
Information architecture (IA). How content is organised and labelled, so people can find things. A site’s menu is the most visible part of its IA.
User flow. The path someone takes through screens to finish a task, such as sign up, choose a plan, pay.
Wireframe. A rough, usually grey sketch of a screen that shows what goes where, without colour or final wording. Cheap to make and cheap to throw away, which is the point.
Mockup. A detailed, realistic picture of a screen, with real colours, fonts and images. It looks finished but doesn’t do anything when you click it.
Prototype. A clickable version of a design you can try out as if it were real. It might be screens linked together in Figma, or real code with pretend data behind it. A prototype exists to answer questions before you pay to build the real thing. See from idea to interactive prototype.
Fidelity (low-fi, high-fi). How close something is to the finished product. A paper sketch is low fidelity; a prototype that looks and behaves like the real app is high fidelity.
MVP (minimum viable product). The smallest version of a product that’s useful enough to learn from real users. It’s often misunderstood as “a cheap, rushed version”, which it shouldn’t be.
Accessibility. Making sure people can use a product whatever their abilities: with a screen reader, with only a keyboard, with low vision, or with a shaky hand on a bus. Read why it isn’t a checklist.
WCAG. The Web Content Accessibility Guidelines, the international standard for accessibility. “WCAG 2.2 AA” is the level most organisations aim for, and the one we build to. Which laws apply in the UK is covered in website accessibility law.
Testing: checking it works for people
Usability testing. Watching real people try to do real tasks with your design, while you stay quiet and take notes. Five people will usually find most of the big problems. Here’s how to run one.
Moderated and unmoderated. Moderated testing has a researcher with the participant (in the room or on a video call). Unmoderated testing uses a tool that records people doing tasks on their own.
A/B test. Showing two versions of something to different groups of real users at the same time, to see which one performs better. It needs a lot of traffic to be trustworthy.
Iteration. Making something, testing it, improving it, and repeating. Most good products are the result of many small iterations, not one big reveal.
Process: how the work is organised
Brief. A short document describing what you want, why, for whom, and any limits like budget or deadline. Here’s how to write a good one.
Scope. What’s included in a piece of work, and just as importantly, what isn’t. “Scope creep” is when more gets added along the way without the time or budget changing.
Agile. A way of working in short cycles, delivering something usable often and adjusting as you learn, instead of planning everything up front.
Sprint. One of those short cycles, usually one or two weeks, with an agreed set of things to finish.
Stakeholder. Anyone with a say in, or affected by, the project: the client, their boss, the legal team, customer support.
Handoff. The moment designs pass from designers to developers to build. In a good team it’s a conversation that runs through the project, not a single moment. See what a good handoff looks like.
Figma: where most design happens
Figma. The tool most product teams use to design screens. It runs in a web browser, and several people can work in the same file at once, like Google Docs for design.
Frame. A container on the Figma canvas, usually the size of a phone or laptop screen. Each screen in a design is a frame.
Auto layout. A Figma setting that makes things arrange and resize themselves, the way they will in code. Add a word to a button and the button grows.
Component (in Figma). A reusable design element, like a button. You design it once; every copy (called an instance) updates when the original changes.
Variant. A version of a component, such as a button that’s primary or secondary, large or small, enabled or disabled.
Variables. Figma’s name for stored values like colours and spacing that designs can refer to. They’re Figma’s version of design tokens (see below).
Library. A Figma file of shared components and styles that other files can use, so every designer works from the same parts.
Dev Mode. A view in Figma for developers, showing sizes, colours and code snippets for whatever they select.
Building: words from the developers
Front end and back end. The front end is everything that runs in your browser: what you see and click. The back end runs on a server: storing data, sending emails, taking payments.
Repository (repo). The folder that holds all of a project’s code and its full history of changes.
Git. The tool that keeps that history. It records every change, who made it and why, and lets you go back to any earlier version.
GitHub. A website that stores repositories online so a team can share them, review each other’s changes and run automatic jobs, like publishing the site when code changes.
The handful of Git commands you’ll hear most
| Command | What it does, in plain English |
|---|---|
git clone |
Download a copy of a repository to your computer |
git status |
Show what you’ve changed since your last save point |
git add |
Choose which changes go into your next save point |
git commit |
Make the save point, with a short note saying what changed |
git push |
Send your save points up to GitHub |
git pull |
Bring down everyone else’s latest changes |
git branch |
Start a separate line of work, so you can try things without affecting the main version |
git merge |
Join a finished branch back into the main version |
Commit. One saved change, with a message explaining it. The history of a project is a list of commits.
Branch. A separate copy of the code where you can work on something new without disturbing the live version.
Pull request (PR). A request to merge a branch, which lets teammates review the changes and comment before they go live.
Deploy. Publishing the latest version so the public can see it.
Staging. A private copy of the live site where changes are checked before they’re deployed for real.
Astro. The tool we use to build websites, including this one. You write pages from reusable pieces, and Astro turns them into plain, fast web pages with very little JavaScript, so they load quickly. More in how we built this site.
Static site. A website whose pages are made in advance, when the site is built, rather than every time someone visits. Static sites are fast, cheap to host and hard to break.
Tailwind. A way of styling web pages by adding short, ready-made class names straight onto the HTML, like p-4 for padding or text-lg for larger text. It keeps styling consistent and close to the thing being styled.
CMS (content management system). Software that lets non-developers edit a website’s words and pictures without touching code. Ours is Somnia CMS. We compare the options in Ready-made platform or custom-built site?.
Responsive. A design that adapts to any screen size, from a phone to a wide monitor.
Design systems: the shared kit
Design system. Everything a team needs to design and build a product consistently: the rules, the reusable parts and the guidance on when to use what. A bit like a recipe book plus a stocked kitchen. Our longer explainer is what’s in a design system, and our own one, Somnia DS, is published in full.
Design token. A single design decision, given a name and stored in one place. For example, “the main brand colour is this exact shade of blue” or “medium spacing is 16 pixels”. Designers and developers both use the name, never the raw value, so changing the token changes it everywhere at once. More in what is a design token?
Primitive token. The raw ingredients: every colour, size and font the brand has, named plainly. blue-600 is a primitive. Primitives say what a value is, not what it’s for.
Semantic token. A token named for its job, which points at a primitive. color-action-primary (the colour of main buttons) might point at blue-600. Components only ever use semantic tokens. That’s what makes dark mode or a second brand possible: you point the same semantic names at different primitives, and every screen updates. You can watch this happen in the Somnia DS theme builder.
Component. A reusable part of the interface, such as a button, a form field, a card or a menu. It’s built once, from tokens, with every state worked out: normal, hover, focused, disabled, error, loading.
Pattern. A tried-and-tested way of combining components to solve a common problem, like a sign-up form with helpful error messages.
Theme. A set of token values that changes the look without changing the components: light and dark mode, or a different brand.
Documentation. The written guidance that explains what each part is for, when to use it, when not to, and how to make it accessible. Without it, a design system is just a parts bin.
Governance. The agreed way the system changes over time: who can suggest a new component, who reviews it, and how teams find out what changed.
How it all fits together
Think of it in layers, each built from the one before:
- Primitive tokens: the raw palette and scales.
- Semantic tokens: those values given jobs.
- Components: built only from semantic tokens.
- Patterns and templates: components arranged to solve real problems.
- Products: the actual apps and websites people use.
Change something low down, like the brand colour, and it flows up through every layer automatically. That’s the whole trick, and it’s why a design system saves so much time once it’s in place.
What happens when it’s finished
A design system is never really finished, but once it’s up and running, here’s how people use it day to day:
- Designers work in Figma using the system’s shared library. They drag in ready-made components and pick from token-based colours and spacing, so their designs match what can be built.
- Developers install the system’s code into their project and use the same components, often by name: a
<Button>in code is the same thing as the Button in Figma. - Storybook (or a documentation site like Somnia DS) is the shop window: a website showing every component in every state, so anyone can look, test and copy the code without opening the product.
- Live coded prototypes are quick versions of new ideas built from the real components. Because the parts are real, a prototype looks and behaves like the finished product, and nothing has to be rebuilt when the idea is approved.
- Raw code: the tokens themselves are exported as files (CSS, JSON, or formats for iOS and Android), so every platform shares the same decisions.
The payoff is that nobody starts from a blank page, and every team’s work looks and behaves like it belongs to the same product.
Still stuck on a word?
If someone on your project uses a term that isn’t here, ask them. Any good studio will happily explain, and if they can’t put it in plain English, that’s worth knowing too. Or get in touch and we’ll explain it, and add it here.
← Back to all insights