Preparing for a penetration test
A checklist of what to have ready before an external tester starts, whichever firm or tool runs the test.
A penetration test goes faster, finds more and causes fewer surprises when the tester has everything on day one. This checklist works for any provider: a consultancy, a freelance tester, a crowdsourced programme or an automated testing service. Most items take minutes, but some (a DNS change, a firewall rule, a sign-off from a system owner) need another team, so start at least two weeks before the test window.
Your provider will send its own questionnaire or scoping form. Use this page to gather the answers before it arrives, and follow the provider's form where the two differ.
Scope and authorization
- A written scope. List every target by exact address: hostnames, URLs, IP ranges, API base paths, mobile app builds, cloud accounts. Anything not on the list is out of scope. Name the test type too: black box (no information), grey box (accounts and some documentation) or white box (source code and architecture).
- What is explicitly out of scope. Systems you do not own, shared infrastructure, and third-party services your app loads (login providers, payment forms, analytics). Those belong to someone else and need that party's own permission before anyone tests them.
- Signed authorization. Someone with the authority to approve testing signs the engagement letter or rules of engagement. If you do not own a target (a customer-hosted deployment, a parent company's network), get the owner's written permission as well.
- Your hosting provider's rules. Most cloud providers allow testing of your own resources without notice but forbid some techniques, such as denial-of-service or attacks on the provider's own infrastructure. Check their current policy and pass any restrictions to the tester.
- A test window. Agree start and end dates, the hours the tester may work and the time zone. Tell the tester about change freezes, releases or peak trading periods to avoid.
- The goal of the test. A framework requirement (ISO 27001, SOC 2, PCI DSS, NIS2), a customer request, a new release or a yearly check. It shapes the scope and the report format, and tells the tester which attack scenarios matter most to you.
The environment
- A staging or test copy where possible. Testers run real attacks that can create, change or delete data. A staging environment that mirrors production (same code, same configuration, same security controls) gives realistic results without the risk.
- If production is in scope: use test accounts only, take and verify a backup immediately before the window, agree a request-rate limit with the tester, and tell them which data belongs to real customers and must not be touched.
- Reachability. The tester must be able to reach every target from where they work. For an internal network or a private cloud, agree how: a VPN account, a jump host, or a device you ship to them.
- Endpoints to leave alone. List actions that cost money or reach real people, as method plus path where you can: sending invoices or emails, charging cards, posting to a production webhook, triggering an SMS. Either exclude them or point them at a sandbox for the test.
- Third-party sandboxes. Switch payment, email and messaging providers to test mode in the environment, and give the tester the provider's published test values (test card numbers, for example).
Let the testers in
- Allow the tester's source addresses. Ask for the fixed IP addresses they will test from and allow them through firewalls, the WAF, rate limits and geo-blocking. Decide with the tester whether the WAF should stay on (tests what an attacker sees) or allow them through (tests the application behind it). Many tests do both.
- Turn off bot protection for the tester. Captchas and bot challenges stop most testing. Disable them in the test environment, or for the tester's addresses.
- Anything in front of the app. A staging password, an identity-aware proxy, deployment protection or an API gateway header check must let the tester through too.
- A way to recognise test traffic. Ask the tester whether they add a header or user agent to their requests. Together with their IP addresses, that lets your team tell the test apart from a real attack.
Test accounts
- Accounts made only for testing. Never give a tester a real person's account or credentials.
- Two accounts per role. With two users in the same role, the tester can check whether one user can see or change the other's data.
- A low-privilege and a high-privilege account. A regular user and an administrator let the tester check whether a regular user can reach admin functions.
- Two tenants, for multi-tenant apps. Accounts in two separate organizations let the tester check that one customer cannot reach another customer's data. This is often the most important finding class for a SaaS product.
- Seeded data. Put realistic records in each account (orders, projects, documents, users) so the tester has something to read, change and delete.
- A short description of each role. One or two sentences on what each role is meant to do. Without it, a tester cannot tell a bug from a feature.
How the accounts sign in
Agree the sign-in method with the tester before the window opens. Common arrangements:
| Sign-in method | What to give the tester |
|---|---|
| Username and password | The credentials, sent through the channel the tester asks for (an encrypted share or password manager, never plain email). |
| Authenticator app (TOTP) | Finish the two-factor setup, then share the setup key or otpauth:// link, not a six-digit code. |
| Email codes or magic links | A mailbox the tester controls. Check that the test environment really sends email to outside addresses. |
| Single sign-on | Test users in your identity provider, or a separate test connection. |
| API keys or tokens | Two keys per role, the header they go in, and how long they stay valid. |
| SMS codes, push approval, passkeys | Usually impractical for a remote tester. Ask whether they support it; otherwise turn it off for the test accounts. |
Account lockout
- Keep lockout and login rate limits as in production. Testers try wrong passwords on purpose to check that login resists guessing. If you turn the limits off, expect a finding that says there is no protection.
- Add a spare account per role. A locked account stops the tests that use it.
- Name someone who can unlock and reset accounts during the window.
Optional context that helps the tester dig deeper
Grey-box and white-box tests find more in the same number of days. Share what you are comfortable with:
- Source code access, read-only, for the branch the test environment runs.
- API definitions: an OpenAPI or Swagger file, a GraphQL schema, or a Postman collection.
- Architecture notes: a diagram of components, data flows and trust boundaries, and where sensitive data is stored.
- Product documentation: help center or API docs. Send pages that sit behind a login as files.
- Previous reports. The last test's findings let the tester verify fixes and spend their time elsewhere.
- Known issues and accepted risks, so the tester does not spend time re-reporting them.
- Areas of concern. New features, recently rewritten code, or anything your team is unsure about.
Communication
- A technical contact who can answer questions, reset accounts, restart a service and pause the test, reachable for the whole window.
- An escalation path for critical findings. Agree that the tester reports a critical vulnerability, or any sign of a previous compromise, immediately rather than in the final report, and who receives that call.
- A stop condition. Agree how either side can pause or stop the test (an outage, unexpected data exposure, a real incident) and how it restarts.
- A secure channel for credentials, findings and the report.
On the day
- Tell your team. Let operations, on-call, the security operations center and any managed security provider know the window and the tester's addresses, so alerts are recognised instead of escalated as an incident. Keep monitoring and alerting on: whether they fire is part of what the test shows.
- Do not change the target mid-test. Avoid deploying to the environment during the window unless you agree it with the tester.
- Expect leftovers. The test may leave records, accounts it signed up, uploaded files and emails the app sent. Plan to clean the environment afterwards.
Production data and real users
If any target is in production, confirm the backup and the excluded endpoints with the tester before the first request. A test that sends real emails or charges a real card cannot be undone.
After the test
- Read the report with the tester. Ask for a debrief call to go through the findings, their severity and the reproduction steps.
- Record the findings in Noru. Add each finding under SecurityFindings with its severity, an owner and, where it matters, a linked risk and asset, so remediation is tracked to closure. See Security findings.
- Upload the report as evidence. Add the report to the evidence vault, link it to your penetration testing control, and set an expiry (usually 12 months) so the next test shows up as a renewal rather than a gap. See Evidence vault.
- Ask for a retest. Once fixes are deployed, have the tester confirm them and issue an updated report or a remediation letter. Upload that too.
- Share a summary, not the report. Customers often ask for proof of a recent test. Ask the tester for an executive summary or attestation letter and publish it on your trust page, gated behind an NDA if you prefer. See Trust center documents.
- Clean up. Delete or disable the test accounts, revoke API keys, VPN accounts and source code access, remove the tester's addresses from allowlists, turn bot protection back on, and remove leftover test data.
Related
Last updated on