How Web Developers Should Structure Client Payments

Holdyn · Apr 8, 2026 · 5 min read

FreelancersGuides

6 min read

Web development is one of the industries most affected by payment disputes. The work is complex, subjective (“I don’t like how it looks”), and often involves clients who don’t understand the technical effort behind a “simple” change.

If you’re a web developer or agency, here’s how to structure your client payments to eliminate non-payment risk while keeping clients happy.

Frequently Asked Questions

How do I handle scope creep on a fixed-price project?

Use amendments, not negotiations. When the client asks for out-of-scope work, propose a formal amendment: “Happy to add that — here’s the additional cost and updated timeline.” This turns every scope change into a priced decision instead of a free-work guilt trip.

What’s the right number of revision rounds to include?

Two rounds per milestone is standard. Any more and clients treat revisions as an unlimited resource. Beyond two rounds, bill at your hourly rate via a transaction amendment. Put this in writing before the project starts.

Should I charge a deposit or use milestone payments?

Milestones beat deposits for projects over $2,500. A deposit only covers initial risk; milestones distribute risk across the entire project. With a 25/25/35/15 structure, you’re never carrying more than one phase of risk at any time.

What hourly rate should I charge for revisions?

1.25x to 1.5x your effective project rate. If you’re charging $150/hour on the fixed price, revisions should be $180–$225/hour. This reflects the fact that revisions are interrupting other work and not planned for in your estimate.

How do I handle a client who disappears mid-project?

With funded milestones, you don’t have to chase. You stop working, the unreleased funds stay held by the platform until the dispute process kicks in. If the client comes back, you negotiate a partial release. If they don’t, you file a dispute with the platform and get paid for the completed phases.

TL;DR — The Better Payment Model

Stop using 50/50 splits — they create leverage imbalances
Use a 4-phase milestone structure — 25% Discovery, 25% Design, 35% Dev, 15% Launch
Handle scope creep with funded amendments — not awkward emails
Include a revision clause — 2 rounds included, then hourly billing

The Standard Mistake: 50/50 Split

Most developers use a 50% upfront, 50% on completion model. It seems fair, but it creates two problems:

The “final 50% hostage” situation: The client has leverage because you’ve delivered most of the work. They ask for “just a few more changes” before paying the final half — and those changes never end.
Scope creep isn’t compensated: If the project grows from 5 pages to 12, your 50/50 split doesn’t adjust.

The Better Model: 4-Phase Milestone Structure

Phase 1: Discovery & Architecture (25%)

Deliverables: Sitemap, wireframes, technical requirements document, hosting setup.

Why 25%: This phase involves the most strategic thinking. Undercharging for discovery signals that your expertise isn’t valuable.

Phase 2: Design (25%)

Deliverables: High-fidelity mockups for all pages, responsive breakpoints, design system/style guide.

Why 25%: Design is where client feedback is heaviest. Getting paid for this phase before development starts ensures you’re compensated for the revision cycles.

Phase 3: Development (35%)

Deliverables: Functional website on staging environment, all pages built, forms working, CMS configured.

Why 35%: This is the largest effort. By the time you reach this phase, the client has approved the design — development follows the approved spec.

Phase 4: Launch & Handoff (15%)

Deliverables: Production deployment, DNS transfer, training documentation, 30-day support window.

Why 15%: Small enough that the client doesn’t resist paying, large enough that you’re compensated for the launch effort.

Phase	Deliverables	%	Amount
Discovery	Sitemap, wireframes, requirements	25%	$2,500
Design	Mockups, responsive breakpoints, style guide	25%	$2,500
Development	Functional site on staging, CMS, forms	35%	$3,500
Launch	Deployment, DNS, training, 30-day support	15%	$1,500
Total		100%	$10,000

Handling Scope Creep

Scope creep is the #1 revenue killer for developers. The amendment approach handles it elegantly:

Client asks for additional pages/features not in the original scope
You propose an amendment: add $X to the current milestone or create a new one
Client reviews and accepts the amendment
Additional amount is funded to conditional payment
You do the additional work with compensation guaranteed

No awkward “this isn’t in scope” emails. The amendment is a neutral, documented process that both parties agree to.

The Revision Clause

Sample revision clause

“Each milestone includes 2 rounds of revisions on the delivered work. Additional revision rounds are billed at $150/hour and require a transaction amendment.”

This one clause eliminates 90% of “endless revision” problems. Clients are more thoughtful with feedback when revisions have a clear boundary.

Pro Tips

Front-load the first milestone: 20–30% covers your initial investment and signals serious commitment.
Keep the final milestone small: 10–15% gives the client incentive to approve quickly.
Include a “discovery” milestone: Charge for research and planning. This filters out tire-kickers.
Set realistic dates: Build in buffer. Delivering early beats missing a deadline.

Structure the Deal, Not Just the Code

The best code in the world doesn’t matter if you don’t get paid for it. Funded milestones, amendment-protected scope changes, and clear revision limits turn client payments from a negotiation into a system.

Holdyn handles all of this — event-based conditional payment with per-milestone funding, built-in amendments for scope changes, and digital contracts with e-signatures. Set up your next project in under 5 minutes.