
Nov 21, 2026 by Anthony York (YorkSoft Ltd)
Last Updated: 19 November 2026
Quick Summary
Quality assurance is the planned process of checking that a website works correctly, loads quickly, stays secure and remains usable for every visitor, running from the first line of code through to life in production. It prevents defects rather than catching them afterwards, protecting revenue, reputation and your development budget.
That distinction matters more than most briefs admit. QA is a habit, not a stage.
At YorkSoft Ltd, we build bespoke web applications for businesses across Northampton and the wider United Kingdom, and we treat testing as part of the build itself.
If you want to see what that build process looks like in practice, you can explore our bespoke web development service and how testing sits inside it.
Websites now carry real commercial weight. A broken form, a slow checkout or a checkout that fails on mobile quietly costs you money while you sleep.
Many businesses find that a single failed release does more damage than a month of small bugs. Trust is often the first casualty.
Three pressures have raised the stakes:
QA is how you protect revenue, reputation and the development budget at the same time.
Skipping QA does not save money. It moves the cost to a worse place, at a worse time.
Downtime during a busy trading period is the obvious risk.
Each of those is a lost conversion, and none of them is likely to show up in a bug tracker unless someone reports it.
The repair bill is the third cost. Fixing a defect found in production usually takes longer than fixing it during the build, because you are working around live data and real customers.
Software testing splits into a handful of practical types, and a well-run project uses several of them together. No single test catches everything.

The main types we rely on are functional, regression, compatibility, usability, accessibility and performance testing. Each answers a different question about the build.
Functional testing checks that features do what the brief says. Can a user register, log in, pay and receive a confirmation?
Regression testing asks a different question: did the new change break something that used to work?
Compatibility testing covers the messy reality of browsers, screen sizes and devices.
Together, these three form the backbone of any serious test plan.
Usability testing watches real people use the site and notes where they hesitate. It finds the friction that no automated test will ever flag.
Accessibility testing checks that people using screen readers, keyboard navigation or zoom can still complete the key journeys.
Performance testing measures speed under load. Page speed affects both ranking and conversion, and we have written separately about the impact of site speed on conversion rates if you want the detail.
Bespoke builds need a testing approach shaped around their own risk, not a generic template.
Start with critical user journeys.
Then follow these habits:
If you are planning a custom build, our guide to planning a bespoke web development process shows where these testing gates fit into the timeline.
Watch out: the most common mistake is testing only on the developer's own machine and browser. It passes there and fails everywhere else.
Tooling should follow the test plan, not replace it. A short, well-chosen stack beats a long list nobody uses.
Most teams need six categories covered, not four:
| Category | What it does | Typical UK options | When to add it |
|---|---|---|---|
| Browser automation | Re-runs key journeys on every release | Playwright, Cypress, Selenium | Once you have stable core flows |
| Cross-browser preview | Checks layout across devices and engines | BrowserStack, LambdaTest, Sauce Labs | Before the first public launch |
| Performance auditing | Flags slow pages, heavy assets and poor Core Web Vitals | Lighthouse, WebPageTest, Chrome DevTools | From the first build sprint |
| Accessibility scanning | Catches missing alt text, contrast failures and ARIA errors | axe DevTools, WAVE, Pa11y | Before the first public launch |
| API and integration testing | Verifies endpoints, payloads and third-party responses | Postman, Newman, Pact | As soon as the first integration lands |
| Bug tracking and CI | Records defects and gates deployments on test results | Jira, GitHub Actions, GitLab CI | Day one, no exceptions |
For small teams on a tight budget, free browser developer tools and widely available auditing tools are a sensible starting point, with paid automation added once manual regression becomes the bottleneck.
Page-level checks miss the failures that hurt most.
API testing checks that each endpoint returns the right status code, payload and error message.
Deployment pipelines should gate on tests, not hope. A typical setup runs unit and integration tests on every pull request, the regression suite on every merge to main, and a smoke test against staging before promotion to production.
Watch out: a green pipeline that only runs unit tests gives false confidence, it will pass while the checkout is broken in a real browser.
The trap is buying tooling before you have a process. Tools speed up good testing; they do not create it. A common pattern is a team subscribing to three automation platforms and running none of them on a schedule.
Start with the smallest stack that covers your critical journeys, measure defect escape rate for a quarter, then add the next category that addresses the largest remaining gap. If you would rather have that stack chosen and run for you, talk to the YorkSoft team about a QA plan sized to your build.
A pre-launch checklist turns vague confidence into a repeatable pass or fail. The version below is organised by risk tier so a small team can work top-down and stop when time runs out, rather than treating every item as equally urgent.
This website quality assurance checklist can be adapted to the risk profile of each build. It takes an afternoon and can save weeks.
Watch out: teams often tick Tier 3 and Tier 4 while leaving Tier 2 until after launch, and accessibility and consent fixes can become more expensive once real users and regulators can see them.
If you want this checklist applied to your next Northampton build, get in touch with YorkSoft to discuss your timeline.
QA impact is measurable, and you should measure it. Start with defect counts found before launch versus after.
Then track the commercial side:
A common pattern is a shift in where bugs are found, with more defects caught in staging and fewer complaints from customers.
That shift is the return on investment. You are not spending less on quality; you are spending it earlier, where it is cheaper.
Planning QA starts with a conversation about risk, budget and timeline, not a tool list.
For Northampton businesses weighing up a bespoke build, the honest question is who will own quality. If you are comparing options, our guide on how to choose a bespoke web development partner sets out the questions worth asking before you sign.
YorkSoft Ltd builds bespoke web applications and offers SEO services including rank monitoring, keyword analysis and competitor monitoring, so technical quality and search visibility can be considered together.
Call us now to talk through your next project and find out what a proper test plan would look like for your build.
Quality problems rarely announce themselves.
Quality assurance catches defects before users meet them. A broken form, a slow checkout or a failed third-party integration costs enquiries and sales directly, and fixing a fault after launch usually takes longer than preventing it during the release cycle. QA also protects search visibility, because page speed, mobile behaviour and crawlable content all affect rankings. For a bespoke web application, quality assurance is the stage that confirms the build actually does what the business process requires, rather than merely looking finished.
Quality assurance is the process: the test plan, the standards, the review steps and the decisions about what risk to accept. Software testing is one activity inside that process, where test cases are run against the web application. Put simply, QA asks whether the right checks happened and whether the release is safe to ship; testing produces the evidence. A project can run plenty of tests and still have weak quality assurance if nobody owns the test plan or reviews test coverage.
A practical website quality assurance checklist covers critical user journeys end to end: forms and their confirmation emails, links, content validation, analytics tracking and third-party integrations. Add cross-browser and mobile testing, page speed checks, accessibility testing against WCAG 2.2, security testing and a regression pass on the staging environment before deployment. Finish with a production smoke test after release. Keep the list short enough to run every cycle, and record which items were signed off.
Test on every release, however small, and run a fuller regression pass at least quarterly. Anything that touches payments, membership records or integrations deserves a check each time it changes. After launch, monitor uptime, page speed and error logs continuously, then schedule manual testing around major content updates, browser changes and dependency upgrades. If your site runs on a modern web stack with regular updates, a short monthly review of critical user journeys catches most problems before customers do.