Let me tell you about an app I tried to use last week.

I opened it. Immediately got hit with a popup asking for notifications permission. Dismissed that. Got another popup asking me to rate the app (I've used it for literally 3 seconds). Dismissed that. Tried to figure out where to start. No clear guidance. Just buttons everywhere. Clicked one. It took me somewhere confusing. Tried to go back. Couldn't figure out how.

I closed the app. Deleted it, from my phone and from my mind.

Total time wasted: 47 seconds.

The developers probably spent months building that app. The code probably works perfectly. But the experience? Hot garbage.

This is why developers need to understand UX. Because working code is not enough. If users can't figure out HOW to use it, they won't.

And users can be DUMB.

What Is UX (And Why Developers Hate Thinking About It)

UX = User Experience. It's everything about how a person interacts with your app. The interface. The flow. The feelings it creates. The little frustrations. The small delights.

Good UX feels invisible. Everything just makes sense. You don't have to think.

Bad UX feels like trying to navigate Nairobi at night with paper maps you bought at the library (who even does that?) last updated never. Technically, you'll get there eventually. But you'll suffer.

Most developers focus on functionality: "Does the button work?" Good UX asks: "Should the button even exist? Where should it be? What should it say? What happens after you click it?"

Why Developers Struggle With UX

1. We're Too Close to the Code

When you build something, you know exactly how it works. Every button, every field, every flow is obvious to you.

But users don't have your mental model. They don't know what you know. What's obvious to you is alien to them.

2. We Optimize for Ourselves

Developers love features. Options. Customizability. Power.

Normal users? They want simple. Fast. Obvious. They don't want 17 settings to configure. They want it to "just work."

3. We Think Logically, Users Think Emotionally

We design based on system architecture. Users navigate based on gut feeling and intuition.

To us, organizing features by backend modules makes sense. To users, it's nonsense. This is especially critical in mobile app state management — the architecture you love might create UX friction users hate.

The Core Principles of Good UX

1. Clarity Over Cleverness

A "hamburger menu" icon might look clean. But if half your users don't know it's a menu, it's a bad design.

Label things clearly. Use words. Don't make users guess.

2. Consistency Is King

If clicking a button opens a modal in one place, it should do the same everywhere. Don't randomly change interaction patterns.

Users learn your app once. If every page works differently, they're constantly relearning.

3. Reduce Cognitive Load

Every choice you present is mental work. Every option is a decision to make.

Don't ask users to think. Guide them. Default to the most common choice. Hide advanced options behind "Advanced Settings."

4. Feedback Is Essential

When a user does something, acknowledge it.

Clicked a button? Show a loading spinner.

Form submitted? Show success message.

Error happened? Explain what went wrong and how to fix it.

Silence is confusing. Feedback reassures.

5. Respect User's Time

Don't make them click through 5 screens to do something that should take one click.

Don't ask for information you don't need.

Don't make them watch a tutorial before they can use your app.

Every second of friction is a chance for them to leave.

Common UX Crimes Developers Commit

Crime 1: Too Many Popups

Notifications permission. Location access. Rate the app. Sign up for newsletter. Enable Face ID. Subscribe to Pro.

STOP. Let people breathe. Ask for permissions when they're actually needed, not all at once on first launch.

Crime 2: Invisible Buttons and Links

Just because something is technically clickable doesn't mean users know it's clickable.

Make buttons look like buttons. Make links look like links. Use affordances (visual clues that something is interactive).

Crime 3: Forms from Hell

20 required fields. No indication which are actually necessary. Password requirements written in invisible text somewhere. Cryptic error messages. Losing all your data if you make one mistake.

Keep forms short. Only ask what you need. Validate in real-time. Show errors clearly. Save progress.

Crime 4: No Empty States

User opens your app for the first time. The screen is blank. No data yet. No guidance on what to do next.

Empty states are your chance to guide new users. Show them what they should do first. Give examples. Make it welcoming.

Crime 5: Mobile App That's Just a Shrunk Web App

Mobile is not desktop with a smaller screen. People interact differently. They use one hand. They're distracted. The screen is tiny.

Design for mobile specifically. Big touch targets. Swipe gestures. Bottom navigation (easier to reach with your thumb). The mobile-first vs web-first decision matters here — each platform has different UX requirements. And React Native navigation patterns often differ from web routing for good UX reasons.

Crime 6: Ignoring Loading States

Button clicked. Nothing happens. User clicks again. And again. Now the action triggers three times.

Always show feedback. Loading spinners. Disabled buttons. Progress bars. Something that says "I heard you, I'm working on it."

Crime 7: Jargon Overload

"Flush cache." "Invalidate session." "Re-index database."

Users don't speak developer. Use human language. "Clear temporary files." "Log out." "Refresh data."

The UX Checklist (Before You Launch Anything)

Onboarding:

  • [ ] New users understand what the app does within 5 seconds
  • [ ] There's a clear first action to take
  • [ ] Critical features are explained (briefly!)
  • [ ] Users reach value quickly (time-to-wow is short)

Navigation:

  • [ ] Users can find key features without hunting
  • [ ] Back buttons work as expected
  • [ ] Navigation is consistent across the app
  • [ ] There's a clear way to get home

Interactions:

  • [ ] Buttons look like buttons
  • [ ] Loading states are shown
  • [ ] Errors are clear and actionable
  • [ ] Success states are confirmed
  • [ ] Everything is responsive (no laggy clicks)

Content:

  • [ ] Text is readable (size, contrast, font)
  • [ ] Language is simple and clear
  • [ ] No jargon unless necessary
  • [ ] Instructions are concise

Forms:

  • [ ] Only essential fields are required
  • [ ] Validation happens in real-time
  • [ ] Errors are specific and helpful
  • [ ] Autofill and autocomplete work
  • [ ] Tab order makes sense

Mobile (if applicable):

  • [ ] Touch targets are big enough (minimum 44x44 pixels)
  • [ ] Content fits without horizontal scrolling
  • [ ] Works with one hand
  • [ ] Doesn't require zoom to read

How to Actually Get Better at UX

1. Use Your Own App (Like a Real User)

Delete it. Reinstall. Go through the entire flow as if you've never seen it before. You'll spot issues immediately.

2. Watch Real People Use It

Not developers. Not tech-savvy friends. Regular people.

Don't help them. Don't explain. Just watch. You'll be horrified at what confuses them. That's good. Those are things to fix.

3. Study Apps You Love

Why does that app feel so smooth? What are they doing that you're not?

Copy patterns that work. Steal shamelessly. Good UX is not about reinventing the wheel.

4. Learn Basic Design Principles

You don't need to be a designer. But learn basics:

  • Visual hierarchy (what users see first)
  • White space (breathing room)
  • Color theory (what colors communicate)
  • Typography (readability)

5. Read About UX

Books like "Don't Make Me Think" by Steve Krug. Blogs. Case studies. You'll start seeing patterns.

The Kenyan Context (Localization Matters)

Building for Kenyan users? Consider:

Data Costs: Heavy images and videos = expensive. Optimize file sizes. Offer low-data modes.

Device Variety: Your app needs to work on a 3-year-old budget Android, not just your flagship phone.

Connectivity: Assume poor internet. Design for offline. Cache aggressively. Show clear offline states.

Language: Sheng makes sense in some contexts. English is safer for broad audiences. Swahili for government/formal apps. Balance.

Cultural UI Patterns: Kenyans are used to how popular things like M-Pesa UI patterns flow. Don't reinvent familiar flows unnecessarily.

Payment Friction: If payment isn't easy and trusted (M-Pesa), users won't convert. Make it seamless.

Cross-Platform Consistency: Whether you choose Progressive Web Apps or native mobile, users expect visual consistency. A dark mode implementation that respects system preferences shows UX thoughtfulness.

When to Get a Real Designer

If you're building:

  • A consumer app where UX is a competitive advantage
  • Something visual-heavy (e-commerce, social media, content platforms)
  • An app targeting non-technical users

Then yes, hire a designer. They'll pay for themselves in better conversions and lower churn.

If you're building:

  • An internal tool for developers
  • A quick MVP to test an idea
  • Something technical with a narrow audience

You can probably handle UX yourself using basic principles.

The Bottom Line

Good UX is not about making things pretty. It's about making things usable, intuitive, and delightful.

Your app can have perfect code and still fail if users can't figure out how to use it. Functionality gets you to the starting line. UX wins the race.

You don't need to be a designer to create decent UX. You just need to care about the user's experience more than your own convenience.

Put yourself in their shoes. Remove friction. Make things obvious. Test with real people. Iterate based on feedback.

Code is for computers. UX is for humans. Don't forget which one you're building for.

Takeaway: Good UX is about clarity, consistency, and reducing friction. Users don't think like developers, so design for their mental model, not yours. Keep things simple, provide clear feedback, respect their time, and test with real people. Bad UX kills apps faster than bugs do. The best app is the one users don't have to think about — it just works.