Good UX design isn't about making things look pretty—it's about making things work. I've redesigned interfaces that looked beautiful but confused users, and I've built simple designs that users loved. The difference? Understanding how people actually use software.
Start with User Research
Before opening Figma, I talk to users. Not surveys or questionnaires—actual conversations. I ask them to show me how they currently solve problems, what frustrates them, and what they wish existed.
For a recent ERP redesign, I spent two days observing users in their actual work environment. Watching someone struggle with a form I designed was humbling, but it led to a complete redesign that reduced task completion time by 40%.
User research doesn't have to be formal. Even talking to 5-10 users reveals patterns you'd never discover otherwise. The goal is understanding, not validation.
Information Architecture: Organizing for Humans
How you organize information determines whether users can find what they need. I've seen beautifully designed interfaces fail because information was organized logically (to developers) but not intuitively (to users).
I use card sorting exercises to understand how users mentally organize information. Give users cards with features or content, ask them to group related items, and you'll see patterns emerge.
For the CCDS Shop redesign, card sorting revealed that users thought about products by use case, not by category. This led to a navigation structure that matched users' mental models, reducing bounce rate by 25%.
Prototyping: Fail Fast, Learn Faster
I prototype early and often. Not polished designs—rough wireframes and clickable prototypes that test concepts quickly.
Figma is my tool of choice for prototyping. I can create interactive prototypes in hours, test them with users, and iterate based on feedback. The goal is finding problems before writing code.
I've thrown away entire design directions based on prototype testing. It's painful, but less painful than building something users don't want.
Usability Testing: The Reality Check
Usability testing reveals problems you never saw coming. I've watched users struggle with interfaces I thought were intuitive, and I've seen them breeze through designs I worried were too complex.
I do usability testing with 5-8 users. More than that, and you're hearing the same feedback repeatedly. Less than that, and you might miss important patterns.
The key is watching users actually use the interface, not asking them what they think. People are polite—they'll say they like something even if they're struggling. Watch their actions, not their words.
Design Systems: Consistency at Scale
As applications grow, consistency becomes critical. I've worked on projects where every page looked slightly different because there was no design system.
A design system doesn't have to be complex. Start with:
- Color palette (primary, secondary, success, error, etc.)
- Typography scale (headings, body text, captions)
- Component library (buttons, forms, cards, navigation)
- Spacing system (consistent margins and padding)
I've built design systems in Figma that developers can reference, ensuring designs translate accurately to code. This saves hours of back-and-forth and ensures consistency.
Accessibility: Design for Everyone
Accessible design isn't optional—it's good design. I've learned to consider:
- Color contrast (WCAG AA minimum, AAA when possible)
- Keyboard navigation (everything should be keyboard accessible)
- Screen reader compatibility (semantic HTML, ARIA labels)
- Focus states (clear indication of where users are)
I've tested interfaces with screen readers and keyboard-only navigation. It's eye-opening how many designs break when you can't use a mouse.
Mobile-First: The New Reality
Most users access applications on mobile devices. I design mobile-first, then enhance for larger screens. This forces focus on what matters most.
Mobile constraints are actually helpful. Limited screen space forces you to prioritize content and features. If it doesn't fit on mobile, maybe it's not essential.
Performance as a Design Feature
Slow interfaces frustrate users regardless of how beautiful they are. I consider performance during design:
- Optimize images (WebP format, appropriate sizing)
- Lazy load content below the fold
- Minimize HTTP requests
- Use CSS animations instead of JavaScript when possible
I've redesigned interfaces that looked identical but loaded 3x faster. Users noticed immediately.
Iteration: Design Never Stops
Design isn't a phase—it's continuous. I monitor user behavior, collect feedback, and iterate based on real usage data.
Analytics reveal where users struggle. High bounce rates, low conversion, or high support tickets indicate design problems. I use this data to prioritize improvements.
What I've Learned
After years of designing interfaces:
- User research is non-negotiable. You can't design for users you don't understand.
- Simplicity beats complexity. Users prefer simple interfaces that work over complex ones that impress.
- Prototype early. Find problems before building.
- Test with real users. Your assumptions are usually wrong.
- Accessibility isn't optional. Design for everyone.
- Performance matters. Fast beats pretty.
Good UX design solves real problems for real people. Focus on that, and the aesthetics will follow.