Pentest Report Template: Structure, Fields, Example

A copy-paste pentest report template: the eight fields every finding needs, the section order a client reads, and a worked example.

A penetration test produces exactly one durable artefact: the report. Exploits get reverted, screenshots get lost, the tester moves to the next engagement. If the report cannot be understood by the engineer who has to fix the issue six weeks later, the test was a cost with no return.

Three readers, one document

  • The executive reads the first page only: what was tested, what the risk is, what it will take to fix. They need business consequence, not payloads.
  • The engineer reads the findings: how to reproduce it, what exactly is broken, and what to change. They need precision, file paths and commands.
  • The auditor or client reads scope, methodology and evidence. They need to know the test was thorough and repeatable.

Write the executive summary last, after the findings are settled. Never put the raw output of a scanner in it.

Structure that works

  1. Executive summary — one page. Risk posture, the two or three issues that matter, remediation priority.
  2. Scope and rules of engagement — what was in scope, what was explicitly out, timing, accounts provided, any restrictions.
  3. Methodology — the phases performed and the standards followed, briefly.
  4. Findings — ordered by severity, not by discovery order.
  5. Appendix — evidence, tool output, and anything that supports a finding without cluttering it.

The finding template

Every finding, without exception, answers the same eight questions:

FieldWhat it must say
TitleWhat is broken, in plain words. "IDOR in invoice download lets any user read other customers' invoices", not "Broken access control".
SeverityScore plus the reason. CVSS alone is not a risk rating — add what an attacker actually gains here.
Affected assetHost, endpoint, version, environment. Specific enough to fix the right thing.
DescriptionThe technical cause in a short paragraph.
ImpactWhat an attacker could do with it, in this environment. Data? Downtime? Lateral movement?
ReproductionNumbered steps a stranger can follow. Include the exact request and the exact response.
EvidenceScreenshots or logs that prove it, redacted of real customer data.
RemediationThe specific change to make, plus a safer fallback if that change is not possible soon.

Reproduction steps a stranger can follow

The test of a good write-up: hand it to a developer who has never seen the application and watch whether they reproduce the issue without asking you a question. That means including the account used and its privilege level, the request exactly as sent (method, path, headers that matter, body), the response that proves the issue, and any precondition such as a feature flag or a seeded record.

Do not paste a 400-line Burp export and call it reproduction. Trim it to what proves the point.

Severity that survives an argument

CVSS gives a number; it does not know your business. Two teams can score the same technical issue differently because one holds payment data and the other publishes blog posts. Write the rating as a sentence:

High — an authenticated customer can read any other customer's invoices by changing an identifier. No special privileges needed, and the endpoint is reachable from the internet.

If a finding will be argued about during retest, that sentence is what settles it. Keep the CVSS vector as supporting detail rather than the headline.

Remediation advice that gets implemented

  • Name the fix, not the category. "Authorise the invoice ID against the session user before the query runs" beats "implement proper access control".
  • Point at the code location when you know it. Engineers fix faster when they do not have to search.
  • Give a compensating control for fixes that need a release cycle: rate limiting, a WAF rule, or disabling the feature until it is patched.
  • Say what to verify after the fix, so retest is a checklist rather than a repeat engagement.

Close the loop

Mark each finding with a status the client can update: open, fixed, accepted risk, false positive. An accepted risk with a named owner and a date is a legitimate outcome; an unlabelled finding that quietly disappears is how the same issue comes back next year.

Offer a retest window and say what it covers. Findings that were fixed and verified are the strongest evidence that the engagement was worth the money.

Related: the Pentest Hub for the tooling each phase uses, and vulnerability scanning for turning scanner output into findings rather than noise.

The template, ready to copy

Everything above in one block. Replace every <angle bracket> and delete the sections that do not apply — a four-page report that answers the reader's question beats a forty-page one that buries it.

# <Client> — Penetration Test Report

**Engagement:** <type: external / internal / web app / wireless>
**Dates:** <start> to <end>
**Tester(s):** <name>  **Report version:** 1.0  **Classification:** Confidential

## 1. Executive summary

<Two or three sentences: what was tested, what the overall risk is,
and the single most important thing to fix first.>

**Risk posture:** <High / Medium / Low>

| Priority | Finding | Severity | Effort to fix |
|---|---|---|---|
| 1 | <one line> | Critical | <S/M/L> |
| 2 | <one line> | High | <S/M/L> |

## 2. Scope and rules of engagement

- **In scope:** <hosts, apps, ranges, accounts provided>
- **Out of scope:** <everything explicitly excluded>
- **Window:** <dates and hours>
- **Restrictions:** <no DoS, no social engineering, rate limits>

## 3. Methodology

<Phases performed, standards followed (PTES, OWASP WSTG, MITRE ATT&CK),
and what was *not* covered.>

## 4. Findings

### F-01 — <Title: what is broken, in plain words>

| | |
|---|---|
| **Severity** | <Critical / High / Medium / Low> — <one sentence why, in this environment> |
| **CVSS** | <score and vector, supporting detail only> |
| **Affected asset** | <host, endpoint, version, environment> |
| **Status** | Open · Fixed · Accepted risk (<owner, date>) · False positive |

**Description**
<The technical cause, one short paragraph.>

**Impact**
<What an attacker gains here: data, access, downtime, lateral movement.>

**Reproduction**
1. <Precondition: account and privilege level>
2. <Exact request: method, path, relevant headers, body>
3. <Observed response that proves the issue>

**Evidence**
<Screenshot or log excerpt, redacted of customer data.>

**Remediation**
<The specific change. Name the fix, not the category.>

**Compensating control**
<What to do until the fix ships.>

**Retest**
<How to verify the fix in one step.>

---

<Repeat for F-02, F-03 … ordered by severity, never by discovery order.>

## 5. Appendix

- Raw tool output, full request/response captures, scope evidence
- Accounts and artefacts created during the test (and their removal)

What separates a template people use from one they ignore

  • Severity carries a reason. "High — an authenticated customer can read any other customer's invoices by changing an identifier" survives a retest argument; a bare number does not.
  • Reproduction is numbered. A stranger with the report should reproduce the finding without asking you a question.
  • Every finding has an owner and a status. Accepted risk with a name and a date is a legitimate outcome; a finding that quietly disappears comes back next year.
  • The appendix holds the noise. Full scanner output belongs there, never in the summary.

Keep reading

Related articles

Browse all articles