You can’t quote what you don’t understand. Every freelancer has tried to bid on a project where half the scope is “we’ll figure it out” and lost either the deal (by padding the number) or the weekend (by absorbing the difference). There’s a third option that works better than both.
Splitting the project into discoverable pieces lets you quote project unknowns honestly without gambling. The structure does the heavy lifting, and the numbers stop being the hard part.
Why a single fixed price on an unclear project is the worst move
When you bid one fixed number on a project with serious unknowns, two things can happen:
- You pad 30 to 50 percent for safety and lose the deal to a freelancer who quoted lower (and is about to eat the difference themselves)
- You quote honestly, scope expands, you absorb 40 unpaid hours
Both outcomes are bad. The single-number fixed quote rewards optimists and punishes realists, which is exactly backwards.
The fix: stop pretending you can quote what you can’t see yet. Structure the quote so the unknown portion gets priced when it stops being unknown.
The discovery phase pattern
The cleanest way to quote project unknowns: small paid discovery first, full build quote after.
Discovery phase structure:
- Fixed price (typically 500 to 3,000 depending on project size)
- Fixed timeline (1 to 3 weeks)
- Deliverable: written scope document plus real build quote
- Either party can walk away after discovery with no further obligation
The pitch to the client:
“Two ways we can go. I can quote the full project today with a wide range (somewhere between 18K and 30K, honestly), or we can do a 2-week discovery phase for 2,400 that produces a real number plus a clear scope doc. Most clients prefer discovery because the build quote at the end has no unknowns left.”
That framing usually wins because the alternative, a giant padded blind quote, looks worse next to a small concrete first step.
What discovery actually produces
A discovery phase that’s worth charging for produces real artifacts:
- A scope document listing every deliverable, with assumptions called out
- A dependency list (third-party APIs, content sources, external decisions)
- A timeline with milestones
- A real build quote with no wide ranges
- A list of risks and what would change the price
That’s a deliverable the client can use even if they don’t hire you for the build. It’s not a sales document. It’s a planning document.
The freelancer mistake I see most often: treating discovery as glorified sales work. Real discovery is real consulting. You’re being paid to think, and the document reflects that thinking.
The capped hourly alternative
When discovery isn’t a fit (small project, time-sensitive, client wants one number), the next-best move is capped hourly for the unknown portion.
Example quote for a website with an unknown API integration:
| Item | Pricing | Amount |
|---|---|---|
| Design and front-end build | Fixed | 8,400 |
| CMS setup | Fixed | 1,200 |
| Third-party API integrations | Hourly, capped | 130/hr, max 5,200 |
| Total max | 14,800 |
The client sees a maximum, which is the number they budget against. You see an hourly bill for the unknown work, which protects you if the API turns out to be a mess. Both sides know the ceiling.
The cap is the magic. A pure hourly quote scares clients because the ceiling is unknown. A capped hourly quote is just a fixed price with permission to underrun.
The language that makes unknowns feel safe
A few sentences that calm client anxiety about quote project unknowns:
- “I won’t bill above the cap without writing you first.”
- “If we hit the cap and the work isn’t done, we re-quote together, no surprises.”
- “If the work comes in under the cap, you pay actual hours, not the cap.”
Each one reduces the gamble. The client isn’t signing a blank check; they’re signing a worst-case ceiling with a path back to the table if reality changes.
How to phrase the unknowns in the quote itself
Don’t hide unknowns. Name them in the quote so the client knows what you’re not promising.
“Assumptions and unknowns:
- This quote assumes the existing CMS data is in a clean export format. If migration requires data cleanup, that’s quoted separately.
- Integration scope assumes the third-party API has documented endpoints for [X, Y, Z]. If endpoints don’t exist or require custom work, we’ll re-quote that portion.
- Timeline assumes content is provided by [date]. Delays on content shift launch.”
Each assumption is one sentence and names exactly what you’re not promising. The client either confirms the assumptions or surfaces the gap, and you’ve protected yourself either way.
The “I’ll write the scope for free” trap
When a client asks for a detailed quote on an unclear project, the wrong move is to spend 8 hours writing a free scope document hoping to land the work. You’re doing paid work for free, which trains the client to expect free work. You’re competing with freelancers who quoted in 30 minutes, so you’re either too expensive or too slow. And if you don’t win the project, you’ve done 8 hours of unpaid consulting for nothing.
The right move is a brief proposal (1 to 2 pages) that outlines the discovery phase, the rough scope of the build, and the next step. Anything deeper goes inside the paid discovery.
When to walk away from an unquotable project
Some projects shouldn’t be quoted by anyone. Signs:
- The client cannot describe what success looks like
- Three meetings have passed and the scope keeps mutating
- The client wants “an estimate” but won’t pay for discovery and won’t provide a spec
- The budget is fixed at a number that doesn’t fit the work, no matter how scoped
These projects are not waiting for the right quote structure. They’re waiting for clarity that may never come. Decline politely:
“Based on our conversations, the scope feels like it’s still forming. I don’t think I can give you a useful quote without a discovery phase, and I understand if that doesn’t fit your process right now. Happy to revisit when the scope is more defined.”
That note keeps the door open without committing you to bid-by-vibes.
The phased quote for big projects
For larger projects, multiple phases of work can each be quoted as scope clarifies.
Example phasing for a custom app build:
- Phase 1: Discovery and design (4,800 fixed, 3 weeks)
- Phase 2: MVP build (quote after Phase 1, estimated 25K to 40K)
- Phase 3: Iteration and polish (quote after Phase 2, hourly capped)
Each phase has a real number when you start it, not a guess. The client commits one phase at a time, you quote one phase at a time, and the relationship has natural off-ramps where either side can stop.
This works better than a single 60K quote with eighteen unknowns inside it.
The shortest version of the framework
If you remember nothing else: never quote a single fixed number on a project you can’t see clearly. Use a paid discovery phase, or capped hourly for the unknown portions, or both. The structure of the quote is what protects you. The number on the bottom is just math you can only do once you’ve seen the work.
Ready to send stronger proposals?
Build, send, and track proposals in one place so follow-up is easier.
Start your free trial →
