Invoicing for Freelance Web Developers: Milestones, Retainers, and the Fee Math in Cents

Search for how to invoice as a freelance web developer and the results are template farms. Before writing this guide we fetched the top-ranking pages for this exact search in July 2026.

The best-ranked results are invoice template downloads from accounting vendors, padded with a ten-point list about remembering to number your invoices. The only practitioner-written how-to in the results was published in March 2023 and recommends a tool at a price that no longer exists. The freshest page, from January 2026, is published by Upwork and funnels you toward Upwork escrow, which is not advice, it is distribution.

Here is what none of them contains: a single processing-fee number. Not one ranking page tells you what a card payment actually costs you, what ACH costs instead, how to split a build into milestones so a dead project cannot take a month of unpaid work with it, or how to invoice the maintenance retainer that follows launch. Those four things are most of what invoicing means for a developer. So that is this article.

What belongs on a web development invoice#

A developer invoice needs about 9 elements, and the two that prevent disputes are line items tied to named deliverables and a stated payment term with a day count.

The basics are the same as any freelance invoice: your business name and contact details, the client's, a unique invoice number, issue date, due date, itemized lines, the total, payment methods, and the payment terms. What is different for dev work is what goes in the lines.

Write line items the client can recognize from the contract, not from your commit history. "Milestone 2: homepage and two interior page templates live on staging, $2,000" is checkable by a non-technical client. "Frontend refactor and component work, 14 hrs" invites a phone call. If you scoped the project with a statement of work, your invoice lines should quote its deliverable names verbatim, because an invoice that mirrors the contract is an invoice nobody can argue with.

Two developer-specific rules:

1. Separate pass-through costs from your labor. Hosting, premium plugins, API fees, and stock assets go on their own lines, at cost or with a stated markup, never blended into a milestone price. Blending them means you eat every renewal price increase silently.
2. Bill scope changes on their own line, backed by a change order. The "just one small tweak" request is the developer version of scope creep, and an invoice line that references a signed change order gets paid, while a surprise line does not.

Bill by milestone, mapped to the build#

Split any project over $1,000 into 3 or 4 milestone invoices, with a 30 to 40% deposit at signing and no single milestone over 25% on builds above $5,000.

The single end-of-project invoice is how developers end up financing their clients. Bonsai's analysis of invoices across its user base found invoices over $20,000 were 3 times more likely to be paid late than invoices under $100.

Big invoices wait. Small invoices tied to things the client just approved get paid.

We wrote a full guide to milestone billing; here is the split logic mapped onto a web build:

On an $8,000 site build at 30/25/25/20, that is $2,400 at signing, $2,000 when designs are approved, $2,000 at feature complete, and $1,600 at launch. The worst case at any point is one 25% phase, not the whole project.

Three rules make this work in practice:

1. The deposit is not negotiable. Work does not start before it clears; how much to charge and how to defend it is covered in our deposit guide.
2. Tie milestones to deliverables the client can see in a browser, not to dates or percent-complete claims. "Feature complete on staging" is checkable; "development 60% done" is a debate.
3. Put a deemed-acceptance clause in the contract. If the client goes silent on an approval for 5 business days, the milestone is approved and invoiceable. Silence is the number one way milestones stall, and if the client disappears entirely after delivery, we wrote the recovery playbook for that.

The launch milestone deserves one extra sentence in your contract: final deliverables, credentials, and repository transfer on receipt of final payment. You are not holding work hostage, you are sequencing the handoff, and the difference is that the sequencing was agreed in writing at signing.

Payment terms: net 7 beats net 30, and the data says so#

Set net 7 or net 14 on milestone invoices: FreshBooks' analysis of over 1 million invoices found 7-day terms get paid within a week 58% of the time versus 40% for 30-day terms.

Net 30 is a corporate accounts-payable convention, not a law of nature, and for a solo developer it is a month-long interest-free loan to the client. FreshBooks analyzed more than 1 million invoices and found invoices with 7-day terms were paid within 7 days 58.05% of the time, versus 40.22% for 30-day terms. The same dataset found invoices mentioning interest on late payment had the highest paid rate of any wording, at 92.15%.

Milestone invoices are small and follow an approval the client just gave, which is exactly when a short term is an easy ask. Send the invoice the day the milestone is approved, due net 7. For the full argument, including when net 30 is genuinely unavoidable with enterprise clients, see payment terms that get you paid in days, not months, and pair the term with a late-fee clause that holds up, covered in our late fees guide.

The stakes of getting terms wrong are not hypothetical. QuickBooks' 2025 late payments report found 56% of US small businesses are owed money from unpaid invoices, averaging $17,500 per business, and 47% have invoices more than 30 days overdue. Bonsai's invoice data puts the late rate for software developers specifically at 29% of invoices paid at least a day late. More late-payment numbers, all traced to primary sources, live in our freelance late payment statistics page.

The fee math in cents: card vs ACH vs PayPal#

On a $5,000 milestone, Stripe ACH costs $5.00 flat while a card payment costs $145.30, so asking US clients to pay by bank saves you $140.30 per milestone.

This is the section no ranking page has, so here it is with July 2026 rates pulled from the processors' own pricing pages. Stripe's standard US pricing is 2.9% plus 30 cents per domestic card transaction, and 0.8% capped at $5.00 for ACH direct debit. PayPal's business fee schedule charges 2.99% plus 49 cents when an invoice is paid by card, 3.49% plus 49 cents via PayPal checkout or Venmo, and 1% capped at $10.00 for pay by bank.

What that does to a $5,000 milestone invoice:

Every row is checkable: 2.9% of $5,000 is $145.00, plus 30 cents. 0.8% of $5,000 would be $40.00, but the cap brings it to $5.00.

Now annualize it, because per-invoice numbers hide the real cost. Take a developer billing $96,000 a year across 24 milestone and retainer invoices averaging $4,000 each. On cards through Stripe, that is $2,791.20 in fees for the year. On ACH, every one of those invoices hits the $5.00 cap, for a total of $120.00.

Moving your US clients from card to bank payment saves a developer billing $96,000 a year about $2,671 in processing fees. That is a config change, not a negotiation: offer both methods on the invoice and make ACH the first button.

Two footnotes on the math. If you use Stripe Invoicing to generate the invoices, Stripe adds 0.4% per paid invoice on its Starter plan on top of processing, which is another $20.00 on a $5,000 invoice, so an invoicing tool with a flat subscription can beat it at volume.

And if the money currently flows through a marketplace instead of a processor, the comparison is not even close: Upwork's freelancer service fee is variable from 0 to 15% per contract, set per client relationship, which is why we did the full real-cost math on Upwork fees separately. Whatever sends your invoices, the payment itself should land in your own Stripe or bank account, not in a tool that holds funds and takes a cut on the way through; here is why your client tool should never touch your money.

Maintenance retainers: the invoice that repeats#

Price maintenance retainers as prepaid hour blocks at your normal rate, invoiced on the 1st of the month, with unused hours capped at one month of rollover.

Launch is not the end of the billing relationship, it is the start of the good part. A maintenance retainer smooths the feast-or-famine cycle and turns a one-time project into recurring revenue, but only if the invoicing mechanics are set up so the retainer runs itself:

1. Price it as hours, not vibes. A block of prepaid hours at your standard rate: updates, security patches, small content changes, uptime checks. If your rate is $100 an hour, a 5-hour block is a $500 monthly retainer. Discount only in exchange for a term commitment, never just for recurring-ness.
2. Invoice on the 1st, due net 7, automatically. A retainer that requires you to remember to invoice is a part-time job. Recurring invoices with automatic reminders are the whole point.
3. Define what happens to unused hours. Rollover capped at one month is the fair middle ground. Unlimited rollover builds a liability you will eventually eat; use-it-or-lose-it feels punitive and invites cancellation.
4. Pause on nonpayment. The retainer agreement should say the retainer, and response times with it, pause when an invoice is 14 days overdue. This clause does the collections work for you.
5. Scope the "small tweak" boundary. Anything over 2 hours or touching new functionality is quoted separately as a project or a change order, not absorbed into the block.

The agreement itself matters as much as the invoice. Our retainer agreement template covers the clauses, including the pause and rollover language above.

When the invoice goes unpaid#

Escalate on a calendar, not on a mood: reminders at 3, 7, and 14 days overdue, a phone call at 21, and know that in Illinois and California the law now puts double damages behind you.

Most late invoices are not malice, they are inbox decay, which is why the fix is a scheduled reminder cadence rather than a confrontation. We keep a full set of payment reminder email templates by days overdue, and the escalation ladder covers what happens after reminders stop working, from demand letter to small claims.

Developers also have a legal floor under them now that most ranking pages have not noticed. Illinois' Freelance Worker Protection Act applies once work is worth $500 in a 120-day period: the client owes you a written contract, payment within 30 days of completion if no date is set, and the statute entitles you to double the unpaid amount plus attorney's fees in a civil action.

California's SB 988 does the same for contracts from January 1, 2025 at a $250 threshold, with damages up to twice the unpaid amount plus $1,000 if the client refused to put the contract in writing. New York has been there since 2024. State by state coverage is in our freelance payment laws guide.

One thing not to do: do not take the client's site down over an unpaid invoice. It feels like leverage, but self-help against infrastructure the client believes they own creates legal exposure that dwarfs the invoice. The contract-based versions of leverage, pausing work, withholding final deliverables until final payment as agreed at signing, and the statutes above, are stronger and cleaner. The full playbook for a systematic approach is in how to get clients to pay invoices on time.

The tooling: what actually sends all this#

One flat-priced tool should generate the milestone invoices, run the recurring retainer, chase the reminders, and let the client pay by ACH, and it should cost less than the fee savings it produces.

Everything above is a system: milestone invoices triggered by approvals, recurring retainer invoices, scheduled reminders, ACH as the default rail. You can run it from a spreadsheet, a calendar, and Stripe directly, and at one or two clients you probably should. Past that, the admin time is the cost. We quantified the leak at around 6 unbilled hours a week for a typical solo.

This is the workflow Raoura was built around (disclosure: Raoura is our product). It is $17 a month flat, and it does the specific things this article argues for: milestone invoices tied to deliverables in a client portal where approvals are visible, recurring retainer invoices, automatic reminder schedules, and payments that go through your own Stripe account, so you keep the processor relationship and the ACH fee cap, and Raoura never touches the money. If you would rather assemble the stack yourself, our minimalist freelance stack guide prices out the alternatives honestly.

!Raoura project milestones view tying each milestone to a named deliverable and its invoice

Milestones named after deliverables the client can check is what makes invoice-on-approval run itself instead of stalling in a debate.

!Raoura reminder settings scheduling automatic payment reminders on overdue invoices

The reminder cadence from the section above works because software sends it on schedule, not because you remembered to.