A blue stamp next to a blank sheet of paper on a dark desk in an empty room

Website Acceptance Testing: How to Sign Off on Your Developer's Work Before Launch

This is the second half of the conversation about the website spec. The spec defines what should be built. Website acceptance checks that exactly that was built: every feature works as described, and the site is ready for real visitors, search engines and ad traffic.

It's tempting to keep acceptance to a quick click-through: pages load, the design matches the mockups, so it's done. The problems surface a month later: leads never reach the sales team, Google can't see half the pages, and hosting access is still with the old contractor. Here is what to check when you accept website development work and how to organize it so you don't waste time arguing.

What website acceptance is and why it matters

Acceptance means checking the result against criteria agreed in advance and formally closing the work. It usually ends with an acceptance sign-off: the client confirms the work is complete, and the developer gets paid for the phase.

Without acceptance, a project has no clear finish line. The client keeps sending changes, the developer considers the work delivered, and a couple of months later nobody remembers what was in the contract and what was added along the way. Good acceptance does three jobs:

That's why website acceptance starts with the spec, not the finished site. If the requirements include acceptance criteria, the review comes down to working through a list. If they don't, every disputed point has to be negotiated from scratch.

Spec features: test user flows, not pages

The core of acceptance is checking features. Take the spec and go through each feature as a user would: not "is there a catalog page" but "can a shopper find a product by SKU, filter by price and add it to the cart."

It's easiest to test complete flows, from landing on the site to the outcome. For each flow, check both the happy path and the errors: what happens if a required field is left blank, a phone number is mistyped, a payment fails for insufficient funds, or someone opens their account with an expired link.

Pay special attention to integrations. If the site exchanges data with a CRM, an ERP or a warehouse system, check both ends: the order didn't just go through on the site, it also showed up in the back-office system with the right fields, and a stock change in the ERP made it to the catalog.

Website testing before launch: responsiveness, forms and speed

Every website needs these checks, even if the spec gives them a single line.

Responsiveness and browsers

Open the site on several phones, a tablet and a laptop, not just in the browser's developer tools. Check the browsers listed in the spec, typically current versions of Chrome, Safari, Firefox and Edge. Look at menus, tables, forms, pop-ups and long headings: they are what usually falls apart on narrow screens.

Forms and leads

A form that submits beautifully but never delivers the lead anywhere is the most expensive launch mistake. Send a test submission from every form and check where it lands: email, CRM, Slack or a messenger. Make sure all fields came through and that the right people got the notification, not the developer.

A form that submits but never delivers the lead is the most expensive launch mistake.

Page speed

Run the key pages through PageSpeed Insights: the homepage, the catalog, a product or service page. Look at mobile, which is usually slower. If the spec set specific speed targets, compare against them. If it didn't, at least make sure heavy images are compressed and pages don't take several seconds to load on a mobile connection.

SEO basics and analytics: what to check before opening the site to indexing

SEO configuration errors are invisible during acceptance but show up in traffic a few weeks later, especially when you migrate from an old site. Go through this website launch checklist together with your developer:

The same goes for analytics. Google Analytics is installed on every page, and conversions are set up for real actions: each form submission, a click on the phone number, a jump to a messenger, a completed order. Check that your test submission was counted as a conversion, and that the site is verified in Google Search Console with the client as an owner.

Admin panel, access and documentation

This part of acceptance isn't about how the site works today but whether the company can run it tomorrow, including without the current developer.

Admin panel

Ask to be shown how to edit copy, add products, news and pages, upload images and change meta tags. Then try it yourself. If changing the phone number in the header requires a developer and the spec said otherwise, that's an issue. Check the roles: a content manager shouldn't be able to delete the entire catalog.

Access and ownership

Before signing off, make sure the domain, hosting and repository are registered to the client. Not to the project manager who ran the project, and not to the agency.

Documentation

The minimum is a guide for the content manager on using the admin panel plus a technical overview: what the site is built on, how to deploy it, where integration settings and backups live. For a simple site, a few pages will do. For a service with integrations, documentation is what lets another team pick up the work if needed.

How to run acceptance: step by step

Pre-launch website QA goes faster and calmer when there's a process behind it. This is how we usually set it up:

  1. Staging site. The site is deployed to a separate address closed to indexing. The client can check everything there without risking the live site and its traffic.
  2. Developer QA. Before handing the site over for acceptance, the developers test features, responsiveness and forms themselves. The client shouldn't be finding obvious bugs.
  3. Client review against the spec. The person responsible on the client side works through the requirements and brings in the people who'll use the site: sales, the content manager, marketing.
  4. One issue list. Every issue goes into a single spreadsheet or tracker: what's wrong, where, how to reproduce it, a screenshot. Not five chats and a pile of voice messages.
  5. Priorities. Each issue gets a level: critical (blocks launch), major (gets in the way but has a workaround), minor (can wait until after launch). Anything that wasn't in the spec is flagged separately as an enhancement request.
  6. Fix deadlines. The developer commits to a date for each batch of issues, and the client re-checks after the fixes.
  7. Launch and sign-off. The site moves to the production domain, forms, analytics and robots.txt are checked again, and the acceptance sign-off is signed.

It's best to fix the length of the acceptance period and the number of revision rounds in the contract up front. Have a lawyer review the wording, but the logic is simple: the client gets a clear window to review, and the developer gets a clear window to fix.

The warranty period and what happens after sign-off

Even after careful acceptance, some bugs only appear under live traffic: a rare browser, an unusual order, peak-day load. That's what the warranty period is for: a window after launch during which the developer fixes bugs in the spec'd work at no charge. Its length and terms are set in the contract.

It's important to tell two kinds of requests apart. A bug means the site doesn't work as described in the spec: that's warranty. A change means a new feature, a different flow, a redesigned block: that's an enhancement, estimated separately. When the line is clear, there are no disputes after launch.

From there the site moves into support and growth: updates, monitoring, new sections and features driven by analytics. The web development agency that built the project usually picks up the work fastest because it knows the code and architecture, but solid acceptance and documentation leave the client free to choose.

At Sphere, development and testing is a dedicated stage before launch, and we hand all access and code over to the client. You can see how that plays out in finished projects in our website development work. If you're choosing a web studio or a digital agency to build your website, ask at the outset how they run acceptance. The answer will tell you a lot.

FAQ

How much time should we set aside for website acceptance?

It depends on the scope: a small corporate website can be checked in a few business days, while an online store or a client portal with integrations takes longer. Put the acceptance period and the deadline for fixing issues into the contract up front so the review doesn't drag on for months.

Who should test the website before launch: the client or the developer?

Both. The developer tests the site before handover: features, responsiveness, forms, speed. The client checks that the site does the job for the business and works with its real data and processes. The developer's QA doesn't replace acceptance, and acceptance doesn't replace QA.

What if a bug turns up after the acceptance sign-off?

If the bug relates to something in the spec, it gets fixed under the warranty period, provided the contract includes one. If it's a new request or a change in requirements, it's estimated and done as an enhancement or under a support plan.

Can we launch with open issues?

Yes, if the only open items are minor fixes that don't get in the visitor's way or break lead capture. Critical and major issues are closed before launch; minor ones go on the list with a specific fix date.

What access should the client get once the website is handed over?

Access to the domain and the hosting or server, the code repository, the admin panel with administrator rights, Google Analytics and Google Search Console, and every service connected to the site: notification email, CRM, payment provider. All of it should be registered to the client's company.

Let’s discuss your project
Related reading