Most apps don't fail because the idea was wrong. They fail because someone opened them, got confused for a few seconds, and never came back. The culprits are rarely dramatic: a button that sits just out of thumb's reach, a form that empties itself after an error, a spinner that turns forever with nothing to explain it. None of that shows up in a pitch deck, and all of it shows up in the reviews. Here are seven mistakes that create the most friction, and what to do instead.

1. Designing for your own phone, not everyone else's

The first build looks lovely on the handset on your desk. Then it meets a small, older device and falls apart: text wraps into three cramped lines, buttons push against the screen edge, and half the content hides under the keyboard.

Design to the smallest screen you support, not the largest. Respect the platform's dynamic text settings rather than locking everything to fixed sizes, and check your layout at the largest accessible text size — that is usually where the breakage lives. Keep body copy at a comfortable reading size too; small grey text on white is a shortcut that quietly loses readers.

Tap targets need the same care. Apple's guidelines suggest around 44×44 points, Google's around 48×48dp, and that includes padding, not just the visible icon. Test with a case fitted and one thumb, because that is how most people actually hold a phone.

2. Putting the important things out of thumb's reach

Interfaces get designed top-down because that is how wireframes are drawn, but hands work bottom-up. The lower third of the screen is the comfortable zone. The top corners are a stretch, and the very bottom edge now competes with the home indicator and gesture bar.

Put your primary action where a thumb rests: a sticky button, a tab bar, a floating action where the platform expects one. Secondary and destructive actions can sit higher up, where the extra reach acts as a useful speed bump. Think about context, too. Someone using your app one-handed on a packed train has far less precision than you do with two hands at a desk. Generous spacing beats clever density almost every time.

3. Treating navigation as a puzzle to be solved

If a user has to learn your navigation, they are spending attention on the app's structure instead of its content. Common symptoms:

• A menu drawer holding your four most-used destinations
• Unlabelled icons that force people to guess
• Core actions hidden behind a long-press or an edge swipe, with no visible cue
• Six or seven items crammed into a bottom tab bar until nothing is readable

Pick a small number of top-level destinations and make them visible. If you use tabs, label them. Reserve gestures for speeding up tasks people already know, never as the only route to something important. Then walk the path from launch to the main task: if it feels like a detour, it is one.

4. Forgetting everything that happens between the screens

Design files tend to show the happy path — content loaded, network perfect, user signed in. Real life is messier, and the in-between states are where trust is won or lost.

• Empty: what appears on day one, before there is any data? A blank white screen reads as broken. Say what belongs here and offer one clear action.
• Loading: a spinner floating in the middle of nothing tells the user very little. Skeleton placeholders that echo the incoming layout feel faster and stop the page jumping.
• Error: "Something went wrong" is not a message. Explain what failed in plain words, keep the user's input, and give them a retry.
• Offline and partial: assume the connection drops mid-task and design the recovery, not just the alarm.
• First run: ask for a permission at the moment it is needed, with a sentence explaining why. A wall of prompts on launch is the fastest way to get a "no".

5. Building forms that fight the person filling them in

Forms are where most apps lose people, and the damage is nearly always self-inflicted. Small fixes make a disproportionate difference:

• Match the keyboard to the field: email, numeric, telephone, URL.
• Support autofill and paste. Blocking paste in a password field is not security, it is friction.
• Validate on blur or on submit, not on every keystroke. Being told you are wrong while still typing is exhausting.
• Never clear a field because of an error. Preserve everything that was typed.
• Keep labels visible above the field. Placeholder-only labels vanish the moment someone starts typing, and short-term memory rarely survives a phone call in between.
• Show any requirements before submission, not after.

6. Mixing platform conventions into a muddle

iOS and Android users carry different instincts, and a design that ignores them feels subtly wrong on both. On Android, the system back gesture is a promise: if it exits the app from a screen where it should step back, or closes a half-finished form without warning, people lose work and confidence. On iOS, expect the swipe-back gesture and make sure custom screens do not break it.

Follow the platform for the controls people use without thinking: pickers, share sheets, date selection, where settings live. Nobody objects to a distinctive visual style — that is branding. They object to a distinctive way of doing something completely ordinary.

7. Leaving accessibility and performance until the end

Both get filed under final polish, which is why they get cut. In practice they are the same discipline: making the app work for people in less-than-ideal conditions.

• Contrast: check body text against its background, and never signal state with colour alone.
• Screen readers: every meaningful icon needs a label, images need sensible alternative text, and reading order should follow visual order.
• System settings: respect reduced motion and larger text sizes rather than overriding them.
• Weight: oversized images, autoplaying video and chatty tracking calls make a mid-range phone feel slow. Test on the oldest device you support, on a weak connection, and watch how long the first screen takes to become useful.

Accessibility work rarely stays niche. Clearer labels, sturdier contrast and predictable focus order tend to help every user, including the ones on a bright train in a hurry.

Before you ship

Run this pass on a real build, on a real device, while there is still time to change things:

1. Set the largest system text size and the smallest screen you support. Fix whatever breaks.
2. Use the app one-handed for two minutes and note anything you had to shuffle your grip to reach.
3. Turn the network off mid-task and see what the app does.
4. Turn on a screen reader and complete the main task from start to finish.
5. Hand it to someone who has never seen it, say nothing, and watch their thumb.

Every mistake above is cheap to fix early and expensive to fix after launch. The apps people keep are rarely the cleverest ones — they are the ones that never made anyone feel stupid.

Photo: Akshar Dave🌻 / Pexels