Your website development payment terms protect you as much as the contract does: the deposit and the payment schedule decide how much money is at risk if something goes wrong with the developer. This guide covers why both extremes hurt, how to tie payments to results, and how to pay for changes without the budget creeping up.

Why a 100% upfront deposit is risky for you

Once you have paid everything in advance, the developer no longer has a financial reason to hurry or to listen to your feedback. If the work drags on, the quality is off, or the developer simply stops replying, getting your money back is hard, especially without a contract or paperwork.

Even an honest developer with full payment in hand tends to push your project down the queue: projects still waiting on payment always feel more urgent. A demand to pay everything at once is one of the main warning signs in how not to get scammed when ordering a website.

Why 0% up front is not a good idea either

The opposite extreme looks good for the client but causes its own problems. A developer working without a deposit is risking their own time. Experienced teams rarely accept those terms. The ones who do are often short on work or ready to cut corners.

A deposit also shows both sides are serious. You confirm the project is happening, and the developer reserves time and people for you. A reasonable prepayment for the first stage is normal practice and nothing to fear.

Staged payments: how to pay a web developer

The idea is simple: the project is split into stages, each stage has a clear result, and you pay for a stage when you see that result or when it begins. That way only part of the budget is at risk at any moment.

A good stage answers three questions:

  • what exactly will be ready: not “design”, but “mockups of the home page, catalog and product page for phone and desktop”;
  • how you will check it: a link to a test version, a clickable prototype, a demo on a call;
  • when the stage counts as accepted: for example, after your feedback is addressed and a sign-off document is signed.

An example split

Say you are ordering an online store at a fixed price. One reasonable schedule could look like this:

  1. Deposit and prototype: 20%. The developer gathers requirements and builds a clickable prototype of the main screens. You see the structure of the future store.
  2. Design: 20%. Approved mockups of the key pages.
  3. Development: 30%. A working test version with catalog, cart, payment and admin panel. You test it yourself.
  4. Launch: 20%. The site is live on your domain and hosting, working with real data.
  5. Final payment: 10%. After acceptance, handover of all access, and fixes for any bugs found.

The numbers are illustrative; every developer has their own schedule. What matters is the logic: each payment is tied to a result you can see, and the last payment waits until the project is fully handed over. What to check before that last payment is collected in the website acceptance checklist.

Make the final payment only after the domain, hosting, code and admin panel are registered to you and you have checked that your access works.

A prototype as a separate first stage

A low-risk way to start is to order only a prototype first. You pay a relatively small amount, get a clear result, and see how the developer works, communicates and keeps deadlines. At NOVO, for example, a website prototype starts at $300 and an app prototype at $400, and every project begins with one.

If the collaboration doesn’t work out, you keep the prototype and can take it to another developer. If it does, you continue with trust and a shared picture of the project.

Fixed price or hourly billing

There are two main ways to count money, and each has its place.

A fixed price means the scope is described up front and the amount doesn’t change. It works well when the task is clear: you know the budget and can plan. The downside is that any change in scope needs separate approval, and the developer builds a buffer for the unknown into the price.

Hourly billing (paying for time actually spent) is fairer when the task is fuzzy or keeps changing: a long project, support, ongoing improvements. The downside is that the final amount is hard to predict. To keep it under control, agree on a monthly or per-stage hour cap and regular reports on what was done and how long it took.

A common and sensible compromise: a fixed price for a first version with a clear scope, then hourly or monthly billing for improvements and support after launch.

How to pay: invoices versus personal transfers

A transfer to someone’s personal card is faster and sometimes cheaper, but in a dispute it proves almost nothing. A transfer receipt doesn’t say what you paid for or what you were supposed to get.

Paying an invoice under a contract, with a sign-off document for each stage, leaves a clear trail: what was ordered, what was done, what was accepted and paid. For a business it is also an accounting matter: development costs are easier to record with proper paperwork.

If the developer works as a private individual and there is no other way, still put the agreement in writing: in a contract, or at least in messages that state the stage, the amount and the result. The clauses a contract must have are covered in the website development contract.

How to pay for changes

Changes during a project are inevitable: you see the prototype and realize you need one more page, or a new promotion idea comes up. The problem isn’t the changes. It is that they often aren’t recorded anywhere.

What helps:

  • Agree on a process in advance. You describe the change, the developer estimates the cost and the impact on the timeline, and starts only after you approve.
  • Record every change in writing. A short message with the description, price and timing that you reply “approved” to is enough.
  • Don’t mix changes with bugs. If what was built doesn’t match what was agreed, fixing it is part of the original price. If you ask for something that wasn’t in the brief, that is a change.
  • Batch small requests. It is easier to collect minor edits in one list and estimate them together than to approve each one separately.

Signs of an unhealthy payment scheme

Be cautious if:

  • you are asked to pay for the whole project at once, especially with a “today only” discount;
  • stages are vague: “50% at the start, 50% at the end” with no description of what “the end” means;
  • the final payment is required before access is handed over;
  • every small clarification within the agreed scope gets its own invoice;
  • you are asked to send payments to different cards belonging to different people.

In short

  • Full prepayment puts all the risk on you; zero prepayment scares off reliable developers. A reasonable deposit for the first stage is normal.
  • Split payments into stages with clear, checkable results, and hold the last payment until the project is fully handed over.
  • Starting with a prototype as a separate stage is an inexpensive way to test a developer.
  • A fixed price suits a clear scope; hourly billing with an hour cap suits improvements and support.
  • Pay under a contract and invoice with sign-off documents, and approve changes in writing before work starts.