Pentest report template: an editable skeleton with a finding ledger
A free outline for a web application penetration test report: document control, an executive summary, scope and limitations, a rating method, a finding block and a retest ledger.
Use it to write a report, to keep in-house test results consistent, or to tell a provider what the report you are paying for should contain.
On this page
Editable penetration test report skeleton
Copy the text into your own document and replace each prompt in round brackets. Parts 0 to 6 are the report: document control, executive summary, scope and limitations, rating method, findings summary, one finding block to repeat per finding, and the finding ledger with its four outcomes.
How to use itHide the instructions
Part 7 holds the appendices. Below the template, finding F-03 is filled in with invented content as an illustration; it is not a client result and is not taken from the lab sample report.
penetration-test-report-template.txt
PENETRATION TEST REPORT TEMPLATE
How to fill it in: replace every prompt in round brackets with your own text and keep every heading. If a part does not apply, write "Not applicable" and the reason, so a reader can tell a skipped part from a forgotten one. Field labels such as "Can exploit" stay as written. Parts 0 to 6 are the report and Part 7 holds the appendices. One finding filled in with invented content, marked as an illustration, follows the template.
## Part 0. Document control
Report title: (application name) web application penetration test report
Report ID: (your reference)
Version and status: (version number), (draft or final)
Prepared for: (organisation, and the contact who receives the report)
Prepared by: (tester names and organisation)
Relationship to the system: (whether the tester's organisation built, hosts or maintains the application, or has no part in it)
Distribution: (who may receive this report, and how copies are stored and sent)
Version history
| Version | Date | Author | What changed |
|---|---|---|---|
| (1.0) | (date) | (name) | (first issue) |
## Part 1. Executive summary
Why the test was done: (the business reason, such as a launch, a customer questionnaire, a contract, an insurer's request or your own assurance)
What was tested: (one sentence naming the application, the environment, the build and the testing dates)
Overall result: (open findings counted by business rating, then one or two plain sentences on the worst thing an attacker could do to this business)
What to do first: (one to three actions in order, in business terms, each tied to finding IDs)
Limits that change the picture: (anything not tested or not confirmed that a decision-maker needs to know)
Retest status: (not yet retested, or retested on build (build id); see the finding ledger in Part 6)
## Part 2. Scope and limitations
2.1 Targets: (hostnames and API base addresses, with the environment for each: production, staging or other)
2.2 Build tested: (release number, commit or deployment id)
2.3 Testing dates: (first day to last day)
2.4 Accounts and roles used: (one line per account: role, account label, organisation or tenant)
2.5 Depth: (unauthenticated, authenticated or code-assisted, and which areas each depth covered)
2.6 In scope as agreed: (the features, routes and roles named in the statement of work)
2.7 Covered as tested: (what was actually exercised; name any agreed item that was not reached, and say why)
2.8 Out of scope: (what was excluded on purpose, such as denial-of-service testing or services run by another business)
2.9 Limitations: (one line per limitation: its cause, such as an out-of-bounds area, broken functionality, missing cooperation, lack of time, or missing access or credentials, and the findings or areas it affects)
2.10 Negative results: (one line per check that found nothing: the route or request, the account, the build, and what was observed)
2.11 Test data left in the system: (record identifiers, where they are, and who will remove them)
2.12 Statement of limits: This report covers the targets, build and accounts listed above, on the dates listed. Areas outside that coverage were not assessed. The report is evidence for a decision; it is not a certificate.
## Part 3. Rating method
3.1 Technical severity: a CVSS v3.1 Base score, shown with its full vector string. Bands: None 0.0, Low 0.1 to 3.9, Medium 4.0 to 6.9, High 7.0 to 8.9, Critical 9.0 to 10.0. Observations that are not scored are rated Informational.
3.2 Temporal and Environmental metrics: (scored, or "not scored" with the reason)
3.3 Business rating scale: (the words used, such as Informational, Low, Medium, High and Critical, and what each one means for this business)
3.4 What the business rating weighs: (for example the data involved, how exposed the feature is, the controls already in place, the cost of disruption and how easily the issue can be exploited)
3.5 Labelling rule: every rating is written with its scale, as "CVSS Medium" or "business High", and where a finding's business rating differs from its CVSS band, the finding says why.
## Part 4. Findings summary
| ID | Title | Business rating | CVSS 3.1 score and band | Status at issue |
|---|---|---|---|---|
| (F-01) | (short title) | (rating) | (score, band) | (open, or fixed during testing) |
## Part 5. Finding detail (copy this block once for each finding)
ID and title: (F-nn, with a title that names the weakness and where it sits)
Status at issue: (open, or fixed during testing, with the evidence)
Category: (CWE id and name; OWASP Top 10:2025 category; the basis for the mapping)
Affected routes and roles
- Affected routes: (method and path of each route shown to be affected)
- Can exploit: (the role and account label used to demonstrate it)
- Data or users affected: (whose records, and which fields)
- Checked and not affected: (each role or route that held, and the result observed)
- Not checked: (related routes or roles that were not tried, and why)
Description: (what is wrong, in two to four plain sentences)
Severity rationale
- CVSS 3.1 vector: (full vector string)
- Base score: (score and band)
- Business rating: (rating)
- Why the two differ: (the reason, or "they agree")
- What would change the rating: (facts that would raise or lower it, and whether each was tested)
Reproducible evidence
- Preconditions: (environment, build, accounts and test records)
- Steps: (numbered steps a developer can follow)
- Request and response: (redacted excerpts, with the account that sent each request)
- Contrasting request: (the same request from an account that should be refused or allowed, and its result)
- Evidence references: (file names or IDs of captures and screenshots, and the build they were captured on)
- Redactions: (what was masked, such as session values, passwords and personal details)
Impact
- Demonstrated: (what the evidence shows happened)
- Inferred, not demonstrated: (what could follow, and why it was not shown)
Root cause: (the missing or faulty control behind the symptom, and whether it was confirmed in code or inferred from behaviour)
Remediation
- Fix for the cause: (the change that closes the cause, not only the demonstrated request)
- Regression test: (the test that keeps the cause from returning)
- Interim measure: (what reduces exposure until the fix is deployed)
- Remediation owner: (a named person, not a team)
- Target date: (a date agreed by the owner)
Retest criteria: (what the retest will check, written now, before any fix)
Clean-up: (test data this finding created, and its current state)
## Part 6. Finding ledger
Record exactly one outcome per finding in each retest round:
- Fixed: the reproduction steps fail on the named build and every retest criterion passes.
- Partially fixed: some of the affected routes, roles or impact still reproduce; name which.
- Still reproducible: the original steps still work as written.
- Not retested: the finding was not checked in this round; give the reason.
Rules for the ledger:
- An outcome comes from a retest result. A finding with no result stays "Not retested" and is not shown as passed.
- A decision to accept a risk or defer a fix goes in the owner decision column. It does not change the outcome.
- Every outcome names the build it was checked on.
- Original IDs stay as they are. An issue first found during a retest gets a new ID and its own finding block, outside this round's ledger.
| ID | Title | Rating at issue | Owner and target date | Retest round and build | Outcome | Evidence or reason | Owner decision |
|---|---|---|---|---|---|---|---|
| (F-01) | (title) | (business and CVSS rating) | (name, date) | (round, build id) | (one of the four outcomes) | (evidence reference, or why it was not retested) | (fix, accept or defer, and who decided) |
## Part 7. Appendices
A. Coverage checklist: (each OWASP WSTG v4.2 test or ASVS 5.0 requirement in scope, marked tested, not applicable, or not tested with the reason)
B. Supporting output: (cleaned excerpts that support a finding, not raw dumps)
C. Glossary: (terms a non-technical reader will meet in this report)
==========================================================
ILLUSTRATION ONLY: one finding block filled in
Finding F-03 was invented for this page to show the level of detail expected. The application billing.example.test, its accounts, routes and results are not from a client and are not taken from the Clever Ops lab sample report. In this invented business, an outside bookkeeping firm holds the Bookkeeper role.
ID and title: F-03, Bookkeeper role can issue credit notes and void invoices through the API
Status at issue: open
Category: CWE-862 Missing Authorization; OWASP Top 10:2025 A01 Broken Access Control. Basis: CWE-862 is in OWASP's list of CWEs mapped to A01:2025.
Affected routes and roles
- Affected routes: POST /api/invoices/{invoiceId}/credit-notes and POST /api/invoices/{invoiceId}/void
- Can exploit: Bookkeeper, a role meant to read invoices but not change them (account bk-test-1)
- Data or users affected: invoices and credit notes in the bookkeeper's own organisation
- Checked and not affected: Field technician (tech-test-1) received 403 on both routes. A Bookkeeper request for another organisation's invoice, INV-T-2001, returned 404.
- Not checked: the refund and mark-paid routes, which the agreed scope did not list, and the mobile API, which was out of scope
Description: The invoice screen hides the Credit and Void buttons from the Bookkeeper role, but the API accepts both actions from a Bookkeeper session. A Bookkeeper can therefore lower the balance a customer owes, or cancel an invoice, by calling the API directly.
Severity rationale
- CVSS 3.1 vector: CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N
- Base score: 6.5, Medium
- Temporal and Environmental metrics: not scored; the business rating carries the factors specific to this business
- Business rating: High
- Why the two differ: Confidentiality is None because the Bookkeeper role may already read invoices, and CVSS scores the change to records without weighing money owed by customers. The role is also held by people outside the business.
- What would change the rating: lower if credit notes needed a second approval before reaching a customer; higher if credit notes synced to the accounting system automatically. Sync is switched off on staging, so this was not tested.
Reproducible evidence
- Preconditions: staging, build release 2026.11.2; accounts bk-test-1 (Bookkeeper), tech-test-1 (Field technician) and office-test-1 (Office staff); test invoices INV-T-1042 and INV-T-1043, created for this check
- Steps:
1. Sign in as bk-test-1 and open INV-T-1042. No Credit or Void button is shown (E-03-1).
2. Send the credit-note request below with the bk-test-1 session (E-03-2).
3. Send the same request with the tech-test-1 session (E-03-3).
4. Send the void request for INV-T-1043 with the bk-test-1 session (E-03-4).
- Request: POST /api/invoices/INV-T-1042/credit-notes, Host: billing.example.test, Cookie: session=(redacted, bk-test-1), Content-Type: application/json, body {"reason": "F-03 test", "quantity": 1, "unitAmount": 1}
- Response: 201 Created, body including "id": "CN-T-0311", "invoiceId": "INV-T-1042", "createdBy": "bk-test-1"
- Contrasting request: the same request with the tech-test-1 session returned 403 Forbidden
- Second route: POST /api/invoices/INV-T-1043/void with the bk-test-1 session returned 200 OK with "status": "void"
- Evidence references: E-03-1 to E-03-4, captured during testing on build release 2026.11.2
- Redactions: session cookie values; customer names on the test invoices replaced with "Test Customer"
Impact
- Demonstrated: a Bookkeeper account created a credit note against one test invoice and voided another.
- Inferred, not demonstrated: in production the same account could reduce real balances or cancel real invoices. Whether credit notes reach the accounting system was not tested.
Root cause: inferred from behaviour, because code access was not in scope. The server checks that the user may open invoices, which the Bookkeeper role may do for reading, but does not check a separate permission to change them. The Field technician role has no invoice access at all, which is why it is refused. The developers should confirm this in code.
Remediation
- Fix for the cause: check a named permission (issue credit, void invoice) on the server in every route that changes an invoice, and refuse the request when the permission is missing.
- Regression test: a role matrix test that sends each state-changing invoice request as each role and expects 403 for Bookkeeper and Field technician, run on every build.
- Related routes: list every route that changes an invoice (create, edit, credit, void, refund, mark paid) and apply the same check. Review production credit notes and voids created by Bookkeeper accounts.
- Interim measure: limit Bookkeeper accounts to the reports export until the fix is deployed.
- Remediation owner: S. Ortiz, lead developer (an invented name)
- Target date: 27 November 2026, agreed by the owner
Retest criteria: bk-test-1 receives 403 on the credit-note and void routes; office-test-1 can still issue a credit note and void a test invoice; tech-test-1 is still refused.
Clean-up: CN-T-0311 was removed with the office-test-1 account after testing. INV-T-1043 stays void and is listed in Part 2.11.
Ledger entry after the first retest round (also invented)
| ID | Title | Rating at issue | Owner and target date | Retest round and build | Outcome | Evidence or reason | Owner decision |
|---|---|---|---|---|---|---|---|
| F-03 | Bookkeeper role can issue credit notes and void invoices | business High; CVSS 6.5 Medium | S. Ortiz, 27 November 2026 | Round 1, release 2026.12.1 | Partially fixed | The credit-note route now returns 403 for bk-test-1 (E-03-R1); the void route still returns 200 (E-03-R2) | Fix the void route and check it in round 2 (S. Ortiz) |
How a "Not retested" entry reads: "Not retested: the bk-test-1 account had been deleted, and no replacement was issued before the round closed."
How to use this pentest report template
A penetration test report has two audiences with different questions.
The person paying for the fixes wants to know what to fund first and what can be said to whoever asked for the test. The developer making the fixes wants to repeat each problem, find its cause and know when it is closed. This pentest report template gives both of them a fixed place to look.
Copy it into your own document, replace each prompt in round brackets and keep every heading. Where a part does not fit, write "not applicable" and the reason, so a later reader can tell a deliberate gap from a forgotten one.
Three kinds of reader get use from it. A tester can use it as a web application penetration test report template, for an application or the API behind it. An in-house team testing its own product can use it so that each round of results lines up with the last.
A buyer can attach it to a request for quotes as the list of parts the report should contain, which makes reports from different providers easier to compare.
The OWASP Web Security Testing Guide (WSTG) v4.2 has a short reporting chapter, and it is candid about its own status. It calls its contents suggestions about one possible approach rather than strict rules, and says the format is a best fit for consultancy reports and may be overkill for internal or bug bounty reports.
The template keeps most of the chapter's parts, with some changes. It puts the executive summary first, because some readers open nothing else, where the chapter places scope and limitations in its introduction ahead of the summary.
It also adds two things the chapter does not spell out: affected routes and roles, and a remediation owner with a target date. And it turns the chapter's brief note on re-tests into a ledger with four defined outcomes.
A finished report maps weaknesses in a running system, so handle it like one. The WSTG chapter advises securing and encrypting the report so that only the receiving party can use it, and Part 0 of the template records who may receive a copy.
Clever Ops reports carry the same core parts: an executive summary, the scope as tested, evidence and two ratings for each rated finding, and one of four outcomes for each finding after the retest.
The sample report, written about a lab application Clever Ops controls, shows the format. The template itself suits any report, whoever writes it.
The executive summary: written for whoever funds the fixes
Part 1 is the page most people will read, so it carries the decision rather than the detail.
- Who reads it: the owner, director or product lead, and later anyone the report is shared with, such as a customer's security reviewer.
- What it must let them decide: which fixes to fund and schedule first, whether a launch or a customer commitment should wait, and what can honestly be said to whoever asked for the test.
- How it usually goes wrong: a count of findings by colour with no consequence attached, a tone harsher or gentler than the findings themselves, or a limit that only appears in the back pages.
Six prompts that make the summary commit
The WSTG chapter asks the summary to put key findings in a business context and leave the technical detail for later, to keep strategic recommendations non-technical, and to avoid jargon and negative speculation. It adds that any figures, graphs or illustrations should help deliver a message more clearly than text would.
A severity pie chart seldom clears that bar: it shows how many findings there are and hides what they would cost.
The template's prompts push past a list of issues. "Why the test was done" ties the result to its purpose, since a test for a customer questionnaire and a test before a launch put different findings first. "Limits that change the picture" carries any untested area or unconfirmed finding up to the page the decision-maker reads.
Before issuing, give the summary to someone who has not read the findings and ask which fix they would fund first. If their answer differs from the order in the findings, one of the two needs rewriting.
Scope and limitations: as agreed, then as tested
Part 2 sets the boundary every finding, and every clean result, sits inside.
- Who reads it: the buyer at handover, and anyone who relies on the report later, such as a customer's reviewer, an auditor or the next tester.
- What it must let them decide: how far the report can be relied on, meaning which system, build, routes and roles it speaks for and which it does not.
- How it usually goes wrong: the scope is pasted from the quote, so it describes the plan rather than the work; the build is never named; limits are missing or vague.
Why the template splits the scope in two
"In scope as agreed" comes from the statement of work. "Covered as tested" records what was actually exercised, and an agreed item that was not reached appears there with its cause. The WSTG chapter describes scope as the boundaries and needs of the engagement agreed with the organisation, and it names five kinds of limitation: out-of-bounds areas, broken functionality, and a lack of cooperation, of time, or of access and credentials.
Part 2.9 asks each limitation to name the findings or areas it affects, so a reader can see what it cost.
Two smaller parts do a lot of work. Negative results tell a reader which checks came back clean, but each covers only the request, account and build written beside it, so the template asks for all three. The test data list tells the owner what the test left behind and who will remove it, which matters most when the target was production.
Severity rationale: a rating someone else can recompute
Part 3 defines the rating method once, and each finding block applies it with its own reasons.
- Who reads it: the technical lead putting the work in order, and anyone who wants to check a rating before acting on it.
- What it must let them decide: whether the order of work suits this business, and whether a rating is worth challenging.
- How it usually goes wrong: a score with no vector behind it, a business rating that departs from the technical one without a reason, or impact that was inferred but scored as if it had been shown.
Publishing a CVSS score with its vector
The FIRST specification for CVSS v3.1 says the vector string, which records the value assigned to each metric, should always be displayed with the score. FIRST also requires, as a condition of use, that anyone who publishes scores provides both the score and the scoring vector, so others can understand how the score was derived.
That is why the finding block has a line for the full vector and another for the score and its band.
The Base score assumes the reasonable worst case impact across different deployed environments. FIRST says scoring the Temporal and Environmental metrics is not required but is recommended for more precise scores, and that Environmental metrics are specified by end-user organisations, because they are best able to assess the impact within their own computing environment.
So Part 3.2 is worth answering plainly. "Not scored" is a fair answer, and it tells your own team that the environment-specific judgement is still theirs to make.
When a CVSS score is optional
The WSTG chapter does not insist on CVSS. It says some engagements require a CVSS score, and that where none is required a score is sometimes good to have and other times just adds complexity. For each finding it suggests recording the likelihood or exploitability (how easy the issue is to exploit, whether working exploit code exists, the level of access required and attacker motivation), the impact on the system, and a risk level, with suggested values of Informational, Low, Medium, High and Critical.
Whichever scale you choose, define it in Part 3 before the first finding, and label every rating with its scale as Part 3.5 asks, because "High" on its own could mean either.
Reproducible evidence, affected routes and roles
The middle of each finding block is written for the person who has to change the code.
- Who reads it: the developer assigned the fix, and the person who will retest it.
- What it must let them decide: where the defect lives, how to reproduce it before changing any code, and how far the fix has to reach.
- How it usually goes wrong: a screenshot of a response with no request, evidence from an unnamed account, "other endpoints may also be affected" with no list, and no build.
From one failing request to a map of the boundary
The WSTG chapter writes its findings section for the technical team: it should give the information needed to understand, replicate and resolve each issue, with possibly sensitive data such as passwords and personal information masked. It suggests logical separation to help readability, giving separate sections for external and internal access as its example.
For a web application, grouping findings by the boundary they cross, between users of one role, between roles or between customer organisations, does the same job.
The routes and roles block turns a finding into a map. "Can exploit" names the role and account that showed the problem. "Checked and not affected" records the roles and routes that held, which tells the developer where a working control already exists. "Not checked" lists related routes and roles nobody tried, so a fix to the demonstrated route is not mistaken for a fix to the whole family.
A contrasting request beside the failing one, such as the same call from a role that is correctly refused, lets the reader see the boundary instead of taking it on trust.
Impact is split into demonstrated and inferred for the same reason. A strong inference belongs in the report, but the reader needs to see which half rests on evidence before deciding how far to trust the rating.
Root cause, remediation owner and target date
The last part of each finding block turns the problem into a piece of work with a name on it.
- Who reads it: the engineering lead who assigns the work, and the business owner tracking it to closure.
- What it must let them decide: who fixes each finding, how wide the change has to be, what reduces exposure in the meantime, and when it should be ready to retest.
- How it usually goes wrong: a fix aimed at the single request in the evidence, an owner written as "the dev team", or a target date filled in by the tester before the owner has read the finding.
Symptom, cause and the width of the fix
A symptom is the request that worked. A root cause is the missing or faulty control that let it work, and it usually reaches more routes than the one demonstrated. The OWASP Top 10:2025 entry on broken access control makes the point directly: access control is only effective when implemented in trusted server-side code or serverless APIs, where the attacker cannot modify the access control check or metadata.
A root cause written as "the screen hides the button and the server never checks the permission" tells the developer to fix the server once, for every route, instead of patching the route in the evidence.
The template also asks whether the cause was confirmed in code or inferred from behaviour, because a test without code access can only infer it.
Who sets the date
The owner and target date belong to the business that owns the code. A tester can recommend an order of work, but only the person doing the work can commit to a date that fits releases and other priorities.
A named person, rather than a team, gives the ledger someone to ask. The interim measure covers the gap: a restricted role, a disabled feature or closer watch on the affected records until the fix is deployed.
The finding ledger: four outcomes, and no silent passes
Part 6 is the record that changes after the report is issued, and the one most often read on its own.
- Who reads it: anyone who receives the updated report, from the owner to a customer's reviewer or an auditor.
- What it must let them decide: which findings are closed on which build, which are still open, and which nobody has looked at again.
- How it usually goes wrong: a blank outcome cell read as a pass, "risk accepted" written where a test result belongs, or a finding marked closed because its button disappeared from the screen.
One outcome per finding, per round
Each retest round gives each finding exactly one outcome. Fixed means the reproduction steps fail on the named build and every retest criterion passes. Partially fixed means part of it still reproduces, and the entry names which part. Still reproducible means the original steps work as written.
Not retested means the finding was not checked in that round, with the reason beside it. A finding without a retest result keeps that status in every copy of the report and is not shown as passed.
Owner decisions sit in a column of their own. Accepting a risk or deferring a fix to a later release is a legitimate business decision, but it is not a test result, and mixing the two is how an open finding comes to look closed. For a re-test, the WSTG chapter suggests a subsection that sums up the earlier test's findings, the current status of each and any cross-references with the current test.
Keeping the original IDs, and giving issues first found during a retest new IDs outside the ledger, keeps those cross-references intact.
Adapting it for in-house tests, retests and shared copies
The skeleton stays the same.
What changes is how much of each part you fill in, and who receives a copy.
An in-house test of your own product
Fill in the relationship line in Part 0 honestly. A team testing code it wrote or runs is checking its own work, and anyone deciding how far to rely on the report should know that. Given the WSTG chapter's note that its format may be overkill for internal reports, trim the prose rather than the structure: keep the scope as tested, the ratings and the ledger, because those are what a later reader or a later tester will need.
A narrower check or assessment
The same skeleton works as a security assessment report template for a smaller piece of work, such as an external check of a site with no customer logins. Part 2.4 then lists no accounts, Part 2.5 records an unauthenticated depth, and each finding names the public route and the visitor as the role.
Keep the limits strict. An assessment that never signed in says nothing about what happens behind the login, and Part 2.12 should say so.
A retest edition
Add a row to the version history, keep every original ID, and update the ledger rather than rewriting the findings. Each outcome names the build it was checked on. A finding the owner chose not to fix stays in the ledger with its outcome and the owner's decision beside it, so the report keeps track of it from one round to the next.
A copy for a customer or a questionnaire
A customer usually needs less than the full report: document control, the executive summary, the scope and limitations, and the ledger. Leave out the request and response excerpts, or share them only under the distribution terms in Part 0. Keep the limitations and the build of the latest retest round in the copy, so the reader sees what the result covers.
Frequently asked questions
Document control with a version history, an executive summary in business terms, the scope and limitations as tested, the rating method, a findings summary, a detail block for each finding and a retest ledger. The OWASP WSTG v4.2 reporting chapter suggests most of these parts, plus appendices such as the test methodology used, severity and risk rating explanations and a checklist of the tests conducted. This template adds three things: affected routes and roles for each finding, a remediation owner and target date, and a ledger with four outcomes.
It is the block a report repeats for every finding, so each issue is written up the same way. Part 5 of this template is one: ID and title, category, affected routes and roles, description, severity rationale, reproducible evidence, demonstrated and inferred impact, root cause, remediation with an owner and date, retest criteria and clean-up. The illustration under the template shows one finding filled in with invented content.
Not always. The WSTG v4.2 reporting chapter says some engagements require a CVSS score, and that otherwise a score is sometimes good to have and other times just adds complexity. If you do publish CVSS scores, FIRST requires the scoring vector alongside each one, so others can see how it was derived. A business rating next to the score covers factors such as monetary loss, which FIRST places outside the scope of CVSS.
As "not retested", with the reason, in the ledger and in every copy of the report that carries a status. A missing result is not a pass, and an owner's decision to accept the risk belongs in its own column rather than in the outcome. A finding moves to fixed only when a retest on a named build shows the reproduction fails and the retest criteria pass.
Yes. Internal tests benefit from the same structure, because each round can then be compared with the last. The WSTG chapter notes that its format may be overkill for internal reports, so shorten the prose but keep the scope as tested, the ratings and the ledger. State in Part 0 that the testers work on the system, so a reader can weigh the report's independence.
The example page is a finished, redacted report written about a lab application Clever Ops controls, annotated part by part with a yardstick for judging any provider's report. This page is the blank skeleton you fill in yourself, with one invented finding to show the detail expected. Use the example to judge a report and this template to write one.
Scope the right test for your application
Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.