Pricing a web development project remains one of the most fragile exercises in freelance work: a poorly built quote erodes the margin before the first day on the job, and a mismatched allocation of risk between contractor and client often surfaces only weeks later. Between fixed price, time and materials, and hybrid formulas, each billing model shifts responsibility for a schedule slip differently. This guide covers the most common pricing methods, how to build a reusable calculation framework, and the mistakes that most often erode profitability on a web development engagement.
Fixed price, time and materials, or a capped fixed price: three ways to split the risk
The billing model is not just a matter of how the quote looks: it sets, from the moment the contract is signed, who absorbs a schedule slip. Under time and materials, the client pays for actual time spent and alone bears the risk of an ill-defined scope. Under fixed price, the contractor commits to a firm price and bears the risk of underestimating the work. The capped fixed price, increasingly used on mid-sized web projects, tries to split that risk by setting a price for a defined scope, topped up with a day rate for anything outside it.
| Billing model | Who bears the risk of slippage | Budget visibility for the client | Typical use case |
|---|---|---|---|
| Time and materials (day rate) | The client | Low at the start, precise by the end | Team augmentation, evolving scope, ongoing maintenance |
| Fixed price | The contractor | Full visibility from signature | Closed, well-specified scope (brochure site, isolated module) |
| Capped fixed price | Shared | High on the core, variable on extras | Business application, redesign with identified areas of uncertainty |
On a web development project, the nature of the scope usually settles the choice: a stable brief and well-documented existing systems favour a fixed price, while technical exploration or a dependency on a third party (an external API, client infrastructure) pushes toward time and materials or a capped fixed price. To cover the administrative side once the project starts, invoice tracking then takes over, a topic addressed at length in the French-language guide on Facturation indépendante avec Odoo.
Building a calculation framework: day rate, overheads and a contingency margin
A solid quote always starts from the same base: the day rate actually required to cover overheads, an estimate of the number of days, plus a contingency margin. The day rate is never set by guesswork: it is calculated from the target net income, the social and tax charges of the chosen legal status, and the number of days that can realistically be billed in a year, after deducting holidays, business development and administrative work.
A web development freelancer rarely bills more than 150 to 190 days a year once weekends, holidays, business development and continuing training are removed. A day rate calculated on 220 billable days almost always leads to a real income below the target.
Once the day rate is set, pricing the project means adding up the estimated days for each work package (scoping, integration, development, testing, deployment), then applying a contingency margin of 10 to 20% depending on how mature the brief is. That margin is not an arbitrary mark-up: it covers review round-trips, integration adjustments and the unforeseen technical issues that appear on almost every project, even the best-specified ones.
A step-by-step worked example
The calculation below illustrates how a quote is built from the same variables: target net income, overheads, billable days, then a breakdown by work package with a contingency margin.
# Étape 1 : taux journalier moyen nécessaire
revenu_net_vise = 45000 # objectif annuel, en euros
taux_charges = 0.45 # charges sociales + fiscales, selon statut
jours_facturables = 170 # jours réellement vendables sur l'année
cout_annuel_charge = revenu_net_vise / (1 - taux_charges)
tjm = cout_annuel_charge / jours_facturables
print(f"TJM nécessaire : {tjm:.0f} €")
# Étape 2 : chiffrage du projet par lot, en jours
lots = {
"Cadrage et spécifications": 2,
"Intégration et développement": 12,
"Tests et recette": 3,
"Déploiement et mise en production": 1.5,
}
jours_estimes = sum(lots.values())
# Étape 3 : marge d'aléas selon la maturité du cahier des charges
marge_aleas = 0.15
jours_factures = jours_estimes * (1 + marge_aleas)
prix_forfait = jours_factures * tjm
print(f"Jours estimés : {jours_estimes} / Jours facturés avec marge : {jours_factures:.1f}")
print(f"Prix du forfait : {prix_forfait:.0f} €")
This calculation is deliberately simple: it does not account for fixed costs (tooling, insurance, bookkeeping), which should be folded into the overhead rate, nor for project-specific expenses (third-party licences, staging hosting). Those lines are added to the quote separately, to keep the calculation framework readable and reusable from one project to the next.
Common mistakes that erode the margin
Three flaws come up in almost every quote that ends up unprofitable: a scope described in a single line rather than broken down into work packages, a contingency margin cut to lower the price shown to the client, and no revision clause for scope changes made mid-project. Scope creep, the gradual drift of the scope through successive additions approved verbally, is the leading cause of overruns on fixed-price projects.
A simple revision clause protects both parties: beyond a defined threshold of change from the original scope, it requires a priced change order, billed at the agreed day rate, to be signed before work continues. That clause avoids the informal conversation that, in practice, almost always ends with unbilled work.
Presenting and defending the quote to the client
A quote broken down by work package gets discussed item by item; a single lump-sum price gets negotiated as a whole, and it is always the contractor who gives ground first.
Breaking the quote down into visible work packages, each with its number of days, changes the nature of the negotiation: the client can drop or simplify a package to fit the budget, rather than ask for a blanket discount on a figure they cannot break down themselves. This presentation also avoids a blunt comparison with a cheaper competitor, since it makes visible what each package actually covers. For tracking time spent on each package, some of the tools covered in Mail Studio’s French-language roundup of command-line tools for web development make it possible to timestamp tasks without leaving the terminal, which later makes billing for a validated overrun easier.
What to remember
- The billing model (fixed price, time and materials, capped fixed price) determines who bears the risk of a schedule slip: the choice should follow how stable the scope really is, not the sales preference of the moment.
- The day rate is calculated from the target net income, the overhead rate of the chosen legal status and the number of days that can realistically be billed, rarely more than 170-190 a year.
- A contingency margin of 10 to 20% is not padding: it covers review round-trips and the technical surprises present on almost every project.
- A quote broken down by work package, paired with a revision clause, protects the margin better than a single fixed price.
On mid-sized web projects, the capped fixed price offers in practice the best compromise: it reassures the client on the budget for the core scope while keeping the contractor from working at a loss on the extras. The real gain in profitability does not come from a higher day rate, but from a calculation framework applied consistently, quote after quote, rather than recalculated each time under sales pressure. — Simon Janvier
To go further: the social charge rates and thresholds that apply to the different freelance legal statuses in France are published on the official portal autoentrepreneur.urssaf.fr.
