Web Application Testing Checklist for 2026
Modern web apps have five testable layers. Skipping any one ships bugs to production. Here's the full checklist we use at QA Labs — from functional to accessibility to performance.

- web-testing
- functional-testing
- browser-testing
- QA-checklist
Short answer
A modern web application needs testing across five layers: functional, API, visual, accessibility and performance. Run functional, API and visual checks on every release, accessibility checks on every UI change, and performance tests continuously. Connecting all five layers to your CI pipeline is what stops old bugs from returning with new releases.
Key takeaways
- Modern web apps have 5 testable layers
- Functional + API + Visual = every release
- Accessibility = every UI change
- Performance = continuous, not one-off
- CI integration prevents regression on all layers
Web applications have gotten dramatically more complex in the last five years. Client-side rendering, edge functions, microservices, third-party integrations, and real-time data have created layers of risk that didn't exist when "web testing" meant clicking through pages.
Here's the five-layer checklist we use at QA Labs. It covers everything a modern web app needs to be tested for.
Layer 1 — Functional testing
- All user flows work end-to-end
- Form validation catches bad input
- Error states display correctly
- Auth flows (signup, login, reset, logout) behave
- Permission roles gate access correctly
- Edge cases (empty inputs, huge inputs, invalid characters) handled
- Session handling is correct
- Data persists across refreshes
Layer 2 — API testing
- Every endpoint returns expected data
- Auth headers required and validated
- Rate limits enforce
- Timeouts handled gracefully
- Concurrent requests don't corrupt data
- Third-party integrations handle failures
Layer 3 — Visual testing
- Layouts consistent across Chrome, Safari, Firefox, Edge
- Responsive design works on all breakpoints
- Fonts, colors, spacing match design
- No layout shift on load
- Images, icons, graphics render correctly
- Dark mode works (if applicable)
Layer 4 — Accessibility testing
- WCAG 2.1/2.2 AA compliance
- Keyboard-only navigation works
- Screen reader compatibility (VoiceOver, NVDA, TalkBack)
- Contrast ratios meet minimums
- Form labels and ARIA attributes correct
- Focus states visible
- Reduced-motion preferences respected
Layer 5 — Performance testing
Core Web Vitals meet targets (LCP <2.5s, INP <200ms, CLS <0.1)
- Load testing at expected peak traffic
- Stress testing beyond peak
- API response times meet SLOs
- CDN caching works
- Images optimized
- Bundle size within budget
Security checks to add
The five layers cover how the app works, looks and performs. Before a major launch, add a security pass as well:
- HTTPS everywhere, with secure and HttpOnly cookies
- Logout and session timeout invalidate tokens on the server
- Inputs checked for injection and cross-site scripting
- Users cannot reach other users' data by changing IDs in URLs or requests
- Password reset and email change flows cannot be abused
- Security headers set, such as Content-Security-Policy and X-Frame-Options
- Dependencies scanned for known vulnerabilities
Resilience checks
- Slow and unstable networks: pages and forms still work or fail clearly
- Browser back, refresh and multiple tabs do not lose or duplicate data
- Expired sessions explain what happened and keep unsaved work where possible
- A third-party service being down shows a clear error instead of a blank page
- Strict privacy settings and common ad blockers do not break core flows
Tools for each layer
| Layer | Common tools |
|---|---|
| Functional | Playwright, Cypress, Selenium |
| API | Postman and Newman, REST Assured, pytest |
| Visual | Playwright screenshot comparison, Percy, Applitools |
| Accessibility | axe, WAVE, Lighthouse, NVDA, VoiceOver |
| Performance | Lighthouse, PageSpeed Insights, k6, JMeter |
| Security | OWASP ZAP, Burp Suite, npm audit or Snyk |
What should you test first when time is short?
Rank your flows by how much revenue or trust depends on them and how often they change. Test the top of that list on every release and the rest on a rotation.
Keep a smoke suite of the five to ten flows that must never break, such as sign-up, login, the core task and payment, and run it automatically after every deploy. It takes minutes and catches the failures that hurt most.
Testing third-party integrations
- Payments: success, decline, 3-D Secure challenge, refund and webhook confirmation in the provider's test mode
- Sign-in with Google, Microsoft or other providers: first sign-in, returning user and revoked access
- Email and SMS: messages arrive, links work and unsubscribe works
- Analytics and tags: events fire once, with the right data, and only after consent where consent is required
- Maps, chat widgets and embeds: the page still works if they fail to load
Data and privacy checks
- Cookie banner choices are respected: no analytics or ad tags before consent where it is required
- Users can export and delete their data if your privacy policy says they can
- Personal data never appears in URLs, logs or error messages
- Test and staging environments hold no real customer data unless it is protected the same way
A release-day checklist
- Smoke suite passes against production after the deploy
- Error tracking and uptime monitoring show no new spikes
- Key journeys checked by hand on one phone and one desktop browser
- Analytics confirms conversions are still being recorded
- Rollback plan ready, with a named owner
- CDN cache purged if pages changed
Regression strategy for web apps
Every release risks breaking something that worked yesterday. Keep the regression suite focused on critical journeys and the parts of the app that change most, run it automatically, and add a test whenever a bug escapes to production so the same failure cannot come back unnoticed.
How to run this checklist
- Functional + API + Visual: Every release
- Accessibility: Every feature touching UI
- Performance: Before major releases and after infrastructure changes
- Full 5-layer: Before major launches
Mobile web checks
- Tap targets are large enough and not too close together
- Forms use the right keyboard for each field, such as email, number or phone
- Nothing overflows sideways at narrow widths such as 320 and 375 pixels
- Sticky headers, banners and chat widgets do not cover content or buttons
- Pages still work when the device rotates or the on-screen keyboard opens
Forms: where most bugs hide
- Required fields, formats and length limits are validated on both the browser and the server
- Error messages appear next to the field, in plain words, and are announced to screen readers
- Typed data is kept when validation fails
- Double-clicking submit does not create duplicate records
- Paste, autofill and password managers work
- International names, addresses and phone numbers are accepted
Cross-browser priorities
Use your analytics to choose browsers rather than testing everything equally. Most issues come from three engines: Chromium (Chrome and Edge), WebKit (Safari, including every browser on iPhone in most regions) and Gecko (Firefox). Covering one browser on each engine, plus Safari on a real iPhone, finds most cross-browser bugs.
Basic SEO checks
- Every page has a unique title and meta description
- Canonical URLs point to the page itself, not a duplicate
- Missing pages return a real 404 status, not a 200 with an error message
- Old URLs redirect permanently to their new address
- The sitemap lists only live pages, and robots.txt does not block important ones
- Structured data validates in Google's Rich Results Test
Who owns each testing layer?
| Layer | Usual owner | Runs when |
|---|---|---|
| Functional | QA with developers | Every release |
| API | Developers and QA | Every pull request |
| Visual | QA | Every release that touches the interface |
| Accessibility | QA and designers | Every interface change |
| Performance | Developers and DevOps | Before major releases and after infrastructure changes |
| Security | Developers with security specialists | Every pull request (scans) and before major launches |
Using this checklist with an outside QA team
If an outside team runs part of this checklist, agree three things up front: which layers they own, which browsers and devices they cover, and where bugs are reported. Share a test account for every user role, a staging environment that matches production, and the release calendar, so testing lands before deadlines rather than on them.
Keeping the checklist current
Review the checklist every quarter. Add a line whenever a bug escapes to production that the checklist would have caught, and remove checks that never find anything and are covered elsewhere. A checklist that grows with your product stays useful; one that never changes gets skipped.
Finally, keep the checklist where the team already works, such as a template in your tracker or a pull request checklist, rather than in a separate document nobody opens. Tick items per release and attach evidence for the layers that matter most to your customers, such as accessibility reports or load test results. Over a few releases, that evidence becomes a record you can show enterprise buyers, partners and auditors whenever they ask how you test your product.
Frequently asked questions
How long does it take to run this checklist? — It depends on the size of the app. The functional, API and visual layers can be largely automated and run on every release. Accessibility, security and full performance checks take longer and are usually scheduled before major releases.
Which layer should we automate first? — Start with functional smoke tests of the critical journeys and API tests for the endpoints behind them. They catch the most damaging failures and are the most stable to automate.
Do we need to test every browser? — Test the browsers your analytics show your users actually use, and always include Safari on iOS, because WebKit behaves differently from Chromium in ways that cause real bugs.
How often should we run a full accessibility audit? — A full WCAG audit once a year or before a major redesign is common, with automated checks on every release and manual checks whenever a key journey changes.
Common mistakes
- Testing only the happy path
- Skipping accessibility because "users don't complain"
- Ignoring visual regression until users report it
- Treating performance as a pre-launch check instead of continuous
- Not integrating any of this into CI
Free QA spot-check
Want a QA engineer to look at your product?
Send us your website or web app address. An engineer will test one key journey, such as sign-up, search or checkout, on desktop and mobile, and email you the most important issues we find. Free, and no call needed.
Related service
QA Testing →Automated suites, manual deep-dives, and CI guardrails that catch regressions before your users do.
Further reading
About the author
Kawsher, Founder, QA Labs →Kawsher is the founder of Quality Assurance Labs (QA Labs), the QA-first software testing and development company in Bogura, Bangladesh, founded in 2021. Every article and case study on this site is written or reviewed by Kawsher, drawing on the team's QA testing, AI, web, mobile, video and marketing work for SaaS and AI teams worldwide.


