Users Don't Care About Your Figma File
The gap between what looks good and what works
Summary: This post breaks down how clean, modern-looking interfaces often fail because teams have forgotten the basics: labels, feedback, defaults, and the old-school UX principles that actually help users.
A few months ago, I helped a friend renew a license on a government-run website. It should have been quick. Instead, we clicked "Submit" 3 times with no response, re-entered data into fields we didn't even realize were required, and stared at a spinning wheel that never told us what it was doing.
The design looked polished and slick. It had a full-width layout, nice typography, and modern UI element styling. But it just didn't work well, and more importantly, it didn't help us throughout the entire task. No confirmation, no errors, no hints. Just a shiny UI that left us guessing at every step.
That moment was familiar. I've seen it across dozens of tools in healthcare, finance, compliance, and internal ops. UX teams follow what they think are best practices. The visuals are clean. The layouts are structured. But the experience still falls apart hardcore because basic UX principles get skipped or misapplied.
This week's article is about the most common places where I see this happening over and over again. If this breakdown inspires even one UX professional to revisit the basics, I'll consider it a success.
Lack of Clarity
Many teams believe that if an interface looks clean, in their opinion, users will magically know how it works. This belief often leads to stripped-down screens that look nice in a screenshot but leave users unsure how to proceed.
💡 NOTE: Usability Heuristic #2: Match Between System and the Real World
You want to know what a user has never done, ever? A user has never ever ever pushed their chair back from the computer screen, looked at your app's design holistically and out of context like a visitor at an art gallery admiring a Rembrandt, and said, "Woooooow, what an intuitive interface."
Common problems in this category include:
Controls that change names or locations depending on the page, with no explanation (the rule of consistency)
Features that appear or disappear based on role, time, or context, but without any visible logic
Unlabeled icons that expect users to memorize what each symbol means (That’s right, I’m going to keep calling out the harm of unlabeled icons over and over until the nonsense stops. hahahaha)
Tooltips used in place of real labels or visible guidance, such as password requirements or input formatting rules
Weak signifiers, like buttons that look like plain text or fields with no visual indicator they can be edited
Forms that fail to offer defaults, even when the system knows what most users are likely to choose
Aesthetic-usability effect used to justify confusion, where teams assume that if it looks good, people will assume it works
📍 Example: A signup flow required users to create a password but didn't show the password requirements until after submission failed. The requirements were hidden behind a small info icon that most people missed because the UX designer thought putting the requirements directly on the UI "cluttered the interface" too much. Sound like terrible logic? Yep, I’ve heard it too. Hahahaha.
Clean design isn't useful if users can't figure out how to use it.
We must first make things that work, and then, and only then, make sure they look visually appealing to our users.
The more stripped-down the interface gets, the more critical it becomes to give users structure, context, and visible rules.
Stuff You Shouldn't Have to Think About
Once users get past the initial confusion of what things are or where to find them, the next problem is figuring out how to interact with them. This is where many interfaces collapse under the weight of small decisions that weren't tested with real people.
Small interaction problems often grow into major usability blockers:
Click targets that are too small, especially in dense tables or mobile layouts, where users frequently miss the intended control and assume it's broken
Buttons that don't respond visually when hovered or clicked, leaving users unsure if their action was registered (lack of proper affordances)
Visual elements that imply interaction but aren't clickable, like arrows or underlined text used for decoration
Unlabeled icons placed throughout the interface, offering no clarity on what action will be triggered
📍 Example: A cloud storage app used a row of unlabeled buttons for features like request file access, convert to PDF, and open version history. Over time, users developed muscle memory for the general location of the icon that triggered the function they needed. When a UI update shifted the layout, their spatial habits no longer worked, and they had to guess through unfamiliar icons all over again.
The more time a user spends hunting for the right interaction or second-guessing a click, the less confident they feel. These small speed bumps add up. Eventually, they train users to avoid features entirely, even if those features are valuable.
Communication Failures
Even when users figure out what to click and how to interact with the system, the interface often leaves them wondering if anything actually happened. If the application doesn't communicate clearly, users are stuck waiting, guessing, or repeating steps they already took.
Common communication breakdowns include:
No confirmation or status messages after form submissions or button clicks
Progress indicators that appear too late, or never appear at all
Error messages that are vague or technical, like "Try again later" or "Unexpected null value at index 3"
Animated microinteractions that look nice but don't clearly explain what just happened or what the user should do next, and usually take too long to finish their animation (e.g., apex frustration moment. hahahaha)
📍 Example: In a budget approval tool, submitting a form simply refreshed the screen with no message. Users had no way of knowing whether the request went through or if the data was lost, so they kept submitting it multiple times.
When feedback is missing or unclear, people stop trusting the interface. They fall back on workarounds like taking screenshots, refreshing the page after every action, or asking a colleague how it's "supposed to work." None of those are good signs.
Cognitive Load, Overload
Once the interface responds to user input, a new problem often pops up. It expects users to remember too much. This is where complexity becomes exhausting. Instead of supporting the user through the task, the system silently offloads responsibility onto the person using it.
💡 NOTE: Usability Heuristic #6: Recognition Rather Than Recall
Here are some of the most common ways that happens:
Modal windows that block helpful context, preventing users from referring to information they were just looking at
Form fields that give no hint about what kind of input is valid or expected
Interfaces that assume the user remembers rules, patterns, or inputs across multiple steps without reinforcing them
Workflows that force users to re-enter information or reconstruct previous actions from scratch due to a lack of memory or reference tools
📍 Example: A financial forecasting tool that features critical information in a table opens a modal when users select the "Edit" button to change values for one quarter. Of course, the rest of the table disappears behind it. Users had to open another browser tab just to compare numbers side by side. I've been there, done that for sure.
Inconsistent memory demands don't just slow people down. They cause people to lose confidence in the tool. The more the interface makes users rely on memory, the more likely they are to create workarounds or make mistakes that never should have happened in the first place.
Bad Neighbors
Even when users have figured out what to do and how to do it, one final layer of risk still shows up. Sometimes the interface places critical, high-impact actions right next to harmless ones. This setup punishes fast workflows and opens the door to accidental data loss.
💡 NOTE: Usability Heuristic #9: Help Users Recognize, Diagnose, and Recover from Errors
Common patterns include:
Destructive actions placed next to confirmation or save buttons, often styled similarly or with identical icons (pair that with the fact that many times a destructive action results in no confirmation modal and you have complete and utter chaos.)
Critical actions located where muscle memory takes over, increasing the risk of clicking the wrong thing at the wrong time
Poor visual separation between actions with very different outcomes
📍 Example: A project management tool placed "Archive Project" directly beside "Add Task." Both used a plus sign icon and had nearly the same styling. One adds a note. The other hides months of work. Users clicked the wrong one regularly.
These aren't usability problems. They are simple, avoidable design risks. The interface shouldn't allow a single misplaced click to erase hours of work, especially in tools used for repetitive daily tasks. People make slips. Interfaces should account for that.
Conclusion
That licensing form I mentioned at the beginning? My friend never got a confirmation email. Days later, she received a phone call saying her submission didn't go through. She had to redo the entire process, this time with someone from support walking her through it over the phone. That's what it took to complete a basic task in a system that looked perfectly fine on the surface.
This is what happens when clean visuals take priority over clear interactions. This is what happens when feedback, labels, defaults, and guardrails get left behind in the name of visual simplicity. Most of the problems in complex tools are not the result of bad intentions. They come from decisions that sound reasonable during design reviews. They come from skipping research or over-trusting bad interaction patterns without checking if they actually work.
Good UX is not about how few elements you can get on the screen. It's about how confident your users feel while using what you built to complete a real task in the real world. It's about making sure they can move forward without guessing, stalling, or redoing their work from scratch.
Clarity is not a luxury. It is the foundation of UX.
If your users have to memorize icons, repeat steps, or hesitate before clicking, the interface is not finished. The job is not done.
UX is not just what looks good. It's what makes people feel sure they're on the right path. When you build for that, the rest starts to take care of itself.