It's Thursday afternoon and the release goes out tomorrow. The test spreadsheet has 200 rows, most of them ticked. Then someone asks in the channel: "Did anyone try it in Safari?" A minute later: "What happens if your session expires on the payment page?"
Nobody knows. That isn't a people problem. It's a checklist problem: the checks exist in people's heads, not in an order the team runs every time.
To test a web application, work through a fixed order: core functions, forms and validation, navigation and sessions, cross-browser and responsive layouts, accessibility against WCAG 2.2, the API and back end, performance, OWASP security basics, compatibility and usability. Then automate the critical journeys as a regression suite that runs in CI on every change.
Key takeaways
- Test in order. Functional and form checks come first, because every later check depends on them.
- Cross-browser, API and security checks belong in the same flow as functional tests, not in a separate phase at the end.
- Use published standards as your pass bar: WCAG 2.2 AA for accessibility, Core Web Vitals for speed, the OWASP Top 10 for security.
- Automate the journeys you check every release, and keep exploratory and usability testing with people.
What is web application testing?
Web application testing checks that a browser-based application works, looks right, performs well and is secure for the people who use it. It covers the user interface, the APIs and services behind it, and the data they store.
There are many types of web testing, and we describe each in types of web application testing. This post is the practical version: a checklist you can work through, in order, for every release.
In what order should you test a web application?
Start with what everything else depends on, and finish with checks that need a stable build. Here's the order this checklist follows:
| Step | Area | Main question | Automate? |
|---|---|---|---|
| 1 | Functional | Do the core features work? | Yes, core journeys |
| 2 | Forms and validation | Does every input accept good data and reject bad data? | Yes |
| 3 | Navigation and sessions | Do links, back buttons and sessions behave? | Mostly |
| 4 | Cross-browser | Does it work in every browser you support? | Yes |
| 5 | Responsive | Does it work at phone, tablet and desktop sizes? | Partly, plus visual checks |
| 6 | Accessibility | Does it meet WCAG 2.2 AA? | Partly; manual for screen readers |
| 7 | API and back end | Do the services return the right data and errors? | Yes |
| 8 | Performance | Is it fast, and does it hold up under load? | Yes |
| 9 | Security basics | Are the OWASP Top 10 risks covered? | Scanners plus manual review |
| 10 | Compatibility | Does it work with real-world settings and devices? | Partly |
| 11 | Usability | Can people complete tasks without help? | No, test with people |
| 12 | Regression and CI | Does everything that worked last release still work? | Yes, always |
Step 1: How do you test a web app's core functions?
List the five to ten things your application exists to do, then check each one end to end with realistic data.
- Sign-up, sign-in, sign-out and password reset work.
- Each core journey completes: for example search, add to basket and pay, or create, edit and share a record.
- Users see only what their role allows, and admin actions are blocked for normal users.
- Emails, notifications and downloads triggered by a journey arrive and contain the right data.
- Results are saved: refresh the page and the data is still there.
- Error states are handled: empty results, failed payments and missing records show a clear message.
Step 2: How do you test forms and validation?
Forms are where users give you data, so they're where most user-facing bugs live.
- Required fields are marked and enforced.
- Each field accepts valid input, including long names, accents, apostrophes and non-Latin scripts.
- Invalid input is rejected with a message that says what to fix, next to the field.
- Validation runs on the server as well as in the browser. Bypass the browser checks and submit again.
- Limits are enforced: maximum lengths, number ranges, file types and file sizes.
- Submitting twice quickly creates one record, not two.
- Input survives a failed submission, so users don't retype everything.
- Autofill and password managers fill the right fields.
Step 3: How do you test navigation, links and sessions?
Users don't move through your app the way the design file assumes. Test the paths they actually take.
- Every link and button goes where it should, with no broken links or 404s.
- The browser back and forward buttons work, including in single-page apps.
- Deep links and bookmarks open the right page, signed in and signed out.
- Refreshing mid-journey doesn't lose data or repeat an action.
- When a session expires, the user is asked to sign in and returned to where they were.
- Opening the app in two tabs doesn't corrupt data.
- Signing out ends the session; the back button doesn't show private pages.
Step 4: How do you test across browsers?
Browsers use different engines: Blink in Chrome and Edge, WebKit in Safari, Gecko in Firefox. A journey that works in one can fail in another.
- Pick your supported browsers and versions from your own analytics, and write them down.
- Run your core journeys in each: typically Chrome, Safari, Firefox and Edge.
- Test Safari on real Apple hardware. Playwright's browsers docs note that its WebKit build isn't branded Safari, and recommend running WebKit on a Mac for the closest match.
- Check date pickers, file uploads, video, clipboard and print, which often differ between browsers.
- Check fonts, spacing and layout for visual differences.
For a deeper guide, see browser testing for web apps.
Step 5: How do you test responsive layouts?
Most web apps are used on phones as well as desktops. Test the layout at every size you support.
- Check each breakpoint and the widths between them.
- Content works at 320 CSS pixels wide without horizontal scrolling, as WCAG 2.2 Reflow expects.
- Navigation menus work by tap, not only on hover.
- Tables, modals and long forms are usable on a small screen.
- Test on at least one real iPhone and one real Android phone before release, not only in desktop emulation.
- Add screenshot comparison for key pages to catch visual regressions.
Step 6: How do you test accessibility against WCAG 2.2?
WCAG 2.2 is the W3C's current accessibility standard, and level AA is the common target. Automated scanners find some issues; people with assistive technology find the rest.
- Every page can be used with the keyboard alone, with a visible focus indicator.
- Images have alt text, and form fields have labels.
- Text contrast meets 4.5:1 for normal text.
- Pointer targets are at least 24 by 24 CSS pixels, or well spaced, per Target Size (Minimum).
- Error messages are announced and explain how to fix the problem.
- A screen reader user can complete your core journeys, tested with NVDA or JAWS on Windows and VoiceOver on Mac or iPhone.
- Pages zoom to 200% without loss of content.
Step 7: How do you test the API and back end?
The UI is only as reliable as the services behind it. Test the API directly, as well as through the screens.
- Each endpoint returns the right data and status codes for valid requests.
- Invalid input returns a clear 4xx error, not a 500.
- Unauthenticated and unauthorised requests are refused, even when the UI hides the button.
- Responses match the documented contract, such as your OpenAPI definition.
- Data written through the API matches what the UI shows, and the other way round.
- Third-party failures, such as a payment provider timing out, are handled gracefully.
- Background jobs, queues and scheduled tasks complete and report errors.
Our API testing guide covers methods and tools in more detail.
Step 8: How do you test web app performance?
Speed is a feature. Test it for single users and under load.
Google's Core Web Vitals give a pass bar for real users, measured at the 75th percentile of page loads:
| Metric | What it measures | "Good" threshold |
|---|---|---|
| Largest Contentful Paint (LCP) | Loading | 2.5 seconds or less |
| Interaction to Next Paint (INP) | Responsiveness | 200 milliseconds or less |
| Cumulative Layout Shift (CLS) | Visual stability | 0.1 or less |
- Run Lighthouse on key pages, with mobile settings as well as desktop.
- Check field data from real users, not only lab scores.
- Load test the journeys that matter at expected peak traffic, then beyond it, and watch response times and error rates.
- Check that slow pages degrade gracefully, with loading states rather than frozen screens.
For load testing methods, see our guide to web app load testing.
Step 9: How do you cover security basics?
A checklist doesn't replace a penetration test, but it catches the common, costly gaps. Use the OWASP Top 10:2025 as your map:
| OWASP Top 10:2025 | What to check |
|---|---|
| A01 Broken Access Control | Change IDs in URLs and API calls; users must not see others' data |
| A02 Security Misconfiguration | No default accounts, debug pages or verbose errors in production |
| A03 Software Supply Chain Failures | Dependencies are tracked, patched and from trusted sources |
| A04 Cryptographic Failures | HTTPS everywhere; sensitive data encrypted at rest |
| A05 Injection | Inputs are parameterised; try SQL and script injection in forms |
| A06 Insecure Design | Abuse cases, such as unlimited coupon use, are designed out |
| A07 Authentication Failures | Rate limits on sign-in, strong password rules, secure session handling |
| A08 Software or Data Integrity Failures | Updates, plugins and pipelines can't be tampered with |
| A09 Security Logging and Alerting Failures | Sign-ins, failures and admin actions are logged and alerted |
| A10 Mishandling of Exceptional Conditions | Errors fail safely, without leaking data or skipping checks |
Add an automated scanner, such as the open-source ZAP, to your pipeline for repeatable checks. Our guide to web application security testing goes further.
Step 10: How do you test compatibility?
Compatibility testing checks the app against the messy settings of real users, beyond the browser list in step 4.
- Operating systems: Windows, macOS, iOS and Android versions you support.
- Screen resolutions and zoom levels, including high-DPI displays.
- Time zones, date formats, currencies and languages, including right-to-left if you support it.
- Blocked third-party cookies, strict tracking protection and common ad blockers.
- Slow or unstable connections.
- Older but still supported browser versions.
Step 11: How do you test usability?
Usability testing asks whether people can use the app, not whether it works. You can't automate it.
- Give three to five people from your audience a real task and watch, without helping.
- Note where they hesitate, misread a label or take a wrong turn.
- Check that error messages and empty states tell people what to do next.
- Check that wording is consistent across pages, emails and help content.
- Fix the biggest problems and test again.
Step 12: How do you set up regression testing and CI?
Everything above finds bugs once. Regression testing makes sure they stay fixed.
- Choose the suite. Automate the checks you repeat every release: core journeys, key forms, cross-browser runs, API checks.
- Run a smoke set on every pull request. Five to fifteen critical journeys, fast enough that developers wait for it.
- Run the full regression nightly or on merge, in parallel across browsers.
- Block releases on critical failures, and quarantine flaky tests visibly instead of rerunning them until they pass.
- Keep evidence: video, screenshots and logs for every failure.
- Review the suite each quarter. Delete tests that no longer earn their place.
Our guide to automated regression testing covers suite design in depth.
How do you run functional, cross-browser, API and security checks in one flow?
Treating each check as a separate phase is how Safari and session bugs get missed. Run them as stages of one pipeline instead:
- On every pull request: smoke journeys in one browser, plus API checks on changed endpoints.
- On merge: full functional and form tests across your supported browsers, plus the API suite.
- Nightly: responsive and visual checks, accessibility scans, an automated security scan and a Lighthouse run.
- Before release: load tests, manual accessibility checks with a screen reader, exploratory testing and a short usability check.
One report for all stages shows a release manager the whole picture in one place.
What does a web application testing checklist template look like?
Copy this structure into your tracker or spreadsheet. The example row is illustrative.
| ID | Area | Check | Browsers or devices | Expected result | Automated? | Owner | Status |
|---|---|---|---|---|---|---|---|
| F-04 | Forms | Checkout rejects an expired card | Chrome, Safari, Firefox, Edge | Error shown next to the card field; no order created | Yes | QA | Pass |
Keep one row per check, link each to the requirement or story it covers, and record the build it was last run on.
Web application testing with Robonito
Robonito is an agentic QA platform: AI agents create, run and maintain end-to-end tests. Web testing is on every plan, including Free.
- Plain-language tests. In AI Studio, describe what to test, paste a URL or reference a Jira issue, and the agent works through the app step by step. AI Studio can also generate tests from requirement documents, Jira stories and epics, Swagger/OpenAPI definitions and the live app.
- Functional and API checks in one suite. API testing is on Pro and Enterprise, and you can import Postman collections, so UI journeys and API checks run together.
- Cross-browser runs. See cross-browser testing for how one journey runs across browsers.
- Self-healing. When labels, layouts or locators change, steps adapt instead of failing, and healed steps are logged for review.
- Evidence and trends. Every run keeps video, network traces and an AI root cause for failures, plus pass rates, trends and risk analysis.
- CI. Jenkins, GitHub Actions, GitLab CI, Azure DevOps and CircleCI, plus Jira, Slack, TestRail and Zephyr. CI/CD, Jira and Slack are on Starter and above.
- Load testing is on Pro.
Pricing. Free covers web with 100 test cases, 1 parallel run and unlimited local runs. Starter is $20 a month and adds CI/CD, Jira and Slack. Pro is $199 a month and adds API, mobile and desktop testing, load testing and 10 parallel runs. Enterprise is custom; see pricing.
Where it doesn't fit. Robonito doesn't replace a security scanner or a penetration test, so keep tools like ZAP and expert reviews for step 9. Usability testing still needs real people. And if your developers want every browser test in the repository as code, a framework such as Playwright may suit that layer better; Robonito can generate executable code for test cases if you need it.
with your release checklist, or on your web app.
Frequently asked questions
What is web application testing?
Web application testing checks that a browser-based app works, looks right, performs well and is secure. It covers functional behaviour, forms, navigation, cross-browser and responsive layouts, accessibility, APIs, performance, security, compatibility and usability. Teams combine manual testing for usability and exploration with automated regression tests that run on every change.
How do you test a web application step by step?
Start with core functions and forms, then navigation and sessions. Next, test across browsers and screen sizes, check accessibility against WCAG 2.2 AA, test the API directly, measure performance against Core Web Vitals and cover OWASP Top 10 security basics. Finish with compatibility and usability checks, then automate the repeatable checks into a regression suite in CI.
What should a web app testing checklist include?
At minimum: core journeys, form validation, links and sessions, supported browsers, responsive layouts, keyboard and screen reader access, API responses and errors, page speed and load, access control and injection checks, and a regression suite. Each item should have an expected result, an owner, and a note on whether it's automated.
Which web application tests should be automated?
Automate the checks you repeat every release: core journeys, form validation, cross-browser runs, API checks, visual comparisons and performance budgets. Keep exploratory testing, usability testing and manual screen reader checks with people. A good test is one that would hurt if it failed and that you'd otherwise run by hand every release.
How is web application testing different from website testing?
A website mostly shows content, so testing focuses on links, layout, speed and accessibility. A web application lets users sign in, enter data and complete tasks, so testing adds functional journeys, form validation, sessions, roles and permissions, APIs and security. Most of the checklist applies to both, but apps need far more functional and security coverage.
How often should you run a web app testing checklist?
Run the automated parts on every change: a smoke set on each pull request and the full regression nightly or on merge. Run the manual parts, such as usability, screen reader and exploratory checks, before each significant release. Review the checklist itself every quarter, adding checks for bugs that escaped and removing ones that no longer matter.
Turn the spreadsheet into a suite that runs itself. to see your web journeys and API checks in one flow, or .




