Paper sketches of app screens connected by arrows, one screen blue, a pencil beside them

Mobile App Design: From User Flows to Final Mockups

People open an app on the go, with one hand, on a weak connection, for half a minute. In that time they need to figure out where they are and do what they came for: order, book, pay, check a status. If that doesn't work, the app gets deleted, and there's usually no second chance.

That's why mobile app design doesn't start with colors and icons. It starts with user flows: who uses the app, in what situation, and in how many steps they get the job done. Let's walk through how we go from goals to mockups that are ready for development, and what matters in an interface built for iOS and Android.

Where app design begins

The first question is why the app matters to the business and to the user. For the business, the goal might be repeat purchases, a lighter load on the call center, or taking a process digital. For the user, the goal is always simpler: get a specific thing done quickly. If these goals aren't spelled out, arguing over mockups is pointless because there's nothing to measure them against.

Next we look at the audience: who these people are, where and when they open the app, how comfortable they are with their phones. A courier wearing gloves, a manager between meetings and a shopper on the couch in the evening need three different interfaces, even if the features are similar.

User flows and a screen map

A user flow is a person's path to a goal: "opened the app from a push notification, saw the order status, contacted support." For every key flow, we describe the steps, the data needed at each step and the points where people might get lost.

The flows come together in a screen map: every screen in the app and the transitions between them. It immediately shows which screens are unnecessary, where a flow is too long and which sections need to be reachable from anywhere. A screen map is cheaper than any mockup, and mistakes in it take minutes to fix.

Navigation answers two questions: where am I, and how do I get where I need to go? Mobile apps have several established patterns for this, and users already know them.

The thumb zone and touch target sizes

Most of the time, people hold their phone in one hand, and the thumb easily reaches the bottom and middle of the screen. The top corners of large phones are the hardest zone to reach. So primary actions go toward the bottom: the tab bar, the screen's main button, the pay button. The top keeps the title, search and rarely used actions.

A touch target is the area you can tap. Apple recommends a minimum of 44×44 pt, Google 48×48 dp. An icon can be smaller, but the tappable area around it shouldn't be, and neighboring targets shouldn't run into each other.

Key actions belong where the thumb can reach, not wherever there happened to be room.

App onboarding and permission requests

Onboarding is the first few screens after install. Its job is to get the person to their first useful result, not to tour every feature. Three illustrated slides that everyone swipes past rarely accomplish much. Contextual hints work better: shown at the moment someone first encounters a feature.

Sign-up is also worth postponing wherever possible. If the catalog, schedule or prices can be viewed without logging in, let people see the value first and leave their phone number or email afterward.

How to ask for permissions

Notifications, location, camera, contacts: each permission is requested by the system, and on iOS the system prompt can't be shown again. Once denied, access can only be turned on in Settings. On Android 13 and later, notifications require permission too. So the request should come at the moment it makes sense: camera access when the user taps "Scan," location when they choose a delivery address.

Human Interface Guidelines and Material Design

Apple and Google each have their own interface guidelines: Human Interface Guidelines for iOS and Material Design for Android. They aren't a mandatory style; they describe how system elements behave and what users on each platform expect. An app can have its own brand and visual language, but it's best not to break the basic behavior.

iOS (HIG)Android (Material)
Minimum touch target44×44 pt48×48 dp
Primary navigationTab bar at the bottomBottom navigation or navigation drawer
BackHeader button and swipe from the left edgeSystem gesture or Back button
System fontSan Francisco, Dynamic TypeRoboto, font scaling in sp
Primary actionButton in the header or at the bottomOften a floating action button (FAB)
Picking from a list or a dateWheel pickers, bottom sheetsDialogs and dropdown menus

There's more in common than different: both guidelines call for large touch targets, readable text, clear hierarchy and support for system settings. iOS and Android app design is usually built on a single design system, with the differences handled in navigation, system components and gestures. That way the app stays recognizable without feeling foreign on either platform.

Screen states: empty, loading, error, offline

In mockups, a screen is usually drawn in its ideal form: data loaded, list populated, connection solid. Real life is different, and this is exactly where apps most often look broken. For every screen we design these states:

States aren't a minor detail for developers to sort out. If they aren't designed, they'll be improvised on the fly, and every section will end up handling them differently.

Accessibility: text size, contrast, dark mode

Many users increase their phone's system font size. The interface has to cope: text wraps, buttons grow, nothing gets cut off. It's easy to check: turn on large text in your phone's settings and go through the main flows.

WCAG contrast between text and background should be at least 4.5:1 for regular text and 3:1 for large text. Gray text on a light gray background looks great in a presentation and is hard to read outdoors. Information shouldn't be conveyed by color alone: an error in a field is flagged with text too.

Users turn on dark mode at the system level and expect apps to support it. It isn't a color inversion: it needs its own background shades, muted accents, and checks for contrast and illustrations. If colors are defined as tokens in the design system from the start, dark mode becomes a second set of values rather than a redraw of every screen.

App prototypes and user testing

A prototype is a clickable model of the app you can walk through before development begins. We start by building it from simple gray blocks so the conversation stays on logic, not colors. Then, once the structure is agreed on, the visual design becomes clickable too.

Testing doesn't require a lab. Five or six people from the target audience, a phone with the prototype and a list of tasks are enough: "find the nearest pickup point," "move your appointment to tomorrow." We watch where people hesitate, where they tap the wrong thing, what they miss. Each of those moments is a fix that costs hours in a prototype and weeks in finished code.

The design system and developer handoff

Developers don't receive a set of images; they receive a system of components, rules and tokens. How complete it is determines whether the app ends up matching the mockups.

The designer stays involved during development: answering questions, reviewing builds and signing off on screens. App design ends with reviewing the build, not with the mockups.

Store assets: the icon and screenshots

The App Store and Google Play listing is part of the design too: it's where people decide whether to install. The icon has to read at a small size and on any wallpaper: one simple image, no small text. The App Store takes a 1024×1024 pixel icon, Google Play a 512×512 one.

Screenshots aren't just screen captures; they're a short story, with one benefit and a large caption on each. The first two or three frames are visible right away in search results, so that's where the most important points go. Google Play also requires a 1024×500 feature graphic. The stores change their screenshot size and count requirements from time to time, so check them against the current documentation before publishing.

Other common mistakes:

Mobile app design stages and checklist

  1. Goals and audience. We define business and user goals, review competitors and the situations in which people open the app.
  2. User flows and screen map. We describe the key paths and build the app's structure.
  3. Prototype. We build a clickable model and test it with users.
  4. Visual style. We propose several options on key screens and choose a direction.
  5. Mockups and design system. We design every screen and state for iOS and Android and assemble the components and tokens.
  6. Handoff and design oversight. We prepare store assets, support development and review builds.

Before handing off to development, run through a short checklist:

As an app development company, we build apps end to end: from audience research and user flows to design, development and publishing in the stores. You can see examples on our work page.

FAQ

Do you need separate designs for iOS and Android?

Usually not. Teams create one design system and a shared visual style, and handle the differences in navigation, system components, gestures and dialogs. That saves time, and the app still behaves the way users expect on each platform.

Can you start design without a technical spec?

Yes, as long as the goals and audience are clear. User flows, the screen map and the prototype become the foundation for the spec themselves, and they make it easier to estimate development than a written description does.

How many screens need to be designed?

It depends on the user flows. Count not only the main screens but also their states, modals and onboarding: a single screen on the map often turns into several mockups.

How is an app prototype different from the design?

A prototype tests the logic: which screens exist, what's on them and how you move between them. Design covers the look, the components and the details. The prototype is agreed on first and the design comes after; otherwise the logic has to be reworked in finished mockups.

Let’s discuss your project
Related reading