Skip to content
web application testingweb app pentestingpenetration testing steps

Web Application Testing Process: A Pentest Walkthrough

Web Application Testing Process: A Pentest Walkthrough

You've got a client application in staging, a scanner license, two test accounts that may or may not still work, and a report due before the next release. It's tempting to point Burp Suite or Nuclei at the login page and call whatever comes back a test. That approach produces alerts, not proof, and it usually misses the flaw that matters most, one user reaching another user's data.

A defensible web application testing process puts multi-account authorization testing and business-flow abuse at the center. Scanners help you find candidates. Your job is to reproduce each one, show who could misuse it, and preserve evidence a client engineer can act on without asking you to repeat the work.

Table of Contents

Phases of a Web Application Test at a Glance

Phase Main question Key output Common tools
Scoping and authorization What is in and out of bounds? Signed scope, test accounts, exclusions Scope template, password manager
Reconnaissance What hosts, technologies and services are exposed? Asset and technology inventory Nmap, DNS and certificate lookups
Attack surface mapping Which roles, workflows and APIs exist? Surface map with parameters and roles Burp Suite, OpenAPI files, browser devtools
Scanning and discovery Where could weaknesses be? Unverified candidate findings Nuclei, ffuf, Burp Scanner
Exploitation and verification Can each finding be reproduced and misused? Request and response proof per finding Burp Repeater, SQLMap on approved parameters
Evidence capture What must be preserved for the report? Evidence archive with timestamps and accounts Burp project files, screenshot tools
Reporting and retest What is the risk and is it fixed? Risk-rated report and retest result Report template, retest scripts

Where Testers Get Stuck

Scoping and authorization is often the longest phase on client-facing work. You're confirming hosts, versions, accounts, exclusions, testing windows and escalation contacts, and none of that feels technical. Skip it and a technically strong test can still fail in the client's eyes because you tested the wrong tenant, hit an excluded service, or can't prove who approved the work.

Attack surface mapping is the next trap. A crawl of public pages isn't a map. You need every role, tenant, state-changing workflow, parameter and API family recorded before scanning starts, otherwise automated checks only cover the paths one account happened to visit.

Don't confuse the middle two phases. Scanning and discovery produces an unverified list. Exploitation and verification turns an item on that list into a finding by reproducing it under controlled conditions. If you can't replay it, you don't report it as confirmed.

Practical rule: No phase is finished until its output exists as a document, file or archive someone else can inspect.

For a broader view of functional and non-functional checks that sit alongside security work, web application testing with Bridge Global is a useful companion read. Use the table above as your checklist for the rest of this walkthrough. If a row has no output yet, you're not ready to move on.

Scoping and Authorization Before Any Request

Don't send a request until this setup is signed. Mistakes here are cheap to fix on paper and expensive once traffic hits a live system.

The Setup Routine

  1. Get written authorization: Name the asset owner and approver, and record the approval date. Verbal permission from a developer who doesn't own the asset isn't authorization.
  2. List the exact scope: Record every in-scope host, API base URL and application version. Separately list excluded hosts, including third-party SaaS, hosting and telecom services that need their own testing permission.
  3. Create accounts per role and tenant: Provision at least one account for each role in each tenant. Cross-account authorization tests later are impossible if everyone shares one admin login.
  4. Agree safety limits: Set request rate, testing windows, whether production is allowed, and which payloads are off limits, such as destructive SQL or mass data changes.
  5. Set the escalation path: Name who you call, how fast they respond, and what triggers an immediate stop, for example rising error rates or service instability.

This order reflects NIST Special Publication 800-115, which describes penetration testing as planning, discovery, attack, and reporting, and states that no actual testing occurs during planning. Rules of engagement, documented management approval and testing goals come first. Logs and periodic updates follow during discovery and attack.

If you're still separating general security testing from an authorized penetration test in your statement of work, compare security testing scope and methods before you draft the scope sheet. Our own penetration testing requirements checklist covers the same ground from the engagement side.

A Concrete Scope Sheet

Say you're testing a multi-tenant SaaS billing app. Your one-page sheet names two tenants, two users per role (admin, standard user, read-only), the staging host and API base, and one hard rule, only the test tenant's data may be changed. Payments run through an excluded third-party processor, so you test the handoff, not the processor.

That discipline matches how we work. Tests run only against targets the customer defines and authorizes, and scope, testing mode and schedule are set before anything launches. For each engagement, the customer must confirm and attest that they're authorized to test the specified targets and scope. Get the sheet signed, file it with the account list, and only then start mapping.

Mapping the Attack Surface Passively and Actively

The old API version is where this phase usually earns its keep. The illustration below shows the shift from quiet observation to deliberate probing that a good mapping pass follows.

An educational illustration showing a developer performing web application security testing through passive discovery and active probing.

Say the browser UI calls /api/v2/invoices and returns invoice ID, total and status. While browsing passively as a standard user, you spot a JavaScript bundle still referencing /api/v1/invoices/{id}, the route an older mobile build uses. You request the same invoice through v1 and get back the customer's tax ID and internal notes as well. Nothing has been exploited yet. You've found a second endpoint family with different field-level behavior, and it wasn't in the OpenAPI file the client sent you.

Passive Discovery First

Browse the application as each test account and record what it reveals without attacking it. Note response headers, cookies, allowed HTTP methods, JavaScript bundles and the API calls the front end makes. Compare the OpenAPI file or GraphQL schema against observed traffic, because undocumented, deprecated and older versions routinely differ from the documented surface.

Active Discovery Second

Run an authenticated crawl that records every state-changing request, then enumerate directories and parameters with ffuf against approved wordlists. Run Nmap port checks only on in-scope hosts. You're not hunting vulnerabilities yet, you're proving which endpoints, methods and parameters exist so later tests have somewhere to land. A structured attack surface mapping method helps keep that inventory consistent across engagements.

The short walkthrough below shows how passive observation and active probing fit together in practice before you build the final map.

What Good Looks Like

Record each role, tenant, object type and workflow in a surface map, with parameters and preconditions attached to every entry. Who can create an invoice, who can approve it, what state must it be in, and which endpoint performs each step.

A finished map lists every role, every state-changing action and every endpoint family, plus an honest note of what remains unknown.

That unknown column matters. If you couldn't reach the password reset flow because email delivery is disabled in staging, say so now. A gap you declare during mapping is a scope conversation. A gap a client finds in your report is a credibility problem.

Scanning, Exploitation and Verifying Each Finding

Automated tools produce candidates, not findings. Treat every scanner alert as a hypothesis until you've reproduced it by hand and shown what an attacker gains.

The OWASP Top 10 2021 data collection covered 515,000 applications, and it tells you where to look first. Broken access control ranked first, appearing in an average of 3.81% of tested applications with more than 318,000 mapped occurrences. Injection was tested in 94% of applications and security misconfiguration in 90%, so authorization, input handling and deployment configuration all deserve deliberate coverage, not just a scanner pass.

Test area How to verify Evidence to keep
Injection (SQL, XSS, command) Send controlled payloads to one parameter at a time and compare responses Request, payload, response excerpt, timing difference
Broken access control Replay the same object request with a second user account and an unrelated tenant Both responses side by side, account IDs used, object ID
Authentication and session Test lockout, token reuse after logout and session fixation Steps taken, token state before and after, timestamps
Security misconfiguration Check debug pages, default paths, verbose errors and missing security headers Header dump, screenshot of error page, affected URL
Business logic Repeat a coupon, transfer or invitation flow out of order or at volume Sequence of requests, account state before and after

The Verification Routine

Run Nuclei templates and Burp Scanner across the mapped surface, then work each candidate in Burp Repeater. Reproduce the original request, change one variable at a time, replay it with the second account, and confirm the impact. Can that account read, change or trigger an object it shouldn't reach.

Say a scanner flags possible broken access control on an invoice endpoint. You request invoice 1042 as User A, its owner, then replay the identical request as User B in another tenant. User B receives the full invoice body. That's proof. A bare 200 response wouldn't be, because plenty of applications return 200 with an empty object or an error payload.

Use SQLMap only on parameters already approved in scope, with the rate and payload limits you agreed. Our tests cover OWASP Top 10 vulnerabilities, SQL injection, XSS, authentication flaws and misconfigurations, and the engine orchestrates +60 pentesting tools, including Nmap, SQLMap and Nuclei, but tooling breadth doesn't replace this manual confirmation step.

Apply one inclusion rule to every item. A finding joins the confirmed list only when it has a reproducible exploit path, an affected endpoint and parameter, stated preconditions and an impact statement. Anything missing one of those stays a candidate, and you say so plainly.

Evidence Capture and Reports Clients Can Act On

Clients don't fix findings they can't reproduce. The checklist below is the minimum evidence set for every confirmed issue in your web application testing process.

A list outlining key components for effective security evidence capture and actionable reporting in software testing.

The Evidence Checklist

  • Exact request and response pair: Answers the engineer's first question, what did you send.
  • Account and role used: Shows which principal performed the action and which one shouldn't have been able to.
  • Timestamps: Lets the client correlate your test with their server and WAF logs.
  • Screenshot showing impact: Proves the effect in the UI when a response body alone is ambiguous.
  • Reproduction steps: Gives a client engineer a sequence they can follow without your Burp project open.
  • Impact statement in business terms: Translates a technical flaw into exposed records, altered balances or abused workflows.
  • Severity on a stated scale: Tells the client what to fix first and why you ranked it there.
  • Concrete fix: Names the control to add or change, not just the weakness to remove.

Write the report while testing runs, not after it ends. Logs rotate, sessions expire and screenshots get lost, and reconstructing evidence a week later produces the vague findings clients push back on. A consistent penetration testing reporting structure makes that concurrent writing much easier to sustain.

Report Structure That Works

Open with an executive summary covering overall risk and the top issues in plain language. Follow with a technical section holding one entry per finding, each carrying the full checklist above. Close with an appendix containing the surface map and tested accounts, plus a retest column that starts empty and fills in as fixes are verified.

If you're delivering as an MSSP, add a compliance mapping column when the client needs PCI DSS, SOC 2 or ISO 27001 references. Cite the specific control the finding touches. A general framework label tells an auditor nothing and tells the engineering team even less.

Model finding: As standard user B in Tenant 2, I replayed the request for invoice 1042 owned by Tenant 1 and received the full invoice, including customer tax ID. Any authenticated user can read any tenant's invoices by changing the object ID. Enforce tenant ownership checks server-side on every object request.

That paragraph works because it names the actor, the object, the data exposed and the fix in four sentences. If your findings don't read that clearly, the evidence underneath them usually isn't complete yet.

Running Retests and Continuous Testing for MSSP Clients

An annual pentest doesn't cover an application that ships every week. The test was accurate for the build you examined. It says nothing about the endpoint added last Tuesday or the role model changed in the latest sprint.

Where the Pentest Fits

Place testing across the lifecycle instead. Set security requirements and threat models during design, run code review with SAST and dependency scanning in builds, then DAST in staging. Manual penetration testing comes after those automated checks, against the release candidate, concentrating on deployed functionality, integrations, authorization boundaries and business logic that scanners can't judge.

Front-end changes deserve the same regression discipline. A practical guide to visual regression testing shows how teams catch unintended UI changes between releases, and the habit transfers directly, compare what changed, then retest what the change touches.

The Retest Routine

  1. Rerun the original exploit: Use the exact request, account and object from the report.
  2. Try adjacent variants: Test other roles, other object IDs and the alternate HTTP method on the same endpoint.
  3. Mark closed only after both pass: A fix that blocks one object ID but not the next one isn't a fix.

Don't wait for the annual engagement when the surface changes. A new endpoint, a new tenant type or a changed role model should trigger a targeted test of that change and its authorization boundaries.

Closing a finding because code changed isn't verification. Closing it because the original exploit and its variants now fail is.

Running This Across Clients

Reuse the account matrix and surface map from the previous engagement and update them, rather than rebuilding from zero each time. Tier clients by how often their applications change, so fast-shipping products get frequent targeted tests and stable ones get deeper periodic ones. Report retest outcomes with fixed and open items side by side, so clients see progress and remaining exposure in one view instead of hunting through two documents.

Confirm Scope and Run Your First Pilot Test

You don't need a full program to start. Run one small, complete pass this week and learn where your process breaks.

Three Steps This Week

  1. Pick one application: Choose a client app with a staging environment and a known set of roles. Small and well understood beats large and impressive for a pilot.
  2. Write and sign the scope sheet: Include two test accounts per role, the exclusion list and the safety limits, and get the asset owner to sign it. Confirm the customer defined and authorized every target before any request is sent, and record that confirmation with the signed scope.
  3. Run the pilot pass: Map the surface, run automated checks, verify three findings by hand, and write the evidence for each one in the report format from the previous section. Three fully proven findings teach you more than thirty unverified alerts.

Keep the toolkit simple. Use Burp Suite for mapping and replay, Nuclei for candidate checks, and a shared spreadsheet as the evidence archive with one row per finding. I'd resist adding more tools until the pilot shows a gap they would fill.

When pilot findings look wrong, check the account matrix and request timestamps first. A request replayed under the wrong account, or with an expired session, produces misleading results that look exactly like authorization failures or false negatives.

If you'd rather see the workflow run before building your own, you can create a free account through the registration portal, explore the platform and run a test pentest to see results firsthand, or request a demo for a full platform walkthrough. Either way, judge the output by the standard in this guide, reproducible proof per finding.


ThreatExploit AI automates reconnaissance, scanning, exploitation, verification and reporting for web applications and APIs, so your team can deliver evidence-backed, compliance-mapped pentest reports without adding senior testers. If you're building a repeatable web application testing process for your clients, visit ThreatExploit AI to see how the platform runs authorized tests end to end and produces reports your clients can act on.