Foldwren

What actually goes into designing an app

A walk through the stages of designing an app, from first idea to developer handover, including who is involved and where the time goes.

People often picture app design as drawing screens. That is one stage of five, and not the longest. Most of the effort goes into working out what the app should do, for whom, and what happens when things do not go to plan.

If you are about to commission an app, knowing the stages will help you read a quote, follow progress and spot when something has been skipped.

Stages one and two: discovery and structure

Discovery

This is where the designer learns about your business, your customers and the problem the app is meant to solve. Expect a lot of questions.

  • Who will use it, and what are they trying to get done?
  • How do they manage that today?
  • What does success look like for the business?
  • What systems does the app need to connect to?
  • What is the budget and the deadline?

You receive: a short written summary of the goals, the users, the scope and what is being left out. That last part is as valuable as the rest. A clear "not in version one" list prevents many arguments later.

Flows and structure

Before any screen is drawn, the designer maps what users do, step by step. Say the app is for a mobile dog groomer. The map would trace how a customer books a groom, how they change it, how the groomer sees the day's run, and what happens if a booking is cancelled late.

From those flows comes the structure: a list of screens, how they connect, and what goes in the main navigation.

You receive: flow diagrams and a screen list. They look like boxes and arrows. Read them carefully anyway. Adding a forgotten step here takes minutes.

Stages three and four: prototype and visual design

Wireframes and a prototype

Wireframes are plain, greyscale layouts of each screen. No colour, no branding, just what goes where: this heading, that list, a button here.

The wireframes are then linked into a clickable prototype you can try on a phone. This is the first moment the app feels real, and the best moment to test it with a handful of people outside the project.

You receive: a prototype link, and a list of what changed after testing.

Visual design

Now the screens get their look: colours, type, icons, spacing, imagery. Alongside the screens, the designer builds a set of reusable components, so the same button and the same card appear everywhere.

This stage also covers the parts clients rarely think to ask for:

  • How each screen looks while loading
  • What appears when a list is empty
  • Every error message
  • How the layout adapts to small and large phones, and to larger text settings

You receive: finished designs for every screen and state, and usually an updated prototype that looks like the real thing.

Stage five: handover and build support

The designs go to the developers, along with the detail they need: measurements, colour values, assets such as icons and images, and notes on how things should behave.

Design does not stop here, and a quote that assumes it does should make you wary. During the build, developers find situations nobody anticipated. A name too long for its box. A step the booking system handles differently from the design. Someone needs to make those calls, and it should be the designer, not whoever happens to be coding that afternoon.

You receive: design files, a component library, exported assets, and a designer on call during development.

Who is involved?

On a small project one or two people may cover several of these roles.

  • You, or someone from your business. The person who knows the customers and can make decisions. This matters more than people expect.
  • A designer. Covering both how it works and how it looks.
  • A developer. Ideally consulted from stage two, so designs are checked against what is technically sensible.
  • Someone writing the words. Button labels, messages and instructions. Often the designer, sometimes you.

Where does the time really go?

Clients are often surprised by this, so here is the honest picture.

  • States and edge cases. A booking screen is one design. Add loading, empty, full, error and offline, and it is six.
  • Decisions. Waiting for feedback and sign off is frequently the longest part of a project. One person with authority to decide speeds things up enormously.
  • Revisions. A couple of rounds are normal and healthy. Open ended rounds are a sign that the goals were never agreed.
  • Content. Real service names, prices, photos and policies always take longer to gather than planned.

Questions to ask about any quote

  • Which of these stages are included, and what do I receive at the end of each?
  • Will the design be tested with real users before development?
  • Are loading, empty and error states part of the design?
  • Is the designer available during the build?
  • Who owns the design files when the project is finished?

A quote that covers only "screen designs" is leaving out most of the work that makes an app usable. Either that work will not happen, or it will be done on the fly during the build, which is the most expensive place to do it.

Your order