Template
Pentest Report Template
Every section a penetration test report needs, a finding format your engineers can act on and an auditor can trace, and a checklist to run before the report leaves your hands. Copy it, fill in each field, cut what your engagement didn't cover.
Post-Exploitation · Updated November 16, 2026
What a pentest report has to do
The test is over when the report is read, not when the testing window closes. A penetration test report is the only thing most of the client organisation will ever see of the work, so it has to do three jobs at once:
- Tell leadership what is at risk in terms they can weigh against other spending: which data, which customers, which actions an attacker could take.
- Give engineers enough to reproduce and fix each issue without a call to the tester: the exact asset, the request, the evidence and a specific fix.
- Stand up as evidencefor an auditor or an enterprise customer's security review: what was in scope, how it was tested, and what became of every finding.
Most weak reports fail the second and third jobs. They list scanner output with a CVSS score and stop, so engineers can't reproduce the issue and nobody can show it was ever closed. The template below is built around the record each finding needs, from discovery to a verified retest. For why each part of that record matters to an auditor, read Writing Audit-Ready Penetration Test Findings.
The template
Plain Markdown, so it pastes into a docs tool, a repository or a ticket. Each field is left blank after its label, with a note on what goes there.
# Penetration Test Report
- Client:
- Application or environment tested:
## 1. Document control
- Report version:
- Status (Draft, Final or Retest addendum):
- Testing window, first and last day:
- Report date:
- Prepared by (testing firm or team, tester names and certifications):
- Reviewed by, and date of review:
- Distribution (named recipients only; mark the report confidential):
## 2. Executive summary
- What was tested and why, in one paragraph:
- Overall result, in one or two sentences a non-engineer can repeat:
- Findings by severity (Critical, High, Medium, Low, Informational):
- Most important risks, each described as what an attacker could do, to which data or customers:
- Strategic recommendations, the two or three changes that remove the most risk:
## 3. Scope
- In scope (hosts, URLs, APIs, repositories, cloud accounts, mobile builds, with versions):
- Out of scope (systems, techniques or data excluded):
- Test type (blackbox, greybox or whitebox) and the access provided (source code, cloud read access, test accounts and their roles):
- Rules of engagement (testing hours, rate limits, production or staging, data handling):
- Limitations (anything that prevented full coverage):
## 4. Methodology
- Approach and standards followed (for example OWASP WSTG, OWASP ASVS, PTES, NIST SP 800-115):
- Severity rating (scoring system and version, and how business context adjusts it):
- Tools and versions:
- Manual verification (how a person confirmed each finding):
## 5. Findings summary
| ID | Title | Severity | Affected asset | Status |
|----|-------|----------|----------------|--------|
| PT-01 | | | | |
## 6. Detailed findings
### PT-01: short, specific title
- Severity (score, scoring system and version, vector string):
- Status (Open; Fixed, pending retest; Closed, retest passed; Risk accepted):
- Affected assets (endpoint, parameter, file and line, cloud resource):
- Weakness class (CWE ID and name):
- Description (what is wrong, in two or three sentences):
- Business impact (what an attacker gains: whose data, which action, how far it spreads):
- Steps to reproduce:
1. Starting position (account, role, network location):
2. Exact request, payload or command:
3. Observed result:
- Evidence (request and response pairs, screenshots, logs; redact secrets and personal data):
- Remediation (the specific fix, with a secure code or configuration example):
- Owner (team or person accountable for the fix):
- References (vendor advisories, OWASP pages, CWE entry):
## 7. Remediation and retest log
| ID | Fix reference (PR, commit or ticket) | Fixed on | Retested on | Retest result | Tester |
|----|--------------------------------------|----------|-------------|---------------|--------|
| PT-01 | | | | | |
## 8. Appendices
- A. Scan output and tool logs:
- B. Full list of tested assets:
- C. Accounts, keys or artefacts created during testing, and confirmation they were removed:
- D. Definitions of each severity rating:
- E. Attestation letter, if one was issued:
Section by section
1. Document control
Version, status, testing window, authors, reviewer and who may read it. It looks like administration, but it is what lets anyone later tell the draft from the final report and the original from the retest addendum. Name the testers and their qualifications: a reviewer checking whether the test was done by competent people looks here first.
2. Executive summary
One page, written last. Say what was tested, the overall result in a sentence, the count of findings by severity, and the two or three risks that matter most, described by what an attacker could do rather than by vulnerability class. “Any signed-in customer could download any other customer's invoices” gets a fix funded; “IDOR in billing API” does not. End with the few changes that would remove the most risk. For how to pitch the same finding to engineers and to executives, see Communicating Vulnerability Severity to Engineering and Executive Stakeholders.
3. Scope
List exactly what was in scope, down to versions, environments and repository names, and what was excluded. State the test type (blackbox, greybox or whitebox) and what access came with it: source code, cloud configuration, test accounts and their roles. Access shapes what the test could find, so a reader needs it to judge what a clean result means. Record anything that limited coverage, such as an environment that was down for part of the window.
4. Methodology
Name the methodology you followed, such as the OWASP Web Security Testing Guide, OWASP ASVS, PTES or NIST SP 800-115, and how you rated severity. Say how findings were verified by a person. Keep it short: this section proves the test was systematic, it is not a tutorial.
5. Findings summary
One table, one row per finding, sorted by severity. Give every finding a stable ID (PT-01, PT-02) and use it everywhere afterwards: in tickets, commit messages and the retest log. That ID is what ties the fix back to the finding.
6. Detailed findings
The body of the report. Each finding follows the same structure so it can be lifted into a ticket on its own; the next section covers how to write one.
7. Remediation and retest log
For every finding: the change that fixed it, when, when it was retested, by whom, and the result. This is the section reports most often leave out, and without it a finding that was fixed still looks open to anyone checking. Re-run the original exploit against the fixed system and record the outcome against the original ID.
8. Appendices
Raw tool output, the full asset list, and a record of anything the testers created (accounts, files, keys) and confirmation it was removed. Leave the body for findings a person has confirmed.
Writing a finding
A finding is complete when a reader can answer each of these from it alone:
| Field | What it answers |
|---|---|
| Title | What is wrong and where, specifically. “Invoice download does not check account ownership”, not “Broken access control”. |
| Severity | How urgent it is, with the score, the scoring system and version, and the vector. |
| Affected assets | The exact endpoint, parameter, file and line, or cloud resource. |
| Weakness class | The CWE entry, so findings can be grouped and trended across tests. |
| Business impact | What an attacker gains, in terms of data, money, customers or reach. |
| Steps to reproduce | Starting position, exact requests or commands, observed result. |
| Evidence | Request and response pairs, screenshots or logs proving it worked, with secrets redacted. |
| Remediation | The specific fix for this code or configuration, not a generic best practice. |
| Owner and status | Who is fixing it, and where it stands now. |
Of these, impact and evidence are what separate a proven finding from a scanner hit. Showing what an attacker actually reached, and not what they theoretically could, is covered in Demonstrating Business Impact Through Data Exfiltration Proof.
A worked example
An illustrative finding for a fictional SaaS billing API, filled in the template's format. The company, endpoint and values are made up; the shape is the point.
PT-03 Invoice download does not check account ownership
- Severity: High. State the CVSS version and vector string you scored it with.
- Status: Fixed, pending retest
- Affected asset:
GET /api/v2/invoices/{invoice_id}/pdf,billing/views.py, functiondownload_invoice - Weakness class: CWE-639, Authorization Bypass Through User-Controlled Key
- Description:The endpoint confirms the caller is signed in but never checks that the requested invoice belongs to the caller's account. Invoice IDs are sequential.
- Business impact:Any customer with a free account can download every other customer's invoices, exposing names, billing addresses, plan and amounts paid.
- Steps to reproduce:Sign in as test user A (account 1). Request an invoice ID that belongs to test user B (account 2). The server returns B's invoice PDF with HTTP 200.
- Evidence: Request and response pair for the cross-account download, with the session token redacted.
- Remediation:Look up the invoice scoped to the caller's account (filter by both
invoice_idandaccount_id) and return 404 when it isn't theirs. Apply the same check to the other invoice endpoints. - Owner: Billing team
Rating severity
Most reports use FIRST's Common Vulnerability Scoring System (CVSS). Version 3.1 is still widespread and version 4.0 is the current release; say which you used and include the vector string, so a reader can check the score rather than take it on trust.
A base score describes the vulnerability in the abstract. It doesn't know that the affected endpoint serves your largest customer's data, or that it is only reachable from an internal network. Say in the finding how business context changed the rating you gave, and keep the scale definitions in an appendix so “High” means the same thing in every report you write.
When the report is audit evidence
Many pentests are commissioned because a SOC 2 audit, an ISO 27001 certification, PCI DSS or an enterprise customer asks for one. In those cases the report is read by someone checking that controls work, and they tend to look for the same things: a defined scope, a named methodology, findings that were proven, an owner for each, and a record that each was fixed and retested.
- SOC 2: pentest results are commonly offered as evidence for the monitoring and system operations criteria (CC4.1 and CC7.1).
- ISO 27001:2022: testing supports Annex A control 8.8, management of technical vulnerabilities.
- PCI DSS v4.0: Requirement 11.4 covers external and internal penetration testing, including retesting after corrections.
Requirements change between versions of each standard. Confirm what your auditor expects, and in what form, before testing starts, and check the current text of the standard itself rather than relying on a summary like this one.
Checklist before you send it
- The executive summary fits on one page and names risks in business terms.
- Scope lists every asset tested, with versions and environments, and what was excluded.
- Every finding has a stable ID used consistently through the report.
- Every finding was reproduced by a person; unverified scanner output is in an appendix.
- Every severity rating states its scoring system, version and vector.
- Every finding has reproduction steps an engineer can follow without asking.
- Evidence is attached, and secrets, tokens and personal data in it are redacted.
- Remediation advice is specific to the affected code or configuration.
- Each finding has an owner on the client side.
- Test accounts, files and keys created during testing are listed and confirmed removed.
- A second tester or reviewer has read the report and signed off.
- The report is marked confidential and shared only with the named distribution list.
- A retest is scheduled, and the retest log is ready to fill.
AI-assisted testing can widen coverage, but the report's credibility still rests on a person confirming each finding. See Limitations of AI-Only Vulnerability Assessment Without Human Review.
Questions
How long should a penetration test report be?
As long as its findings need and no longer. The executive summary should fit on one page; each finding should stand on its own so it can be pasted into a ticket. Pages of raw scanner output belong in an appendix, not the body.
Who is the report written for?
At least three readers: executives deciding what to fund, engineers fixing each finding, and, increasingly, an auditor or an enterprise customer's security reviewer checking that testing happened and that findings were closed. The template's sections are split so each reader can find their part without reading the rest.
Should automated scan results go in the findings?
Only once a person has confirmed them. An unverified scanner hit reported as a finding costs engineering time when it turns out to be a false positive and undermines the findings that are real. Keep raw output in an appendix and promote what you have reproduced.
Is there a required format for a pentest report?
No single format is mandated. Compliance frameworks and customers care that the report shows scope, method, proven findings and how each was resolved. Check what your auditor or customer expects before the engagement starts, not after the report is delivered.
What happens after the report is delivered?
Findings are fixed, then retested, and the retest result is recorded against the original finding ID, either in a retest addendum or an updated version of the report. Without that record a fixed finding still reads as open to anyone checking.



