Updated November 2026 · Written and maintained by the Progression Agency strategy team
A wireframe is the cheapest argument an app team will ever have. App design wireframes reduce every screen of a flow to gray boxes and plain labels, so the owner, the designer and the developer can disagree about content, order and actions while a change still costs minutes. This page follows one hypothetical booking flow from a pencil sketch to a clickable prototype and shows what each pass settles: the level of detail, what every screen holds, how screens connect, which notes travel with them and which tools suit each stage. Progression’s designers and developers are based in New York and wireframe apps for businesses across the US.
On this page · 13 sections
- One gray box, two readings
- What app design wireframes settle before anyone picks a color
- Three levels of detail, one screen
- What each mobile app wireframe screen holds
- Wiring screens into a task
- Annotation: the notes that keep two people reading one box the same way
- Wireframe in software development: who reads it, and for what
- From wireframe to prototype
- Tools for app design wireframes
- A wireframe for app design reviews: ten questions
- Four habits that make wireframes expensive
- What app wireframing costs
- Inputs that make the first sketches useful
Wireframes already approved? When the wireframes are signed off and the work turns to finished screens, store graphics and the developer file, our mobile app design company page picks up from there.
Examples marked “Illustrative example.” describe a hypothetical bike repair shop and its booking app, not a real business.
One gray box, two readings
A hypothetical bike repair shop wants customers to book a tune up from their phones. The drop off screen in its first wireframe holds a gray box with one word in it: Map.
The owner read the box as a live map with courier tracking. The developer read it as a still picture of the street that opens the phone’s maps app. Both readings were reasonable, and nobody noticed the gap until the screen was built. One sentence of annotation beside the box would have settled it in a minute: still image of the shop’s location, tap opens the phone’s maps app.
That is the whole case for wireframing carefully. The drawing is cheap; the misunderstanding is expensive. The rest of this page follows the same hypothetical booking flow through every pass that prevents a gap like that one.
What app design wireframes settle before anyone picks a color
The W3C’s Accessibility Roles and Responsibilities Mapping describes wireframes as low fidelity screen mockups and lists them, beside user journeys, prototypes and information architecture, as core deliverables of user experience design. In practice app design wireframes settle six things: order, actions, paths, states, words and notes.
Everything else waits. Color, type, imagery and motion belong to visual design, and whether people can actually finish the task belongs to the prototype. The table splits each question across the three stages.
| Question | Settled in the wireframe | Left for visual design | Left for the prototype |
|---|---|---|---|
| What is on the screen? | Every element, in priority order | Imagery and illustration | Nothing new |
| How big is each part? | Rough proportions and the main action’s prominence | Exact spacing, type sizes and color | How it feels to tap |
| What does the screen say? | Labels, button wording and messages | Typography and tone of voice polish | Whether people read it |
| Where does a tap lead? | Every path, including back and cancel | Transitions and motion | Whether the path works end to end |
| What if it goes wrong? | Each state the screen must show | How those states look | Whether people recover |
| Who can use it? | Focus order, labels and gesture alternatives | Contrast and color | Keyboard and screen reader trials |
Is an app wireframe the same as a mockup?
They are close relatives with different jobs. An app wireframe fixes structure and behavior in gray; an app design mockup shows how a finished screen will look, with color, type and imagery, and usually comes after the structure is agreed. Showing a polished mockup first invites comments on the color of a button before anyone has asked whether the button should exist.
Where wireframes sit in the app design process
Wireframes come after the problem and the one task are agreed and before visual design. In the app design process they are the first point where a written requirement becomes something people can point at, which is why owners often see gaps in their own requirements for the first time here. The wider steps from idea to launch are on our how to build an app page. Once the flow holds up, the same screens are judged against finished work in our look at the best app design.
Three levels of detail, one screen
The same Pick a time screen from the hypothetical booking app can be drawn three ways. Each level answers a different question, and each costs a little more to change.
| Level | Made with | Answers | Cannot answer | Move on when |
|---|---|---|---|---|
| Sketch | Pencil, paper or a whiteboard | What belongs on the screen and roughly where | Proportions, wording, behavior | Everyone agrees on the list of screens |
| Gray boxes | A design tool with simple shapes | Order, size and the main action | How it looks and feels | Each screen’s purpose fits in one line |
| Annotated | The same file with real words and notes | What every part does, says and needs | Whether people can finish the task | Developers have no open questions on the notes |
Balsamiq’s guide to wireframes describes the low detail end as simple black and white or grayscale boxes and lines, and the high detail end as closer to the finished product, with placeholder text, images and some interaction. Most app projects pass through all three levels for the main flow and stop at gray boxes for screens that copy an existing pattern, such as a settings list.
How a wireframe paper prototyping session runs
A wireframe paper prototyping session uses printed or hand drawn screens as a working app. One person plays the computer, swapping sheets as a participant taps with a finger; another takes notes. The usability firm NN/g, in its article on paper prototyping, cites the common software engineering estimate that a change made before any code is written is about 100 times cheaper than the same change after implementation. The GOV.UK Service Manual’s guidance on making prototypes makes a similar point from another side: sketches are useful for exploring and discussing basic ideas with colleagues, while realistic code prototypes suit user research better.
- Print each screen at the size of a real phone.
- Cut the main buttons out so they can be moved between sessions.
- Give the participant one task, in their own words.
- Note every hesitation, not only every wrong tap.
- Redraw between sessions rather than arguing about what was meant.
When does a high detail wireframe pay off?
When the words carry the risk. A booking confirmation, a price breakdown or a consent screen fails on wording more often than on layout, so those screens earn real copy and notes early, while a list of shop opening hours can stay in gray.
What each mobile app wireframe screen holds
A mobile app wireframe is a small canvas with a lot of decisions on it. The drawing below splits the hypothetical Pick a time screen into six zones, and the table extends the list to everything a finished wireframe should carry.
| Part of the screen | What it holds | The question it settles |
|---|---|---|
| Purpose line | One sentence above the frame | Does this screen earn its place? |
| Carried choices | What the person picked on earlier screens | Is anything asked twice? |
| Content in order | Each element, most important first | What do people see before scrolling? |
| Main action | One button, named for its result | What happens next? |
| Ways out | Back, cancel, help | Can people leave without losing work? |
| Inputs | Each field, its keyboard and whether it is optional | What is the least we can ask? |
| States | Loading, nothing found, error, success | What does this screen show when things change? |
| Notes | Numbered pins with plain sentences | What would a developer otherwise ask? |
Two habits keep screens honest. Write the purpose line first; if it needs the word and, the screen is probably two screens. Then carry earlier choices forward visibly, so the person booking a tune up never wonders whether the app remembered which repair they picked.
Real words or placeholder text?
Real words, as early as the gray box stage. A button labeled Button tells nobody anything, and a label that reads well in a meeting can be too long for a narrow phone. Placeholder text hides both problems until the visual design stage, when fixing them costs more.
How many screens does a first app wireframe need?
Enough to finish the main task from start to end, plus the screens people reach when something goes wrong. For the hypothetical repair shop that is four screens for booking and three more for a full day, a taken slot and a failed payment, before any account or settings screens are drawn.
- List the task’s steps in plain words before drawing anything.
- Give each step one screen, then merge any two that share a purpose.
- Add a screen for every way the task can stop.
- Leave accounts, settings and profiles for the second pass.
Wiring screens into a task
Screens on their own say little about the trip between them. NN/g’s article on wireflows defines a wireflow as wireframe style page layouts combined with a simplified flowchart for interactions, and notes the format grew up among teams designing mobile apps, where each step can show a full phone screen.
The rule that makes a wireflow useful is the starting point of each arrow. An arrow should leave from the exact part people tap, not from the edge of the screen, so nobody has to guess which of three buttons leads where. In Figma’s prototyping guide, the same parts have names: the hotspot is where the interaction takes place, a connection joins it to the destination, a flow is the network of connected frames on one page, and each flow has its own starting point.
| Flow | Starts on | Steps | Ends on |
|---|---|---|---|
| Book a repair | Service | Choose a service, pick a time, confirm drop off | Booked |
| Change a booking | Booked | Open the booking, pick a new time, confirm | Booked, with the new time |
| Cancel a booking | Booked | Open the booking, confirm the cancellation | Home, with a message |
| No times left | Time | See the next day with open slots | Time, on that day |
| Slot taken while choosing | Time | See a message and the nearest open time | Time, with that slot marked |
Wireflow or flowchart?
Use a wireflow when a few screens change with what people do, which describes most apps; use a flowchart when the logic behind the screens has many branches, such as eligibility rules. Many teams draw both and keep the flowchart for developers.
An app idea that lives in a notes file?Send the notes and the one task customers should finish. You get a free proposal for app design wireframes that turn the idea into screens your team can argue over.
Get a free proposalTell us about a project you’d like help with.
Annotation: the notes that keep two people reading one box the same way
Annotations turn a picture into a specification. Figma’s annotation feature lets designers attach notes and live properties to a layer, and its design files come with four preset categories: Development, Interaction, Accessibility and Content.
| Category | What the note covers | Example on the Pick a time screen |
|---|---|---|
| Development | Data, rules and limits | Times come from the shop calendar; past times never show |
| Interaction | What a tap, swipe or hold does | A taken slot shows the next open time |
| Accessibility | Focus order, labels and alternatives | Day strip scrolls with buttons as well as a swipe |
| Content | Words, lengths and tone | Button text is Book plus the time, up to 14 characters |
Figma says annotation properties stay accurate when the design later changes, and developers see annotations update in real time in Dev Mode. Adding annotations needs a Professional, Education, Organization, Government or Enterprise plan and a Full seat; reading them needs a Full or Dev seat and at least view access to the file. The same notes work just as well as numbered pins on a paper sketch; the tool only keeps them attached as the screen moves.
Which accessibility notes belong on a wireframe?
The W3C’s mapping assigns a set of tasks to user experience designers, and several of them are wireframe decisions rather than visual ones. The list below paraphrases the ones that matter most for an app; W3C states that the mapping does not set WCAG requirements and is not a complete list.
- Plan keyboard focus states for every active element.
- Include hover and focus behavior with the design files.
- Give gesture based actions a single pointer alternative.
- Give anything that needs dragging a single pointer alternative too.
- Keep information relevant to a form above its submit button.
- Show error messages and alerts the same way across the app.
- Avoid moving focus automatically from one form field to the next.
The W3C’s designing for accessibility tips add points that start in the wireframe too: clear and consistent navigation, form fields with clearly associated labels, and designs for different viewport sizes.
Wireframe in software development: who reads it, and for what
A wireframe in software development is read by more people than the ones who drew it. Each reader looks for something different, and a wireframe that answers only the designer’s questions leaves the rest to guess.
| Reader | Reads the wireframe for | Wants answered before work starts |
|---|---|---|
| Business owner | Whether the flow matches how the business runs | Is every rule and exception covered? |
| Product lead | Scope of the first release | Which screens wait for version two? |
| Developer | Data, states and behavior | Where does each value come from, and what if it is missing? |
| Tester | Paths and edge cases | What should happen at every dead end? |
| Content writer | Labels, messages and lengths | How much room does each line have? |
The developer row matters most for cost. Every value on a screen comes from somewhere: a calendar, a price list, the person’s account. A note that names where each value comes from, and what the screen shows if it is missing, removes most of the questions that otherwise arrive halfway through a sprint. Our MVP development company page explains how a first release is scoped once the flow is agreed.
Should developers see wireframes before they are finished?
Yes, at the gray box stage. A developer who sees the flow early can flag a value the system cannot supply or a step that needs a slow outside service, while moving a box still costs nothing.
From wireframe to prototype
A prototype is a wireframe you can tap. Figma’s prototyping guide lists what a prototype is for: previewing interactions and user flows, sharing and iterating on ideas, getting feedback, testing interactions with users and presenting to stakeholders.
In Figma the step is small: the annotated frames gain connections from their hotspots, each connection gets a trigger such as a tap, and an animation sets how one frame moves to the next, with a duration between 1 millisecond and 10 seconds. Overlays handle menus, alerts and confirmations without new full screens. The GOV.UK Service Manual adds a warning for prototypes built in code: they need not meet production standards, so their code should not be copied straight into the live service, and a published prototype should sit behind a password so the public does not mistake it for the real thing.
- Freeze the annotated wireframes for the flow being tested.
- Connect every hotspot on the flow, including back and cancel.
- Add the failure states as overlays or extra frames.
- Set the prototype to the phone size most customers use.
- Test with people who match the customers, one task each.
How those sessions are run and recorded is covered on our usability testing services page.
What changes between the last wireframe and the first prototype?
Very little on the screen and a lot in the file: the frames gain connections, triggers and overlays, and the failure states become reachable. Visual polish can stay out; a gray prototype tests the flow just as well.
Tools for app design wireframes
The right tool is the one that keeps the current question cheap to answer. Pencils win at the start; a shared design file wins once notes and connections matter.
| Tool | Suits | Worth knowing |
|---|---|---|
| Paper and pencil | First sketches and wireframe sessions with the owner | Nothing to install; cheapest to throw away |
| Whiteboard or FigJam board | Mapping a whole flow with several people at once | Good for the list of screens, weak for detail |
| Balsamiq | Low detail wireframes in a deliberately sketchy style | Its own guide pitches it to non-designers as well as designers |
| Figma Design | Gray boxes, notes, wireflows and the prototype in one file | Annotations need a paid plan and a Full seat |
| Figma First Draft | A fast starting point from a written prompt | Builds from Figma’s own libraries, not your design system |
Many teams pick the wireframe software development teams already open every day, so notes and status live where the build happens. For the hypothetical repair shop that means paper for the first session, then one Figma file that carries the gray boxes, the notes, the wireflow and the prototype.
Can AI draft the first wireframe?
It can draft a starting point. Figma’s First Draft turns a written prompt into editable wireframes or designs in a couple of minutes, using wireframing and design libraries Figma built for the purpose. Figma notes it does best with common website and app patterns, and that it cannot yet generate from your own design system; from May 20, 2026 Figma’s agent is the new entry point for the feature. A draft still needs the purpose lines, states and notes a person writes.
A wireframe for app design reviews: ten questions
A review works best as a checklist read aloud with the owner, the designer and a developer in the room. The chart runs the hypothetical booking flow’s second pass through ten points; eight pass and two states are still undrawn.
- Does every screen state its one purpose?
- Is the main action labeled with what happens?
- Do choices carry over between screens?
- Does every arrow start at something people can tap?
- Are placeholder labels gone?
- Is keyboard focus planned for every control?
- Does every drag have a single tap alternative?
- Is form help above the submit button?
- Is every way the task can stop drawn?
- Could a developer build each screen without asking a question?
Who should sign off a wireframe?
The person who owns the business rules, not only the person who likes the look. Sign off means the flow matches how the business runs, including the exceptions; the look is agreed later, at the visual design stage.
Four habits that make wireframes expensive
Wireframes fail quietly. Each habit below produces a tidy drawing that still leaves the expensive questions for the build.
- Drawing only the happy path, so the first full day of bookings breaks the screen.
- Using labels like Map or Button that each reader fills in differently.
- Polishing color and type before the flow is agreed, which turns reviews into taste debates.
- Handing over screens without notes, so developers measure and guess.
The cure for all four is the same: one purpose line per screen, real words, numbered notes and a wireflow that shows every exit. A related view of the whole product design discipline sits on our product design agency page.
What app wireframing costs
Wireframes are rarely bought on their own; they are the first part of an app design or prototype project. The bands below run from the typical low to the published high in the US market.
| Work | Typical low to published high |
|---|---|
| Clickable prototype, wireframes through a tested flow | $8,000 to $25,000 |
| App UI and UX design, one platform | $8,000 to $25,000 |
| App UI and UX design, iOS, Android and web | $20,000 to $40,000 |
| Full product design project | $10,000 to $100,000 |
| Cross platform mobile MVP build that follows the design | $40,000 to $90,000 |
Progression sets its price in the written proposal, after scope, and it is subject to change. The full design service is described on our UI/UX design services page, and design and build costs together in our app development cost guide.
Why do two wireframe quotes differ?
Usually because they cover different amounts of the app. Count the flows, the failure states, the platforms and the review rounds in each quote; a cheaper quote often stops at the main screens and leaves the states and notes for later.
Wireframes that nobody can build from?Share the file. The free proposal covers the missing states, notes and flows before any code is written.
Get a free proposalTell us about a project you’d like help with.
Pricing depends on scope and is confirmed in a written proposal. Published prices are subject to change.
Inputs that make the first sketches useful
The first wireframing session moves fastest when the business rules are written down before anyone draws. The card lists six inputs.
- The one task customers should finish.
- How they do it today.
- Every piece of information the business needs from them.
- Opening hours, limits, prices and exceptions.
- The words customers already use.
- Who signs off, and who builds.
Teams planning a build alongside the design can compare iOS app development, Android app development and cross platform app development.
What this page leaves out: the Progression Method, proprietary and reserved for clients. Reach out to learn more
Getting found in search
AI, AEO and what is changing
Paid media and lead generation
Websites and design
Choosing and working with an agency
Software and app development
Website design by industry and type
Web development, platforms and hosting
Social, content and brand
By industry and by situation
Frequently asked questions
What are app design wireframes?
How detailed should an app wireframe be?
Is a wireframe the same thing as a mockup?
Should wireframes use real words?
What goes on every mobile app wireframe screen?
How many screens should the first wireframes cover?
What is a wireflow?
Which annotation categories does Figma provide?
Which Figma plans can add annotations?
Do developers need a paid seat to read annotations?
Which accessibility decisions belong in a wireframe?
Is paper prototyping still worth doing?
Can AI create an app wireframe?
When does a wireframe become a prototype?
Can prototype code go straight into the finished app?
How does a user flow relate to a single wireframe screen?
Where do wireframes sit in the app design process?
Who should review app design wireframes?
What do app design wireframes cost?
Which business details help the first wireframing session most?
Does Progression’s team also build the app after the wireframes?
An app idea that lives in a notes file?Send the notes and the one task customers should finish. You get a free proposal for app design wireframes that turn the idea into screens your team can argue over.
Get a free proposalTell us about a project you’d like help with.
Get a free marketing proposal
Tell us what you are trying to grow and we will come back with a plan, not a pitch deck. Same-day reply on weekdays.
