A web application penetration testing checklist lists the tests a tester runs to find exploitable flaws in a web app. Testers group it by area: information gathering, configuration, identity, authentication, authorisation, sessions, injection, error handling, cryptography, business logic, client-side code, and APIs. Use it to plan the scope, run the test, and confirm coverage.
Pilots run a checklist before every flight, however experienced they are. The checklist does not fly the plane. Instead, it makes sure the pilot misses nothing obvious while their attention goes to the hard parts. A web application penetration testing checklist does the same job for a tester. It covers the routine checks reliably, so that skilled time goes to the flaws only a person can find.
What a Web Application Penetration Testing Checklist Covers
A good web application penetration testing checklist follows a published method, so anyone can check its coverage. Testers most often use the OWASP Web Security Testing Guide, which groups web application tests into categories.
A checklist is not a scan. Scanners can run many of the checks below, but the most damaging flaws, such as broken access control and business logic errors, need a tester who understands what the app should allow. For the full process around the checklist, see this guide to web application penetration testing.
Before Testing: Scope and Rules of Engagement
Most failed tests fail before the tester sends the first request. The scope was vague, the test accounts did not work, or nobody agreed on what to do if the tester found a critical flaw. Settle these points before you start the web application penetration testing checklist:
- Scope: Every URL, subdomain, and API endpoint in scope, plus anything explicitly out of scope
- Environment: Production, staging, or both, and any differences between them
- Test accounts: At least 2 accounts for every user role, so that you can test access between users
- Testing approach: Black box, grey box, or white box, and what documentation the tester receives
- Rules of engagement: Testing hours, rate limits, and any actions that are not allowed
- Contacts: Who to call if the app stops working or the tester finds a critical flaw
- Data handling: Where you store findings and test data, and how you delete them afterwards
- Backups: A recent backup of any environment where testing could change data
The Web Application Penetration Testing Checklist
The web application penetration testing checklist below follows the OWASP categories. Each item is a test to run, not just an item to mark as done: record what you tested, how, and what you found.
1. Information Gathering
In a web application penetration test, information gathering maps what exists before any attack begins. Many serious findings start here, with a forgotten admin page or an old API version.
- Search engines and public code sites for leaked paths, keys, and documents
- Server and framework details from headers, cookies, and error pages
- Hidden files such as robots.txt, sitemaps, and backup files
- Every entry point: forms, parameters, headers, cookies, and API endpoints
- Subdomains, virtual hosts, and other applications on the same server
- The app’s layout, including load balancers, content delivery networks (CDNs), and firewalls
2. Configuration and Deployment Management
Configuration tests check how your team set up the web application and its platform. Default settings and forgotten files are some of the easiest ways in.
- Unused HTTP methods, such as PUT and DELETE, that the server should refuse
- Security headers, including Content Security Policy and Strict Transport Security
- Admin pages open to the internet
- Old, backup, and unreferenced files left on the server
- File permissions and directory listing
- Cloud storage and hosting settings, such as publicly readable buckets
- Subdomain takeover through records that point to deleted services
3. Identity Management
Identity tests check how your web application creates, provisions, and manages accounts.
- Role definitions, and whether each role has only the access it needs
- The user registration process, including what checks it skips
- Accounts that admins create, and who can create which roles
- Account enumeration through login, registration, and password reset messages
- Weak or predictable username rules
Book Your Free Cybersecurity Consultation Today!
4. Authentication
Authentication tests check how your web application confirms that users are who they claim to be.
- Passwords sent without encryption
- Default passwords on any part of the system
- Lockout after repeated failed logins, and whether an attacker can bypass it
- Ways around the login page, such as direct requests to protected pages
- The “remember me” feature and stored credentials
- Password reset flows, including token strength and expiry
- Multi-factor authentication, including fallback options that bypass it
- Browser cache of pages with sensitive data
5. Authorisation
Authorisation tests check whether each user of your web application reaches only what they should. This category deserves the most manual time, because broken access control leads the OWASP Top 10, and scanners handle it poorly.
- Insecure direct object references: change an ID in a request and see whether another user’s data comes back
- Privilege escalation: perform admin actions from a normal account
- Horizontal access: reach another user’s records at the same role level
- Directory traversal and file inclusion
- Bypass of the authorisation scheme through alternative paths or methods
- OAuth weaknesses, such as missing state checks or open redirects
For example, a tester logged in as one customer changes an invoice number in the address and receives another customer’s invoice. Nothing in the response looks like an error, so a scanner reports nothing. Only a tester who knows the business rule sees the breach.
6. Session Management
Session tests check how your web application keeps track of a logged-in user.
- Cookie attributes: Secure, HttpOnly, and SameSite
- Session fixation: whether the session token changes at login
- Cross-site request forgery protection on every state-changing action
- Logout: whether the server really ends the session
- Session timeout, and whether old tokens still work
- Exposed session tokens in URLs or logs
- JSON Web Tokens: signature checks, algorithm handling, and expiry
7. Injection
Injection tests check whether user input can change how your web application behaves. This category covers the classic attacks.
- SQL injection, including blind and time-based variants
- Cross-site scripting: reflected, stored, and DOM-based
- Command injection on the server’s operating system
- Server-side request forgery, where an attacker tricks the server into calling other systems
- Server-side template injection
- XML external entity and other XML injection
- LDAP and NoSQL injection, where the app uses those back ends
- HTTP parameter pollution and header injection
8. Error Handling
Error tests check what your web application reveals when something goes wrong.
- Stack traces and debug messages shown to users
- Different error messages that reveal whether a record exists
- Unhandled errors that leave the app in an unsafe state
9. Weak Cryptography
Cryptography tests check how your web application protects data in transit and at rest.
- Transport Layer Security (TLS) versions and cipher suites, including weak or outdated options
- Sensitive data sent without encryption
- Weak or home-made encryption of stored data
- Padding oracle and other flaws in the encryption code
10. Business Logic
Business logic tests check whether attackers can abuse your web application’s own rules. No scanner can test these, because the rules are unique to each app.
- Skipping steps in a workflow, such as paying before anyone approves the order
- Limits enforced in the browser but not on the server
- Negative quantities, zero prices, and other values that break the rules
- Repeating actions that should happen once, such as redeeming a voucher twice
- Race conditions, where 2 requests at the same moment both succeed
- Upload of unexpected file types or malicious files
11. Client-Side Testing
Client-side tests check the web application code that runs in your users’ browsers.
- Cross-site scripting that runs in the browser’s Document Object Model (DOM-based)
- Open redirects that send users to attacker sites
- Clickjacking, where another site loads the app inside a hidden frame
- Cross-origin resource sharing (CORS) settings that trust too many other sites
- Sensitive data stored in browser storage
- JavaScript that exposes logic, keys, or hidden endpoints
12. API Testing
API tests apply the checklist to the interfaces behind your web application. Modern web apps often expose more through their APIs than through their pages. For a deeper treatment, see this guide to API penetration testing.
- Broken object-level authorisation on every endpoint that takes an ID
- Responses that return more data than the page shows
- Missing rate limits on login, search, and costly operations
- Old or undocumented API versions that are still live
- GraphQL introspection and query depth limits
13. WebAssembly
WebAssembly testing applies where your web application runs compiled code in the browser. Check whether the compiled modules expose sensitive logic or keys, and whether they trust input that the server should validate.
After Testing: Reporting and Retest Checklist
The test is not finished when the tester sends the last request. As a result, a complete web application penetration testing checklist ends with the report and the retest:
- Proof for each finding: the request, the response, and steps to reproduce it
- Severity in context: rated for this application and its data, not copied from a generic score
- Clear fixes: specific enough for a developer to act on without a follow-up call
- Executive summary: the business risk in plain terms
- Retest: the tester verifies each fix before anyone closes the finding
- Data deletion: test data and credentials removed once the engagement ends
Common Mistakes When Using a Checklist
A web application penetration testing checklist helps only if you use it well. However, 5 mistakes are common:
- Treating the checklist as the test. Marking an item as done is not the same as testing it properly. Record evidence for every item.
- Testing with one account. Without accounts for each role, nobody can finish the authorisation section properly.
- Skipping business logic. These tests take the most thought, so teams cut them first when time runs short.
- No retest. A finding is not fixed until someone confirms the fix works.
Web Vulnerability Assessment vs Penetration Testing Checklist
Web vulnerability assessments and penetration tests use overlapping checklists, but they stop at different points. A web vulnerability assessment finds and lists likely weaknesses, mostly with scanners, across many apps. A penetration test goes further: the tester exploits each weakness to prove it is real, and chains findings together to show the real impact.
In practice, the assessment covers breadth and the penetration test covers depth. A strong programme uses the assessment to keep the known weaknesses down, then uses the full web application penetration testing checklist on the apps that matter most.
Join our weekly newsletter and stay updated
Using Your Web Application Penetration Testing Checklist
The checklist was complete. The team marked every item as done, and the report went out on time. But nobody had logged in as a second customer, so the broken access control in the invoice system went unnoticed. A web application penetration testing checklist is only as good as the testing behind each line.
Use the checklist to plan the scope, run every category, and record evidence for each item. Then put the most skilled time into authorisation and business logic, where scanners help least and the damage is greatest.
If you would rather have experts run the full checklist, Kratikal’s web application security testing team tests every category, with retests included. For other systems as well, see its wider penetration testing services.
FAQs
Readers using a web application penetration testing checklist most often ask the questions answered here.
Web application penetration testing is a controlled attack on a web application by a skilled tester, with the owner’s permission. Testers try to find and exploit weaknesses in areas such as authentication, access control, sessions, and input handling. The goal is to prove which flaws an attacker could use, and how far they could get, so that the owner can fix them.
The steps in web application penetration testing are scoping, information gathering, testing, exploitation, reporting, and retesting. Scoping agrees on the targets and rules. The tester then maps the app, tests each area on the checklist, and exploits confirmed weaknesses to show impact. Finally, the report explains each finding and its fix, and a retest confirms each fix works.
The OWASP checklist for web applications comes from the OWASP Web Security Testing Guide, which groups web application tests into 13 categories. These include information gathering, configuration, authentication, authorisation, session management, injection, business logic, client-side testing, and APIs. Testers use it as a common method so that anyone can compare and check their coverage.
Tools used for web application penetration testing include Burp Suite and OWASP ZAP for intercepting and changing traffic, Nmap for mapping services, and sqlmap for SQL injection. Testers also use ffuf for finding hidden content and testssl.sh for checking encryption settings. Tools speed up testing, but flaws in access control and business logic still need manual work.
You do web application security testing by agreeing on a scope, mapping the app, and then testing each area on a checklist such as the OWASP categories. Use automated scanners for known weaknesses and manual testing for access control and business logic. Then report each finding with proof and a clear fix, and retest every fix before closing it.