Website Testing Checklist: 100+ Test Cases for Complete Website QA
A website can look perfectly fine and still contain dozens of problems.
A button may work on desktop but fail on mobile.
A form may accept invalid information.
A checkout process may break when a session expires.
A navigation link may lead to a missing page.
An image may look correct on one browser but become distorted on another.
A page may load quickly for a developer but become extremely slow for users on a slower connection.
A visually attractive website can still have serious accessibility, usability, security, functional, or performance problems.
This is why website testing should not be limited to checking whether individual pages load successfully.
A complete website QA process evaluates the entire user experience and the technical behavior of the application.
This guide provides a practical website testing checklist covering more than 100 test scenarios across functionality, navigation, forms, UI, responsive design, browsers, accessibility, performance, security, sessions, content, and regression.
It can be used as a starting point for manual testing, automated testing, exploratory testing, and release validation.
---
What Is Website Testing?
Website testing is the process of evaluating a website or web application to determine whether it works correctly, remains usable across supported environments, meets its requirements, and provides an acceptable experience to users.
Website testing can include many different testing activities.
These may include:
- Functional testing
- UI testing
- Usability testing
- Compatibility testing
- Responsive testing
- Accessibility testing
- Performance testing
- Security testing
- Form testing
- Navigation testing
- Content testing
- Session testing
- Integration testing
- Regression testing
- End-to-end testing
The exact scope depends on the type of website.
A simple informational website may require relatively straightforward testing.
An e-commerce application may require much deeper testing around:
- Accounts
- Products
- Search
- Cart
- Checkout
- Payments
- Orders
- Coupons
- Shipping
- Notifications
A SaaS application may require testing around:
- Authentication
- Permissions
- Dashboards
- Subscriptions
- Workspaces
- APIs
- Integrations
- Data management
Therefore, a website testing checklist should be treated as a framework rather than a fixed list that applies identically to every project.
---
Why Website Testing Is Important
Users don't experience a website as a collection of individual test cases.
They experience it as a journey.
For example:
A visitor might:
1. Open the homepage.
2. Search for a product.
3. Open a product page.
4. Add the product to a cart.
5. Create an account.
6. Log in.
7. Enter payment information.
8. Complete checkout.
9. Receive confirmation.
10. View the order.
A defect at any point can interrupt the entire journey.
This is why QA should consider both individual features and complete workflows.
Website testing also protects against problems that aren't immediately obvious.
For example:
A website might pass functional testing but fail accessibility testing.
It might work correctly on Chrome but break on Safari.
It might work on desktop but become unusable on mobile.
It might work with a fast internet connection but become extremely slow on a slower network.
It might successfully authenticate users but fail to invalidate their session after logout.
A complete testing strategy looks beyond the happy path.
---
Website Testing Categories
Before creating test cases, divide the website into testing categories.
A practical strategy includes:
1. Functional Testing
Does the website actually perform the required functions?
2. UI Testing
Does the interface look and behave correctly?
3. Navigation Testing
Can users move through the website correctly?
4. Form Testing
Do forms accept valid information and reject invalid information?
5. Responsive Testing
Does the website work across different screen sizes?
6. Cross-Browser Testing
Does it behave correctly across supported browsers?
7. Accessibility Testing
Can users with different abilities use the website?
8. Performance Testing
Does the website remain responsive under expected conditions?
9. Security Testing
Are authentication, authorization, sessions, and user data protected?
10. Usability Testing
Can users understand and complete important tasks?
11. Content Testing
Is the information accurate, readable, complete, and correctly displayed?
12. Regression Testing
Did a new change break an existing feature?
These categories help prevent QA teams from focusing exclusively on functional behavior.
---
Website Functional Testing Checklist
Functional testing should begin with the requirements.
Every major feature should have expected behavior.
The objective is to verify that the website behaves as intended.
---
Test Case 1: Homepage Loads Successfully
Open the homepage.
Verify:
- Page loads successfully
- Main content appears
- Navigation appears
- Images load
- Buttons are available
- No unexpected errors are visible
---
Test Case 2: Main Navigation Works
Click every primary navigation item.
Verify that each link takes the user to the correct destination.
---
Test Case 3: Logo Navigation
Click the website logo.
Expected result:
The user is taken to the expected homepage or configured destination.
---
Test Case 4: Browser Refresh
Refresh important pages.
Verify that:
- Content remains available
- The application does not enter an unexpected state
- Form or session behavior matches requirements
---
Test Case 5: Direct URL Access
Open important pages directly using their URLs.
Verify that the pages load correctly.
This is particularly important for applications with client-side routing.
---
Test Case 6: Back Button
Navigate between several pages.
Use the browser Back button.
Verify that navigation behaves correctly.
---
Test Case 7: Forward Button
Repeat the workflow and use the browser Forward button.
Verify expected behavior.
---
Test Case 8: Open Links in a New Tab
Open important links in a new tab.
Verify that the destination works correctly and the application does not depend on the original tab in an unexpected way.
---
Navigation Testing
Navigation problems can make an otherwise functional website difficult to use.
Test:
- Header navigation
- Footer navigation
- Breadcrumbs
- Sidebar navigation
- Dropdown menus
- Mega menus
- Internal links
- External links
- Back navigation
- Forward navigation
---
Test Case 9: Header Links
Verify all header links.
---
Test Case 10: Footer Links
Verify all footer links.
---
Test Case 11: Breadcrumb Navigation
If breadcrumbs are available, verify that each breadcrumb leads to the correct location.
---
Test Case 12: Dropdown Navigation
Open dropdown menus.
Verify:
- Menu opens
- Menu closes
- Items are selectable
- Links are correct
- Menu doesn't overlap important content
---
Test Case 13: Mobile Navigation
Open the mobile navigation menu.
Verify:
- Menu opens
- Items are visible
- Scrolling works
- Menu closes correctly
- Links work
---
Broken Link Testing
Broken links can damage both user experience and site quality.
Check:
- Internal links
- External links
- Image links
- Footer links
- Navigation links
- Buttons acting as links
---
Test Case 14: Valid Internal Links
Verify that internal links lead to existing pages.
---
Test Case 15: Missing Page
Verify how the website handles a page that doesn't exist.
The application should provide an appropriate error or not-found experience.
---
Test Case 16: Broken External Link
Verify that important external links point to the intended destination.
---
Test Case 17: Incorrect Redirect
Verify that links don't unexpectedly redirect users to unrelated pages.
---
Form Testing
Forms are among the most common sources of website defects.
Examples include:
- Contact forms
- Registration
- Login
- Search
- Checkout
- Newsletter signup
- Profile forms
- Feedback forms
Forms should be tested with both valid and invalid data.
---
Basic Form Test Cases
Test Case 18: Valid Data
Enter valid information into all required fields.
Submit the form.
Verify successful submission.
---
Test Case 19: Required Fields Empty
Leave required fields blank.
Submit the form.
Verify appropriate validation.
---
Test Case 20: Optional Fields Empty
Leave optional fields empty.
Verify that submission behaves according to requirements.
---
Test Case 21: Invalid Email
Enter an invalid email format.
Verify validation.
---
Test Case 22: Invalid Phone Number
Enter an invalid phone number.
Verify appropriate handling.
---
Test Case 23: Minimum Field Length
Test values at the minimum allowed length.
---
Test Case 24: Maximum Field Length
Test values at the maximum allowed length.
---
Test Case 25: Value Beyond Maximum Length
Enter data exceeding the allowed maximum.
Verify safe handling.
---
Test Case 26: Special Characters
Test supported special characters.
---
Test Case 27: Unicode Input
Where applicable, test international characters.
---
Test Case 28: Spaces
Test:
- Leading spaces
- Trailing spaces
- Multiple spaces
- Spaces-only input
Expected behavior should match requirements.
---
Test Case 29: Copy and Paste
Verify whether copy/paste behaves correctly in supported fields.
---
Test Case 30: Form Submission Multiple Times
Click Submit repeatedly.
Verify that duplicate submissions do not occur unexpectedly.
---
Search Testing
Search functionality should be tested independently.
---
Test Case 31: Valid Search
Enter a known search term.
Verify relevant results appear.
---
Test Case 32: No Results
Search for something that doesn't exist.
Verify that the application provides an appropriate empty-state message.
---
Test Case 33: Empty Search
Submit an empty search.
Verify expected behavior.
---
Test Case 34: Special Characters in Search
Test supported special characters.
---
Test Case 35: Very Long Search Query
Enter an unusually long query.
Verify that the interface and backend handle it safely.
---
Test Case 36: Search Case Sensitivity
Test uppercase and lowercase variations.
Verify behavior according to requirements.
---
UI Testing Checklist
A website should be tested visually as well as functionally.
Verify:
- Typography
- Font size
- Font weight
- Spacing
- Alignment
- Colors
- Borders
- Shadows
- Icons
- Images
- Buttons
- Cards
- Tables
- Modals
- Notifications
---
Test Case 37: Text Alignment
Verify that text is aligned correctly.
---
Test Case 38: Button Alignment
Verify that buttons don't overlap or appear incorrectly positioned.
---
Test Case 39: Image Rendering
Verify:
- Correct image
- Correct dimensions
- No distortion
- No unexpected cropping
---
Test Case 40: Icons
Verify that icons:
- Appear correctly
- Have appropriate size
- Are positioned correctly
- Perform the expected action when interactive
---
Test Case 41: Error State UI
Trigger validation errors.
Verify that error states are visually clear.
---
Test Case 42: Success State UI
Trigger successful actions.
Verify appropriate success feedback.
---
Responsive Website Testing
Modern websites need to work across many screen sizes.
Don't test only:
"Desktop and mobile."
Test representative viewport ranges.
Examples include:
- Large desktop
- Standard desktop
- Laptop
- Tablet
- Mobile
- Small mobile
---
Test Case 43: Desktop Layout
Verify the primary desktop layout.
---
Test Case 44: Tablet Layout
Verify that content remains usable on tablet-sized screens.
---
Test Case 45: Mobile Layout
Verify mobile navigation, content, buttons, and forms.
---
Test Case 46: Small Mobile Screen
Test a smaller viewport.
Look for:
- Horizontal scrolling
- Clipped content
- Overlapping elements
- Hidden buttons
- Broken menus
---
Test Case 47: Landscape Mobile
Rotate the device.
Verify the layout remains usable.
---
Test Case 48: Portrait Mobile
Verify the portrait layout.
---
Test Case 49: Responsive Images
Verify that images resize appropriately.
---
Test Case 50: Responsive Tables
If tables exist, verify that users can access all necessary information on smaller screens.
---
Cross-Browser Testing
A website can behave differently across browsers.
Test the supported browser matrix for the application.
Common browsers may include:
- Chrome
- Firefox
- Edge
- Safari
The exact browser list should be based on product requirements and user analytics.
---
Test Case 51: Chrome
Verify critical workflows.
---
Test Case 52: Firefox
Verify critical workflows.
---
Test Case 53: Edge
Verify critical workflows.
---
Test Case 54: Safari
Verify critical workflows where supported.
---
Test Case 55: Browser-Specific UI
Check for:
- Layout differences
- Font rendering
- Form behavior
- JavaScript issues
- Date inputs
- File uploads
- Authentication
- Navigation
---
Accessibility Testing Checklist
Accessibility should not be treated as an optional final check.
Test whether users can navigate and understand the website using different interaction methods.
---
Test Case 56: Keyboard Navigation
Navigate through important functionality without using a mouse.
---
Test Case 57: Focus Order
Verify logical focus order.
---
Test Case 58: Visible Focus
Verify that focused elements are visually identifiable.
---
Test Case 59: Form Labels
Verify that form controls have meaningful labels.
---
Test Case 60: Error Identification
Verify that users can identify what went wrong when validation fails.
---
Test Case 61: Button Names
Verify that interactive controls have understandable names.
---
Test Case 62: Image Alternatives
Verify that meaningful images have appropriate alternative text where required.
---
Test Case 63: Color Dependency
Verify that important information isn't communicated only through color.
---
Test Case 64: Text Readability
Verify that text remains readable at supported sizes and zoom levels.
---
Performance Testing Checklist
A page that works correctly but takes too long to load can still create a poor user experience.
Performance testing should consider realistic conditions.
Test:
- Page loading
- Navigation
- Images
- JavaScript
- API requests
- Large content
- Multiple concurrent users
- Slow network conditions
---
Test Case 65: Homepage Load
Measure the page under expected conditions.
---
Test Case 66: Large Page
Test pages containing significant content.
---
Test Case 67: Image-Heavy Page
Verify whether large images significantly affect loading.
---
Test Case 68: Slow Network
Test using slower network conditions where relevant.
---
Test Case 69: API Delay
Simulate delayed API responses where possible.
Verify that the UI handles delays gracefully.
---
Test Case 70: Failed API
Simulate a backend failure.
Verify that users receive appropriate feedback rather than a broken interface.
---
Authentication Testing
If the website includes accounts, authentication becomes a major testing area.
Test:
- Registration
- Login
- Logout
- Password reset
- Session expiration
- Remember Me
- Protected pages
- Multiple sessions
---
Test Case 71: Valid Login
Verify successful authentication.
---
Test Case 72: Invalid Login
Verify authentication failure.
---
Test Case 73: Logout
Verify that logout works correctly.
---
Test Case 74: Protected URL
Attempt to access protected functionality without authentication.
Verify that access is prevented.
---
Test Case 75: Session Expiration
Allow the session to expire.
Verify expected behavior.
---
Authorization Testing
Authentication asks:
"Who are you?"
Authorization asks:
"What are you allowed to do?"
This distinction is extremely important.
For applications with different user roles, test:
- Standard user
- Manager
- Administrator
- Guest
- Other configured roles
---
Test Case 76: Authorized Feature
Verify that a user can access functionality assigned to their role.
---
Test Case 77: Unauthorized Feature
Verify that a user cannot access restricted functionality.
---
Test Case 78: Direct URL Authorization
Attempt to directly access a restricted URL.
Verify that authorization controls still apply.
---
File Upload Testing
If the website supports file uploads, test:
- Valid file types
- Invalid file types
- Small files
- Large files
- Empty files
- Duplicate files
- File names with spaces
- Special characters in names
---
Test Case 79: Valid File
Upload a supported file.
Verify successful processing.
---
Test Case 80: Unsupported File
Upload an unsupported file.
Verify appropriate validation.
---
Test Case 81: Large File
Upload a file near the maximum supported size.
Verify behavior.
---
Test Case 82: Oversized File
Upload a file exceeding the allowed limit.
Verify safe rejection.
---
Content Testing
Functional correctness doesn't guarantee content quality.
Check:
- Spelling
- Grammar
- Broken text
- Incorrect headings
- Missing content
- Duplicate content
- Incorrect labels
- Placeholder text
- Outdated information
---
Test Case 83: Placeholder Text
Search for accidental placeholder text such as:
"Lorem ipsum"
or development-only messages.
---
Test Case 84: Broken Content
Check for:
- Missing headings
- Truncated text
- Incorrect characters
- Unexpected symbols
---
Test Case 85: Dynamic Content
Verify that dynamic information appears correctly.
---
Error Handling Testing
Good websites should fail gracefully.
Test situations such as:
- Server errors
- Network failure
- API timeout
- Invalid request
- Expired session
- Missing resource
- Unsupported action
---
Test Case 86: 404 Page
Open a nonexistent page.
Verify that an appropriate not-found experience is provided.
---
Test Case 87: Server Error
Where possible in a controlled test environment, simulate a server failure.
Verify that the UI doesn't expose unnecessary technical details.
---
Test Case 88: Network Failure
Disable or interrupt network connectivity during an operation.
Verify appropriate feedback.
---
Test Case 89: API Timeout
Simulate a delayed API.
Verify that the interface communicates the state appropriately.
---
Security-Oriented Website Testing
Security testing should be performed only on systems where you have authorization.
The objective is to verify that the application properly protects users and data.
Important areas include:
- Authentication
- Authorization
- Session management
- Input handling
- Sensitive information
- Access controls
- Error messages
- File uploads
---
Test Case 90: Unauthorized Access
Verify that protected functionality cannot be accessed without appropriate authorization.
---
Test Case 91: Session Invalidation
Verify that logout invalidates the appropriate authentication state.
---
Test Case 92: Sensitive Data Exposure
Verify that sensitive information isn't unnecessarily displayed in pages, errors, or client-visible content.
---
Test Case 93: Input Handling
Verify that user input is safely handled by the application.
---
Test Case 94: Error Information
Verify that error responses don't unnecessarily expose implementation details.
---
E-Commerce Website Testing
If you're testing an e-commerce website, add another layer of scenarios.
Important workflows include:
- Product search
- Product details
- Product variants
- Cart
- Coupons
- Checkout
- Address
- Shipping
- Payment
- Order confirmation
- Order history
---
Test Case 95: Add Product to Cart
Select a product and add it to the cart.
Verify:
- Correct product
- Correct quantity
- Correct price
---
Test Case 96: Update Cart Quantity
Change the quantity.
Verify price and quantity calculations.
---
Test Case 97: Remove Product
Remove a product.
Verify that the cart updates correctly.
---
Test Case 98: Checkout
Proceed through the checkout workflow.
Verify each step.
---
Test Case 99: Invalid Checkout Information
Enter invalid information.
Verify appropriate validation.
---
Test Case 100: Order Confirmation
Complete a valid order.
Verify that confirmation is displayed and the order is recorded correctly according to requirements.
---
End-to-End Website Testing
Individual test cases are important.
But complete user journeys are equally important.
Consider an e-commerce example:
Visitor
↓
Homepage
↓
Search
↓
Product
↓
Cart
↓
Login
↓
Address
↓
Payment
↓
Order
↓
Confirmation
A defect in any step can break the complete experience.
This is why end-to-end testing should cover the most important user journeys.
---
How to Prioritize Website Tests
Not every test has the same importance.
A useful prioritization model is:
P0 — Critical
Failure prevents users from using the core product.
Examples:
- Website unavailable
- Login broken
- Checkout broken
- Payment broken
P1 — High
Major functionality is affected.
Examples:
- Search broken
- Registration broken
- Important forms failing
P2 — Medium
A feature works incorrectly but users have alternatives.
P3 — Low
Minor visual or content issues.
This helps QA teams spend testing time where it matters most.
---
Smoke Testing vs Regression Testing
A common mistake is treating every test as a regression test.
A smoke test should answer:
"Is the build stable enough for deeper testing?"
For a website, smoke tests might include:
1. Homepage loads.
2. Login works.
3. Main navigation works.
4. Core feature works.
5. Critical API works.
6. Logout works.
If smoke testing fails, the team may stop deeper regression testing until the major issue is fixed.
Regression testing is broader.
It verifies that changes haven't broken existing functionality.
---
Manual Testing vs Automated Website Testing
Manual testing remains valuable.
It is particularly useful for:
- Exploratory testing
- Usability
- Visual inspection
- New functionality
- Unexpected behavior
- Investigating failures
Automation is valuable for:
- Regression
- Smoke testing
- Repeated workflows
- Stable functionality
- Frequent releases
- Cross-browser execution
The best strategy is generally not:
"Manual or automation?"
It is:
"Which parts should be manual and which parts should be automated?"
---
Where AI Can Help With Website Testing
AI can assist QA teams with several activities.
For example, it can help generate:
- Test scenarios
- Edge cases
- Test cases
- Regression candidates
- Test data
- Bug summaries
- Test documentation
AI can also potentially help identify patterns across failures.
However, AI-generated tests still need QA review.
A generated test case is a suggestion.
It isn't automatically a correct requirement.
The QA engineer still needs to understand:
- Business risk
- Requirements
- User behavior
- Expected results
- System architecture
---
How RoboQA Fits Into Website Testing
One of the problems with traditional browser automation is the amount of effort required to turn a manual test idea into executable automation.
A QA engineer may need to:
1. Choose an automation framework.
2. Set up the project.
3. Identify selectors.
4. Write browser actions.
5. Add assertions.
6. Handle waits.
7. Maintain the script.
8. Debug failures.
9. Update the script when the UI changes.
This can be worthwhile for stable, critical automation suites.
But it can also create friction when a QA engineer simply wants to test a website workflow quickly.
This is one area where RoboQA is designed to help.
Instead of starting with a large automation script, a tester can describe what should be tested.
For example:
"Open the website, search for a product, open the first result, add it to the cart, proceed to checkout, and verify that the checkout page loads."
The idea is to move the starting point closer to:
TEST INTENT
rather than:
AUTOMATION CODE.
The goal isn't to eliminate QA engineers.
The goal is to reduce repetitive work between a QA engineer's testing idea and browser execution.
---
A Practical Website Testing Workflow
A QA engineer can approach a new website using the following process.
Step 1: Understand the Application
Identify:
- Core features
- User roles
- Critical workflows
- Integrations
- Supported browsers
- Supported devices
---
Step 2: Identify Risk
Ask:
What would hurt the business most if it failed?
For an e-commerce website, checkout may be the highest priority.
For a SaaS application, authentication and core workflows may be critical.
---
Step 3: Create Smoke Tests
Build a small set of tests that quickly establish whether the build is usable.
---
Step 4: Test Critical Features
Focus on the highest-risk workflows.
---
Step 5: Test Negative Scenarios
Don't test only successful workflows.
Ask:
"What happens when the user does something unexpected?"
---
Step 6: Test Different Environments
Verify supported:
- Browsers
- Devices
- Viewports
---
Step 7: Test Accessibility
Use keyboard navigation and other appropriate accessibility checks.
---
Step 8: Test Performance
Evaluate important pages and workflows under realistic conditions.
---
Step 9: Automate Stable Repetition
Automate workflows that are:
- Frequent
- Stable
- Business critical
- Deterministic
---
Step 10: Run Regression Before Release
Verify that new changes haven't broken existing functionality.
---
Complete Website Testing Checklist
Use the following condensed checklist during QA planning.
Functional
[ ] Homepage
[ ] Navigation
[ ] Links
[ ] Buttons
[ ] Forms
[ ] Search
[ ] Filters
[ ] Authentication
[ ] Logout
[ ] Password reset
[ ] Core workflows
[ ] File uploads
[ ] Downloads
[ ] Integrations
UI
[ ] Typography
[ ] Alignment
[ ] Spacing
[ ] Colors
[ ] Buttons
[ ] Icons
[ ] Images
[ ] Error states
[ ] Success states
[ ] Loading states
Responsive
[ ] Desktop
[ ] Laptop
[ ] Tablet
[ ] Mobile
[ ] Small mobile
[ ] Portrait
[ ] Landscape
[ ] Responsive images
[ ] Responsive tables
Compatibility
[ ] Chrome
[ ] Firefox
[ ] Edge
[ ] Safari
[ ] Supported mobile browsers
Accessibility
[ ] Keyboard navigation
[ ] Focus order
[ ] Focus visibility
[ ] Labels
[ ] Error identification
[ ] Image alternatives
[ ] Color independence
[ ] Text readability
Performance
[ ] Page loading
[ ] Images
[ ] JavaScript
[ ] API responses
[ ] Slow network
[ ] Large pages
[ ] Error handling
Security
[ ] Authentication
[ ] Authorization
[ ] Session management
[ ] Logout
[ ] Protected pages
[ ] Input handling
[ ] Sensitive information
[ ] Error exposure
Regression
[ ] Smoke tests
[ ] Critical workflows
[ ] Previously fixed bugs
[ ] High-risk features
[ ] Cross-browser checks
---
Final Thoughts
Website testing is not simply a matter of opening every page and checking whether it loads.
A website should be tested as a complete product.
That means asking:
Does it work?
Does it work when users make mistakes?
Does it work on different devices?
Does it work in supported browsers?
Can users navigate it with a keyboard?
Does it remain usable when APIs fail?
Does authentication behave correctly?
Are protected resources actually protected?
Does the website remain responsive under realistic conditions?
And most importantly:
Can users successfully complete the workflows that matter to the business?
A good website testing strategy combines functional testing, exploratory testing, UI testing, accessibility, compatibility, performance, security, and automation.
Automation can remove repetitive work.
AI can assist with test generation and analysis.
But QA engineers still provide the most important part of the process:
understanding what should be tested and why.
The goal isn't to produce the largest possible test suite.
The goal is to build confidence that the website will behave correctly when real users interact with it.
And as websites become more complex, that confidence becomes increasingly important.
For teams that want to move from manual test ideas toward executable browser testing, tools such as RoboQA can help bridge the gap between describing a workflow and actually testing it.
The best website testing strategy is ultimately the one that combines good test design, appropriate automation, risk-based prioritization, and continuous feedback.
Test the happy path.
Test the failure path.
Test the edge cases.
Test the real user journey.
And test the things that matter most.