UI/UX Designer Interview Questions

"I'll take the appointment booking flow I redesigned for a small clinic group. Patients were phoning the front desk because the online form kept failing them, and the desk staff were overloaded. I was the only designer, working with a product manager and two developers. I started by watching five patients try to book, and the big problem was that they had to pick a doctor before seeing any free times. So I flipped it: show the next free slots first, then let people filter by doctor if they cared. I tested two versions in a clickable prototype and the slot-first one won clearly. After launch, phone bookings dropped noticeably and the desk team stopped complaining. If I did it again, I'd agree on the success measure with the team before starting, not after."

"I studied graphic design, so I came in through the visual side. In my final year I built a small app for a college club, and when I watched people use it, they got stuck on things I thought were obvious. That was the moment I got hooked on the UX side, because the pretty screens didn't matter if people couldn't finish the task. Since then I've done two internships and some freelance work, mostly on forms and sign-up flows. The problems I enjoy most are messy flows with lots of steps, where a clear structure and good wording can save people real time. This role appeals to me because your product has exactly that kind of complexity."

"I try to spend most of my learning time on things that don't go out of date, like typography, research methods and accessibility. Last year I worked through the accessibility guidelines properly and started testing my own designs with a screen reader, which changed how I annotate handoffs. I also like studying real products: when an app does something well, I take screenshots and try to work out why it works. Trends and new tools are fine, and I try new tools when they come up, but I ask one question before adopting a trend: does it make the task easier for users, or does it just look fresh? Glass effects that hurt contrast, for example, usually fail that test."

"I signed up and went through your onboarding. The step that stood out was the workspace setup screen, which asks for six things before I've seen any value. I got through it, but I suspect some people leave there. I'd want to try asking only for the name up front and collecting the rest later, when it's actually needed. But I'm guessing from one run through, and there may be a reason those fields are there, maybe billing or compliance. So before changing anything, I'd look at where people drop off in that flow, talk to someone on the team about why each field exists, and watch a few new users go through it. If the drop-off isn't there, I'd happily be wrong."

"Day to day I work in one of the main collaborative design tools, for everything from wireframes to final screens and clickable prototypes. I'm comfortable building shared components with their variants, using styles instead of one-off colours, and keeping files organised so a developer can find things without asking me. For research I've used an online whiteboard for sorting notes and a remote testing tool for unmoderated tests. If your team uses something different, I'm not worried, because the ideas carry over: layers, components, constraints and prototype links work much the same everywhere. When I switched tools at my last job, I rebuilt one real screen from our product in the new tool during my first week, learned the shortcuts I use most, and asked a teammate to review how I'd set up the file. I was back to normal speed within a couple of weeks."

"I was asked to redesign a scheduling tool for a logistics team, and I didn't know anything about how loads get planned. My first week, I sat with two planners and watched them work, and I kept a list of every term I didn't know. That glossary saved me later. I learned they cared about exceptions far more than the normal case, because the normal loads just ran themselves. My first sketches were a tidy calendar, which was the wrong idea. I ended up designing a view that pulled the problem loads to the top with the reason for each one. I tested it with the planners every week, and they caught a few things I'd misunderstood before any code was written."

"We had four weeks to launch a returns flow before a busy sales season, and the full design had about eight features. I sat down with the product manager and a developer and we ranked every piece by two things: does a customer need it to finish a return, and how long will it take to build. Starting a return, choosing a reason, and printing a label were must-haves. Photo uploads, exchange suggestions and a nice tracking screen could wait. We kept the tracking to a simple status line instead. It shipped on time, and the support team told us the main complaint was gone. The dropped pieces went into the next quarter's plan, and two of them turned out not to be needed at all."

"Before designing anything, I'd go back to whoever wrote the brief and ask what 'better' means to them. Is the problem that people drop out during sign-up, that they sign up but never use the main feature, or that support gets too many setup questions? Each one leads to a different design. Then I'd look at the numbers for each step of onboarding to see where people actually leave, and I'd watch a few new users go through it. Once I know the real problem, I'd agree on one measure with the team, for example how many new users complete their first task in the first week. Only then would I start sketching ideas."

"UX is about the whole experience: does the product solve the right problem, and can people get through the task without confusion? That covers research, structure, flows and wording. UI is the part people actually see and touch, like the layout, typography, colour, buttons and how each element reacts when you tap it. They overlap all the time. A checkout can have a sensible flow, but if the pay button looks like a secondary link, people miss it, and that's a UI choice creating a UX problem. And a beautiful screen can't save a flow with too many steps. I see them as one job with two zoom levels."

"I start by understanding the problem: talking to the product manager, looking at data, and speaking to users if we can. Then I write down what success looks like. Next I explore, usually quick sketches or low-fidelity wireframes with a few different directions, because the first idea is rarely the best. I pick one or two, build a clickable prototype, and test it with users. After that I refine, add all the states and details, and hand it off, then stay involved while it's built and check the results after launch. I don't run every step every time. A small fix to a known screen might go straight to a design review, while a brand new feature gets the full process."

"I use low-fidelity wireframes early, when I'm working out what goes on a screen and in what order. They're quick, so I can try several layouts and throw most away, and people give feedback on the structure instead of arguing about colours. When the question becomes 'can people get through this flow,' I build a clickable prototype, because you can't test a multi-step task with static screens. The prototype can still be fairly rough if I'm testing the flow. I'd only make it high fidelity when details matter, like testing whether people notice a subtle message or trust a payment screen. Going polished too early is a trap, because everyone assumes the design is almost finished."

"At my last company I was sure we needed a dashboard with charts on the home screen of our expense app. I'd designed a nice version and was proud of it. When we tested it with six finance staff, almost nobody looked at the charts. What they all did was hunt for the list of expenses waiting for their approval. One person said, 'I only open this app when something's waiting for me.' So I moved the approval queue to the top and pushed the charts to a separate page. In the next round, people found their pending items in seconds. The lesson for me was to test the rough idea earlier, before I'd polished it and got attached."

"I wouldn't fight for a month-long study, because that's not realistic. First I'd ask what we're least sure about. If it's a small change to a well-understood flow, maybe we don't need new research at all. If it's something new, I'd suggest a quick version: pull what we already know from support tickets and analytics in a day, then do five short calls with users, or test rough sketches in the same week. I can work on screens in parallel, so it doesn't slow anyone down. And I'd agree with the team that we test the real thing soon after launch. The point I'd make is that fixing a wrong idea after it's built costs far more than a few days of checking."

"I start with what we need to learn, then pick the method. If we don't understand the users yet, their goals, frustrations or how they do things today, I'd use interviews, because I can follow up and dig into the why. If I already have ideas and need to know how common something is, like which problems affect the most people, a survey works, because it reaches many people quickly, though it can't tell me much about why. If there's a design, even a rough one, and I want to know if people can use it, I'd run usability tests where they try real tasks. I often combine them: interviews to find the problems, a survey to size them, and testing to check the solution."

"A useful persona comes from real research and describes behaviour: what the person is trying to get done, what gets in their way, and how they make decisions. The useless kind has a stock photo, an age, and a list of hobbies nobody ever uses. I'd rather have two or three personas that genuinely differ in their needs than many that blur together. A journey map is useful when it shows the steps someone goes through, what they're doing and feeling at each step, and where things break, including steps outside our product, like calling support. The real test is whether the team uses them. If a product manager says 'this won't work for the busy manager,' the persona is doing its job."

"I'd start with a content audit, listing what's there, what's outdated, and what people actually search for, using site search terms and analytics. Often a lot can be merged or removed. Then I'd run a card sort, where users group content cards in a way that makes sense to them. An open sort, where they name the groups themselves, shows their mental model and their words. From that I'd draft a structure, usually keeping the top level short and using labels users recognise, not internal team names. Then I'd tree test it: users get a text-only version of the menu and tasks like 'where would you find the return policy.' That shows whether the structure works before any visual design hides the problems."

"We launched a new search page and the empty state was just a blank white area with nothing in it. I'd designed the main results beautifully but never designed what happens when there are no results, or when the search fails. The developer had to guess, so they left it blank. That was on me, not them. We fixed it within a week with a proper message and suggestions. After that, I started using a checklist for every screen: empty, loading, error, very long text, and no permission. I also asked to review builds on a test server before release, which caught a lot of small spacing and wording differences early."

"On a food delivery app, our product manager wanted a large promotional banner at the top of the restaurant list, because marketing had a campaign to push. I thought it would shove the restaurants below the fold on smaller phones, and people open that screen to choose food quickly. Instead of trading opinions, I asked what the campaign actually needed. It was mainly awareness of a new loyalty scheme. So I mocked up two versions: the big banner, and a slim card placed after the first few restaurants. We showed both to a handful of users and watched how quickly they picked a restaurant and whether they noticed the offer. The slim card didn't slow anyone down and still got noticed. The product manager agreed, and marketing liked that the card could rotate messages. What I took from it is to argue about the goal, not the pixels."

"I'd start by asking questions, not defending the design. Something like, 'When you look at it, what's the first thing you want people to notice?' Often 'make it pop' really means 'the main action doesn't stand out' or 'it feels too plain for our brand.' Once I know which, I can do something specific. If it's the main action, I'd strengthen the visual hierarchy, maybe more contrast or more space around the button. If it's brand feel, I'd bring two or three quick variations with more colour or imagery. I'd also remind everyone of what we tested, so we don't break what works. Most of the time, the leader has a real point hidden in vague words, and finding it is my job."

"I'd take the goal seriously, because keeping customers matters, but I'd push back on the method. Hiding the cancel option is a dark pattern. People who can't find it don't stay happy, they dispute the charge, complain publicly, or never come back. In some places, consumer rules also expect cancelling to be about as easy as signing up, so it could be a legal risk too. Instead, I'd suggest a clear cancel flow that asks one quick question about why they're leaving, then offers something relevant, like pausing the plan or switching to a cheaper one. We'd learn why people leave, which is the real problem. I'd propose we measure how many people take the offer, and compare over a few months."

"The main screens are the easy part. What developers really need is everything around them. So I include every state: empty, loading, error, success, disabled, and what happens when a name is really long or a list has hundreds of items. I show how the layout changes on small and large screens, and describe interactions like what happens after you tap save and where the focus goes. I use design system components and tokens wherever possible, so developers can reuse existing code, and I call out anything new. I also add accessibility notes. But the most useful part is a short walkthrough with the developers before they start, because their questions always show me something I missed."

"When I present, I start with the goal, how far along the work is, and what kind of feedback I need, so people don't spend twenty minutes on colours when I'm asking about the flow. When I get criticism, I try not to explain every decision straight away. I write it down and ask questions to understand it, then decide later what to act on. When I give critique, I link it to the goal or the user, like 'I'm worried a first-time user won't know this is tappable,' instead of 'I don't like this.' I also try to say what's working, because that's useful information too. The best teams I've worked in treat critique as a normal part of the job, not an attack."

"We redesigned the password reset flow because support was getting a lot of 'I'm locked out' tickets. Before we started, we agreed on two measures: how many people who start a reset actually finish it, and how many lockout tickets reach support each week. We had a few months of history for both. The new flow sent a code instead of a link and explained each step. We released it to half the users first, so we could compare the two groups side by side. Completion went up clearly in the new group, and lockout tickets fell over the next month. The data also showed one thing we missed: lots of people waited too long and the code expired, so we lengthened the expiry time in a follow-up."

"I wouldn't pick one straight away, because they answer different questions. Analytics tell me what thousands of people actually do, and a usability test tells me why a few people struggle. If they disagree, something's usually different about who or what they measured. So I'd check both. Was the test task realistic, and were the participants like our real users? Is the tracking correct, and is the analytics number dominated by one group, like returning users who already know the product? Very often the test was with new users and the analytics are mostly regulars. Then both are true, just for different people. If it's still unclear, I'd run a small experiment on the live product to settle it."

"First, I'd break the checkout into steps and look at where people leave, split by device and by new versus returning customers. If most drop-off is on mobile at the payment step, that's a very different problem from people leaving when they see shipping costs. Then I'd find out why, by watching recordings, testing with a few people, and checking error logs and support tickets. Common causes are surprise costs appearing late, being forced to create an account, long forms, few payment options, and errors that wipe what you typed. So likely fixes are showing the full cost early, offering guest checkout, cutting fields and using autofill, and clear inline errors. I'd test the changes against the current version and track completion rate, plus refunds and order value, so we don't just move the problem."

"On a sign-up form I worked on, the error messages were shown only by turning the field border red. I tried the form with just the keyboard and a screen reader, and two things were broken: the screen reader never announced the errors, and anyone who can't tell red from other colours had no clue what went wrong. I redesigned the errors to include a text message and an icon next to each field, plus a summary at the top that the screen reader reads out. I sat with the developer to make sure each message was properly linked to its field in the code. Afterwards I added keyboard and screen reader checks to our design review, so it wasn't down to someone remembering."

"I work to the WCAG guidelines, usually level AA. First, contrast: normal text needs at least 4.5 to 1 against its background, and large text, plus the parts of the interface people need to see, like input borders and meaningful icons, need at least 3 to 1. I never use colour alone to carry meaning, so errors get text and an icon too. I check that every field has a visible label, not just placeholder text, and that touch targets are big enough to hit easily. Then I annotate things developers can't guess: the focus order for keyboard users, what the focus state looks like, heading levels, alt text for meaningful images, and names for icon-only buttons so a screen reader can say them. I also check the layout still works when text is made larger."

"First I'd make sure I really need something new. Quite often a combination of existing components, or a variant of one, does the job. If it's genuinely missing, I'd message whoever looks after the design system that day, explain the use case, and ask if anything similar is already in progress. Then I'd build it from the system's existing pieces: same colour tokens, spacing and type, so it doesn't look foreign. I'd mark it clearly as a local component and write up how it behaves. After the release, I'd propose it for the system with the real usage as evidence. What I'd avoid is a quiet one-off, because that's how design systems slowly fall apart."

"A design system is the shared set of rules and parts a team builds with. At the base are tokens, named values for colour, spacing, type and so on, so if the brand colour changes, it changes in one place. On top are components like buttons and inputs, with all their states, and patterns for common tasks like forms. The part people forget is documentation and ownership: when to use each component, and who decides what gets added. To keep it from slowing people down, the components have to match what's in the code, so developers trust them, and there needs to be a quick, clear way to propose something new. I'd rather allow a labelled experiment than force people to hack around the system."

"I start with what we want to learn, then write realistic tasks, like 'you want to change your delivery address for tomorrow's order,' not 'click on settings.' I recruit people who match our real users and ask for consent to record. In the session, I explain that we're testing the design, not them, and ask them to think aloud. The hardest part is staying quiet. If they get stuck, I ask 'what are you looking for?' instead of pointing them to the answer. A colleague takes notes so I can focus. Afterwards, we list the issues, group them, and rank them by how badly they block people and how many hit them. I share a short summary with a few video clips, because clips convince people far more than a slide."

"It depends on the goal. For a normal qualitative test, where I'm looking for problems in a design, the common rule of thumb is about five people per type of user. After the first few sessions, you mostly see the same problems again, so extra people add less. It's better to test with five, fix what you found, and test again with another five. If the product has very different users, like buyers and sellers, I'd want around five from each group. But if the goal is to measure something, like the success rate of a task or to compare two designs with numbers, five is far too few. That needs a much bigger sample, often dozens of people or more."

"Before adding emphasis, I'd take things away, because the real problem is usually that everything is shouting at once. I'd ask which elements people actually use and move rarely used ones into a menu or a secondary area. Then I'd make sure there's one clear primary action: a solid, high-contrast button, with other actions styled as secondary or text links so they don't compete. Size and weight help, and so does white space around the key action. Position matters too. I'd put it where people expect it, near the content it relates to. Grouping related items and aligning them to a clear grid makes the screen easier to scan. Then I'd do a quick test, showing the screen for a few seconds and asking what people noticed first."