Web development invoices bill milestones on fixed-scope projects (typical builds: marketing sites $3,000–$25,000, e-commerce $10,000–$75,000+, custom applications quoted per scope), hourly ($60–$200) or per sprint on ongoing work, and monthly retainers for maintenance ($100–$2,000+). Standard structure: 30–50% deposit, milestones at design approval and development complete, balance at launch — with scope changes billed as labeled change requests, third-party costs (hosting, plugins, APIs) passed through, and code/site handoff occurring at final payment.
Web Development Invoice Template
Reviewed by the Agiled editorial teamUpdated June 2026
Web projects have a scope problem by nature — 'one more page,' 'can it also sync with our CRM,' 'small change' requests that are architecture changes wearing a disguise. The invoice is half of the defense (the contract is the other): milestones tied to defined deliverables, change requests as labeled lines with their approval referenced, third-party costs passed through visibly, and the site handed over when the final invoice clears. This template carries that structure for project, hourly, sprint, and maintenance billing. Download it in PDF, Word, Excel, Google Docs, or Google Sheets, or generate a pre-filled version below.
Part of our free invoice template library — 80+ industry-specific templates in PDF, Word, Excel, Google Docs, and Google Sheets.
Your Company Name
123 Business St, City, State 12345
billing@yourcompany.com
INVOICE
INV-0001
Bill to
Client Company
Due
Net 30
| Description | Qty | Rate | Amount |
|---|---|---|---|
| Frontend development | 30 | $110.00 | $3,300.00 |
| Backend API development | 20 | $130.00 | $2,600.00 |
| Server setup and deployment | 1 | $400.00 | $400.00 |
Download this invoice template
Pick a style, choose a format, and download — generated locally in your browser.
Style
Format
Fixed layout for sending and printing
Word
Editable in Word or Google Docs
Excel
Live formulas for recurring invoices
Or create and send invoices online
Create online- Hourly
- $60 – $200
- Marketing site build
- $3,000 – $25,000
- Deposit
- 30 – 50% before work begins
- Maintenance retainer
- $100 – $2,000+ / month
What to include on a web development invoice
Milestones named and tied to deliverables
"Milestone 2 — development complete on staging, client review 6/10 — $6,000." Milestones bill against observable states, not percentages of feelings.
Deposit credited on every project invoice
The 30–50% kickoff payment shown by date, subtracted to the running balance — the ledger view that keeps a three-month build's money conversation calm.
Scope changes as labeled change requests
"CR-3 — member login + gated content per approval 5/22 — $2,400." Quoted, approved in writing, then built. The CR line is the web dev change order.
Hourly/sprint work summarized by feature
"Checkout flow refactor — 14 hrs @ $120" beats raw time dumps. Sprint billing states the sprint number, dates, and committed scope.
Third-party costs passed through
Hosting, premium plugins/themes, API fees, stock assets — at cost with the service named, and renewals assigned (client's card on their own accounts wherever possible).
Maintenance retainer scope
"Monthly maintenance — updates, backups, security monitoring, 2 hrs content changes — $350." Included capacity stated; overflow at the stated rate.
Handoff terms
"Site, code, and credentials transfer on final payment." The clause that collects the last invoice — until it clears, the work lives on your staging.
Typical web development pricing (U.S., 2026)
| Work | Typical range | Notes |
|---|---|---|
| Hourly rate | $60 – $200 | Specialists $150 – $250+ |
| Marketing / brochure site | $3,000 – $25,000 | Page count and design depth |
| E-commerce build | $10,000 – $75,000+ | Platform and integrations |
| Custom web application | $25,000 – $250,000+ | Per scope; sprint-billed |
| Landing page | $500 – $3,000 | |
| Maintenance retainer | $100 – $2,000+ / month | Scope-dependent |
| Rush premium | +25 – 50% | Stated before acceptance |
| Deposit | 30 – 50% | Before work begins |
Ranges reflect freelance and small-studio pricing; agency rates run higher. Application work is better billed by sprint or time-and-materials than fixed-bid when scope is genuinely uncertain.
How web development billing actually works
Fixed-scope builds: the milestone arc
Site builds bill deposit (30–50%) at kickoff, a milestone at design approval, another at development-complete-on-staging, and the balance at launch — each invoice naming its milestone with the deposit and prior payments credited. The protective detail is an acceptance window in the contract (client review within X business days; silence advances the milestone) so invoices can't stall on an unreviewed staging link. Content delays — the classic launch killer — are handled by billing development-complete when your work is done, not when their copy arrives.
Ongoing development: hourly, sprints, retainers
Post-launch and application work bills hourly (summarized by feature, invoiced biweekly or monthly) or per sprint — the sprint invoice states the number, dates, and committed scope, due Net 15. Maintenance retainers invoice at the month's start with included scope stated and overflow at the stated rate; they convert one-off clients into recurring revenue and the invoice's scope line is what keeps 'maintenance' from silently becoming unlimited development.
Scope changes and the CR discipline
Mid-project change requests get a number, a quote, and a written approval before a line of code — then bill as labeled CR lines on the next milestone invoice. The same discipline covers the 'small change' that's actually architectural: the CR quote is where the client learns the difference, politely, with numbers. Third-party surprises (the API that needs a paid tier, the plugin license) pass through at cost with the client's approval referenced — never absorbed, never marked up silently.
Invoicing mistakes that cost web development professionals money
Billing percentages instead of milestones
'50% complete' is unverifiable and argues badly. Bill observable states: design approved, staging live, launched. If a milestone can't be demonstrated, it isn't one.
Building unapproved changes
Scope absorbed mid-sprint compounds into a project that ships late and bills the same. Quote the CR, get the yes in writing, then build — the discipline trains the client more than any contract clause.
Handing off before final payment
DNS pointed and credentials transferred make the last invoice optional. Launch on final payment — stated as policy from the proposal onward, applied without drama.
Owning the client's third-party accounts
Hosting and licenses on your card become your liability and their hostage situation. Client accounts, client cards, your management — pass through only what can't be moved.
Letting content delays stall billing
Projects that wait months for client copy shouldn't freeze your receivables. Bill development-complete when your scope is done; the contract's content-delivery terms carry the rest.
How to use this template
- 01
Download the template in your preferred format, or generate a pre-filled version with the download studio above.
- 02
Add your business details and the project/SOW reference.
- 03
Collect the deposit, then bill named milestones tied to observable deliverables, crediting prior payments.
- 04
Bill scope changes as numbered CR lines referencing written approval.
- 05
Pass third-party costs through at cost, with renewals on the client's own accounts.
- 06
State handoff-on-final-payment, run maintenance retainers monthly in advance, and use Net 15–30 on ongoing work.
Skip this template if…
- Pure design engagements delivering mockups — the graphic design template's rights-on-payment structure fits better.
- Long-term staff augmentation — placement and contract-labor billing differs from project invoicing.
FAQs
How much does web development cost?
Freelance rates run $60–$200/hour. Project pricing: landing pages $500–$3,000, marketing sites $3,000–$25,000, e-commerce builds $10,000–$75,000+, and custom applications from $25,000 well upward, usually sprint-billed. Maintenance retainers run $100–$2,000+ monthly by scope.
How should web projects be billed — fixed price or hourly?
Fixed price with milestone billing for defined builds (the client gets certainty, you get the CR process for changes); hourly or per-sprint for application work and genuinely uncertain scope. The failure mode is fixed-bidding uncertain scope — that's how studios fund their clients' indecision.
What milestones should a web development invoice use?
Observable states: deposit at kickoff (30–50%), design approval, development complete on staging, and launch. Each invoice names its milestone and credits prior payments. An acceptance window in the contract (review within X days, silence advances) keeps milestones from stalling on unreviewed work.
How do developers handle scope creep on invoices?
With change requests: each mid-project addition gets a number, a quote, and written approval before it's built, then bills as a labeled CR line. The visible process converts 'one small thing' from margin erosion into revenue — and teaches clients the difference between a tweak and an architecture change.
When should the client get the code and credentials?
At final payment — the standard handoff clause keeps the site on the developer's staging until the closing invoice clears, then transfers the site, repository, and credentials. Stated from the proposal onward, it's the single most effective collection mechanism in web work.
How should hosting and plugin costs be billed?
As pass-throughs at cost with the service named — and wherever possible, on the client's own accounts and card with the developer holding admin access. That keeps recurring liabilities (renewals, payment failures, ownership) where they belong while the maintenance retainer covers the management labor.
Need sending, reminders, and payments too?
Turn this template into a full invoicing workflow with Agiled.