A website development contract is not a formality. It decides what you get, when you get it, and what happens if something goes wrong. Here are the clauses you should not sign without, plus simple wording you can ask to add.
Why you need a contract even with a developer you trust
While a project goes well, nobody opens the contract. It matters in three situations: when the two sides understood the job differently, when deadlines slip, and when someone wants to stop. In each of them, verbal agreements and a chat history help very little.
A good contract protects both sides. An honest developer will not object to clear terms: they also want the scope to stay fixed and the payments to arrive on time. If you ask for a contract and hear “why bother, we already agreed,” treat that as a warning sign.
What to include in the contract: scope of work
The most common source of disputes is simple: the “website” in the client’s head and the one in the developer’s head are different. A line like “development of a company website” with no details means almost nothing.
The scope belongs in an attachment to the contract. Usually that is a brief, a prototype or a detailed estimate, ideally all three. It lists the pages, features, integrations, languages, what the admin panel can do, and who prepares texts and photos. If you do not have a brief yet, start there. Our guide on writing a website brief shows how to do it without technical knowledge.
It also helps to write down what is not included. For example: “the client fills the product catalog” or “moving old blog posts is not included in the price.” That way you see in advance what will cost extra.
Stages, deadlines and the client’s obligations
Tie deadlines to stages rather than to a single final date: prototype, design, development, launch. Each stage ends with a result you can review and accept. Problems then show up after two weeks, not after three months.
One important detail: the developer’s deadlines depend on you too. If you take a week to send texts or approve a design, the schedule moves. A fair contract says so, for example: “the stage deadline is extended by the time the client’s materials are delayed.” That is honest, and it pushes both sides to respond quickly.
It is also good to set how long the client has to review each stage and give feedback, for example five business days. This protects both sides from endless waiting.
Price and payment schedule
The contract should state the total price, or a clear way to calculate it if the work is billed by the hour. Add the currency, how payments are made, and what the price covers: only development, or also the domain, hosting and paid services for the first year.
It makes sense to split payments by stage and tie each one to an accepted result. Full prepayment puts all the risk on you, full postpayment puts it on the developer, so most projects land somewhere in between. Our article on prepayment and staged payments covers the options and why paying against documents beats a transfer to a personal card.
Acceptance and sign-off
Acceptance answers the question “when is the work considered done?” Without it, the developer can say “the site is ready” while you are looking at a contact form that does not send anything.
Describe a simple procedure in the contract:
- the developer delivers a stage and shows the result;
- the client has a set number of days to review it;
- issues are sent in writing, as a list;
- the developer fixes them within an agreed time;
- once fixed, both sides sign an acceptance document.
Agree separately on what counts as a defect and what counts as a new request. A defect is anything that does not match the brief or the approved design. A new button that was never in the brief is a change of scope. For what to check at handover, see our website acceptance checklist.
Rights to code, design and accounts
Clients skip this section more often than any other, and it has the longest consequences. If the contract says nothing about rights, you may end up having paid for the work but, formally, not being free to use or change the site without the developer’s permission.
What to put in writing:
- after full payment, the exclusive rights to the design, texts and code created under the contract pass to the client;
- the developer hands over the source code and design source files, not just a working site;
- the domain, hosting, analytics and other accounts are registered to the client or transferred to them;
- if the project uses third-party components, fonts or photos, the developer explains their license terms and whether they need to be paid for.
Some studios reuse their own building blocks across projects. That is normal, but then the contract should give you a permanent right to use them in your site and to keep developing it with any other contractor.
The key rule: the domain, hosting and all key accounts should be in your name from day one, not “handed over later.”
For a full list of what should belong to you, read who owns your website.
Warranty, changes and confidentiality
Warranty period
After launch there are always bugs nobody noticed during acceptance. The contract should define how long the developer fixes them for free and how quickly they respond. The exact period is up to the two sides. What matters is that it is written down, and that it is clear the warranty covers bugs, not new features.
Changes during the project
New wishes will almost certainly come up, and that is fine. Agree on how they are handled: the client describes the change, the developer estimates the cost and time, the client confirms in writing. Without that, small “while you’re at it” tweaks quietly turn into an argument about extra payment.
Confidentiality
If you share customer data, internal pricing or access to your systems, add a non-disclosure clause. The developer may also want their own work kept private. While you are at it, agree on whether the developer may show the project in their portfolio.
Termination and liability
Nobody starts a project planning to end it early, but this clause exists exactly for the case when things do not work out.
The contract should say:
- how either side can exit and how many days’ notice it needs to give;
- how payment for work already done is calculated;
- what the client receives on termination: everything completed so far, including code, design files and accounts.
That last point matters most. Without it, you can end up having paid half the budget while the result stays with the developer.
Liability is usually handled through penalties for missed deadlines and a cap on total liability. Harsh penalties for one side and none for the other are a sign of imbalance. If the budget is large or some wording is unclear, have a lawyer review the contract. It costs far less than a dispute later.
How to review a website development contract before signing
Read the contract with a pen in hand and ask yourself:
- Can I tell from the attachments exactly what I will receive?
- When and for what do I pay, and what do I get after each payment?
- How do I accept the work, and what do I do if something is wrong?
- Whose name are the domain, hosting and accounts in?
- Will I get the code and source files if we part ways halfway?
- How long are bugs fixed for free?
If the text does not answer one of these, ask for a clause to be added. A reasonable developer will take it calmly. At NOVO, for example, we start with a prototype, and it becomes part of the scope description: the client sees the main screens before development, so there is little room to argue about “what was meant.”
In short
- The scope lives in an attachment: a brief, a prototype or a detailed estimate.
- Deadlines and payments are tied to stages and accepted results.
- Acceptance ends with a signed document, and issues are sent in writing.
- Rights to code and design pass to you, and the domain and accounts are in your name from the start.
- The warranty period, change process and termination terms are written down.
- For a large budget or unclear wording, have a lawyer review the contract.