Ten screens. At first glance, that's almost a brief: send it to a few designers and compare their quotes.
But app design cost doesn't fit neatly into that description. A list screen might be a simple view. Or it might depend on permissions, approval status, missing data, and something the user did a minute ago. The cover page of the proposal won't reveal the difference.
I'd rather understand how many decisions are hiding behind that screen list. And who will make them if the estimate leaves them out.
Let's price one form
Take a hypothetical expense approval app. This is an example to explain scoping, not a client story. An employee enters an amount, attaches a receipt, and submits the request to a manager. One screen, apparently.
What if the attachment fails? The connection drops? The request has already gone through, but the employee taps Submit again? The manager sends it back for clarification? Someone changes the amount after approval?
Some questions belong to the interface, others to product rules and back-end implementation. The user still needs a clear answer. If the designer doesn't work it out, a developer, a project manager, or a production error will make the decision instead.
So “the same scope, but without the states” makes me wonder who's going to design those states. They haven't gone anywhere.
What changes the estimate before visual design starts
The employee and manager work with the same request but need different views and actions. Add an accountant, and there's another task to define: which documents they need, what they can correct, and when.
The number of roles isn't a price tag by itself. What matters is how different their work is. Two similar permission levels may take less effort than one role with a complicated set of exceptions.
Then there are platforms, real data, and existing components. Mobile app design needs to account for phone behavior rather than a smaller desktop layout. A component library helps when the elements and states you need actually exist. A folder of buttons without usage rules still leaves work ahead.
Research needs a purpose, too. If the approval process is already documented and validated, there's no reason to rediscover it for the sake of an impressive process. If nobody knows why requests keep getting sent back, skipping that question may produce a very tidy version of the existing confusion.
What happens between the first conversation and handoff
A project generally needs an understanding of the constraints, connected user flows, a prototype, validation of uncertain decisions, detailed UI, and design handoff. I wouldn't assign universal budget percentages to those stages. In one product, the big unknown comes before the first screen. In another, it appears when we try to build the interface with existing components.
Each stage should produce something useful. Discovery establishes what we're designing and what we don't know. A prototype lets someone attempt the task. Testing provides reasons to keep or change a decision. UI design defines visual rules and states. Handoff helps the developer implement behavior without guessing.
“Research included” doesn't help much unless you know what will be researched. “Delivered in Figma” has a similar problem: access to a file doesn't necessarily mean the design is ready to build.
If you already have an estimate, send it with a description of the task. I'll review what's covered and which decisions might unexpectedly fall to your team
How to reduce the budget without leaving the main task unfinished
In our hypothetical app, you could postpone a complex approval chain and start with one approver. You could skip a separate analytics area if an export is enough initially. Those choices reduce the product that needs designing and supporting.
Leaving submission errors and recovery undefined pushes uncertainty downstream. The main action still needs to survive ordinary problems: no connection, an unsupported file, someone returning later.
I'd frame scope reduction this way: which task must the first release complete reliably? Which exceptions can temporarily be handled manually, who will handle them, and will the user understand what's happening? Now there are choices to make. “The same thing, only cheaper” doesn't say which part of the product you're willing to give up.
Comparing two proposals for the same task
Before hiring an app designer, give candidates the same starting information. Otherwise, you're comparing their assumptions about the project rather than prices for the same work.
| What to ask | Why it matters |
|---|---|
| Which roles and user flows are included? | Defines the release scope |
| Which states will be designed? | Keeps missing behavior out of the developer's backlog |
| What will be tested, and with whom? | Clarifies the research and validation work |
| What does the developer receive? | Establishes implementation readiness |
| How are changes agreed on? | Explains the impact of new requirements |
| Is implementation support included? | Identifies who answers questions after handoff |
Designing an app and shipping a working product involve different commitments. Code, server-side permissions, integrations, and ongoing operations need to be named separately, particularly when money or sensitive data is involved.
What to bring to the first conversation
You don't need a huge document prepared in advance. I'd first like to see how the task works today: who does what, where someone waits for another person, and what happens when a request is rejected.
Add the constraints: a required platform, existing code, available data, an actual deadline. If the date comes from “we'd like it next month,” that's useful information, too. It's simply different from a date already committed to a partner under contract.
Getting the scope right also means agreeing on what won't be in the first release. That list can save more discussion later than another polished reference board.
Where I come in
I help define the work, test uncertain decisions, and carry the interface into implementation within the agreed scope. There isn't a universal per-screen rate for that. First, we need to understand what happens behind the screen.
For choosing an engagement model, see in-house designers, freelancers, and agencies. If your product supports several working roles, see B2B app design.
Send me the main task or an existing interface. We'll look at what the first release needs and which unknowns are still driving the estimate
Sources and limitations
The expense approval app is hypothetical. It illustrates design decisions, not a completed client project or an implementation for processing payments. No prices, budget percentages, or client outcomes are claimed. The article describes my approach to scoping and comparing proposals.






