DEV Community

Karactif Tech
Karactif Tech

Posted on Edited on

Invoicing for Web Developers: Bill the Build, the Change Request, and the Handover

Invoicing for Web Developers: Bill the Build, the Change Request, and the Handover

The site went live on a Thursday. DNS cut over at 2pm, the client's marketing lead sent a thumbs-up, and you closed the laptop feeling good. The invoice went out eleven days later, because you had already started the next project and the numbers had to be rebuilt from a repo you had stopped reading.

In those eleven days, three things happened: the client asked for "one small tweak" that became four hours, the annual hosting renewal landed on your card, and nobody could remember whether the extra API integration was in scope or a favour. None of it made it onto the invoice, because the invoice was written from memory.

Developer billing rarely fails at the rate card. It fails at the trail — the link between what was agreed, what was built, and what is being charged for.

Why developer invoicing drifts

Fixed price, moving scope. You quote a build, the client discovers what they actually want halfway through, and the difference gets absorbed silently because raising it feels like a confrontation.

The fifteen-minute problem. Small asks are individually too trivial to invoice and collectively a second project. Absorb four a week and you have donated a day a month.

The deploy gap. Launch day is peak goodwill. Two weeks later, when the invoice usually gets written, the details are cold and the client has moved on.

Four things that should never share a line

Most disputed developer invoices collapse four different commercial relationships into one number:

  1. The build — scoped work, billed against milestones.
  2. Change requests — work outside scope, billed as approved.
  3. Pass-through costs — domains, hosting, licences, stock, APIs.
  4. Care and maintenance — the retainer, billed on a schedule.

"Website — $9,500" tells the client nothing about which of these they are paying for, and gives you nothing to point at when the next ask arrives.

Milestones beat one big number

One invoice at the end of a six-week build means you finance the project and the client meets the cost once, as a shock. Milestones fix both.

Tie each invoice to a verifiable event rather than a date: deposit on signature, a draw when staging is approved, a draw at content freeze, the balance at handover. When the invoice says "Milestone 2 — staging approved 06/11", the client can match it to something they did, and payment stops being a judgement call. Do not invoice a milestone you cannot demonstrate, and do not make the last one small enough that finishing is optional for the client.

Change requests need an ID, not a memory

Number every change request the moment it is approved, whatever the channel: email, ticket, Slack thread, issue tracker. A usable invoice line looks like this:

CR-14 — add Stripe webhook retry handling, approved by email 06/11 — 3.5 hrs @ $85

That line proves the work was authorised, dates the approval, and separates the charge from the original quote so nobody compares it to the proposal total. Without an ID, the same work reads as an unexplained overage, and you will discount it to keep the peace. Decide in advance whether change requests are hourly or quoted as small fixed pieces; both work, switching mid-project does not.

Pass-throughs: domains, hosting, licences

Third-party costs are where freelance developers quietly lose money, usually by paying a renewal in month nine and never rebilling it.

Pick a policy, state it on the first invoice, and keep to it: rebilled at exact cost with receipts on request, or at cost plus a small handling percentage. Then itemise — "Hosting, 12 months, renews 03/2027 — $240" is budgetable; "expenses — $410" invites a breakdown request. Put renewal dates on the invoice and the client will not treat a charge six months later as an invention.

If you quote in euros, invoice in euros. Converting after the fact is you volunteering to absorb the difference.

The handover invoice

Handover is a defined event: repository access, credentials, DNS, analytics, documentation, plus a short note listing what was delivered and what the warranty covers. Invoice it before the credentials change hands, and reference the handover note on the invoice.

Describe the warranty in plain words — "30 days of bug fixes from handover; new work billed as a change request" — and you prevent the month-two conversation where "the site is broken" turns out to mean "we want a new feature."

Retainers and maintenance

Maintenance is the most under-invoiced part of freelance development because it stays invisible until it is urgent. Define it as something you can invoice against: a monthly fee, a stated number of hours, a response window, an overage rate. Then bill on a fixed date, with hours used shown as a line. Clients rarely argue with overage they can see in advance; they argue with a total that jumped.

A billing routine that survives a deploy

  • Keep a change log where you track issues, and write to it when the change is approved, not when the invoice is due.
  • Invoice within 24 hours of each milestone, while the evidence is one screen away.
  • Close the last invoice before opening the next project. Finished-but-unbilled work becomes debt you chase while doing something else.

Where the tooling fits

If the friction is the rebuild — the same client details, the same milestone structure, the same hosting line every month — use something that keeps those pieces.

One example: Invoice Maker, a free iPhone and Android app from Caractiv Tech. Describe a job in text or dictate it and it drafts an editable invoice you review and correct before it becomes a document. It keeps saved clients and reusable line items, so a three-line monthly retainer is quick to rebuild, exports a PDF for the handover email, and marks each invoice paid, unpaid or partially paid so overdue balances stay visible. It handles 34 currencies for clients billed abroad; manual documents work offline, while the AI drafting needs a connection. Free to download, with Premium templates and branding.

A spreadsheet and a PDF export still work if you actually maintain them. What matters is that the invoice comes from the record, not from recollection.

Five mistakes that cost developers money

  1. One line for the whole project. Nothing to point at when scope moves.
  2. Absorbing pass-throughs. Renewals you never rebill are a permanent discount.
  3. Verbal change requests. Unwritten work becomes your goodwill.
  4. Invoicing after the next project starts. The details and the urgency both vanish.
  5. No stated terms. "Whenever you get to it" is a payment schedule, and a bad one.

The short version

Bill the build in milestones tied to real events. Give every change request a number and a date. Rebill third-party costs with the renewal date visible. Invoice at handover, and put maintenance on a fixed monthly cycle. Your repo already tells the story — the invoice should tell the same one, in the client's language.


Get Invoice Maker

Disclosure: I work on Invoice Maker, the app linked above. This article is general information about billing practices for freelance developers, not legal, tax or accounting advice; contract and invoicing requirements vary by jurisdiction, so confirm the specifics where you operate.


Appendix: distribution assets (not part of the article body)

Social summaries

X:

Most freelance dev invoices don't fail on the rate. They fail on the trail.

Four things that should never share a line: the build, change requests, pass-through costs, and the maintenance retainer. Bill milestones on events, not dates.

LinkedIn:

A developer's invoice is usually written two weeks after launch, from memory, which is exactly when the details are coldest.

What fixes it: milestones tied to verifiable events, change requests with an ID and an approval date, third-party costs rebilled with the renewal date visible, and maintenance on a fixed monthly cycle. None of this is about raising rates — it's about not donating work you already did.

Reddit (r/freelance, r/webdev — answer-first, no link in body):

What stopped scope arguments for me: every request outside the proposal gets a CR number and a one-line description the moment it's approved, even if the "approval" is a Slack message. Then the invoice reads "CR-14 — webhook retry handling, approved 06/11 — 3.5h". Nobody argues with that, and I stopped eating four hours a week in invisible tweaks. Also rebill hosting renewals with the renewal date on the invoice; clients don't mind paying, they mind surprises.

Image suggestion

A developer's desk at dusk: laptop showing a deploy log, phone propped beside it with an invoice open — three line items visible (Milestone 2, CR-14, hosting renewal). A domain renewal email on screen, coffee ring on a notebook. No readable client name or figures. Alt text: "Developer invoice with milestone, change-request and hosting lines beside a deploy log."

Top comments (0)