Skip to main content
Security templateReviewed

Penetration testing scope: a web application template to fill in before you ask for quotes

A scope schedule you can copy and complete for any provider: exact URLs and API paths, environments, roles and route counts, test accounts, third-party services, source addresses, data limits, exclusions and the retest boundary.

A completed example for an invented two-role software product shows every part filled in.

Web application scope schedule, blank and completed

Copy the blank schedule into a document and fill in all twelve parts before you ask any provider for a quote. Write exact hostnames, paths, counts and names rather than descriptions, and write "none" where a line does not apply.

How to use it

Below it, the same schedule is filled in for an invented two-role software product, as an illustration rather than a client, so you can see the level of detail each line needs.

penetration-test-scope-template.txt

Introduction2 lines

WEB APPLICATION PENETRATION TEST SCOPE SCHEDULE Fill in one schedule for each application. Write exact values rather than descriptions: a hostname, not "the portal"; a count, not "a few". Where a line does not apply, write "none" so the provider can see it was considered. Send the same completed schedule to every provider you ask to quote, and attach the signed authorisation letter and the rules of engagement before testing starts.

What a penetration testing scope settles

A penetration testing scope is the written boundary of a test: which systems the tester may send requests to, from which accounts and addresses, in which environment, and what must be left alone.

The rest of the engagement hangs off it. The quote prices it, the authorisation letter gives permission for it, the rules of engagement govern behaviour inside it, and the report can only speak for what it contained.

The UK's National Cyber Security Centre (NCSC) says the output of scoping should be a document that states, among other things, the technical boundaries of the test, the types of test expected, the timeframe and the effort needed, the testing team's requirements, any compliance or legislative requirements, reporting requirements and time constraints.

Its examples of preparing for the team's requirements include creating test accounts before the test date. NIST SP 800-115 describes what a written assessment plan does for both sides. It sets the rules and boundaries assessors must keep to and reduces the risk of accidental disruption or inadvertent disclosure of sensitive information, and it protects the test team by making sure management understands and agrees to the scope, activities and limitations.

The template on this page is a tool for your own procurement. Fill it in once, send the same schedule to every provider you approach, and the quotes come back describing the same work. It is written for a web application and the API behind it. An office network, a native mobile app or a phishing exercise needs a schedule of its own.

Who fills it in, and what to collect first

NCSC suggests that scoping involve the relevant risk owners, technical staff who know the target system and a representative of the penetration test team.

In a business with one application, that is usually the owner or manager who wants the test, the developer or agency that maintains the application, and the provider. The owner answers why, for whom and what must not break. The developer answers hostnames, routes, environments and services. Gathering these before anyone opens the template saves most of the back and forth:

  • The exact wording from whoever asked for the test: a customer questionnaire, a contract clause, an insurer's form or your own board minute.
  • An export of the routes from the code's route definitions or the API schema, taken from a named build, so the count and the list agree.
  • Your DNS zone. It lists every hostname you have pointed somewhere, including the ones that point at other companies' services.
  • Every outside service the application calls or loads, which your developer can read from configuration and environment settings and your bookkeeper can cross-check against the bills.
  • The terms each host and vendor publishes about customer security testing, saved with the date you read them.
  • Usernames for the test accounts, and the name of the person who will create them.

How to fill in each part of the schedule

The schedule has twelve parts.

The five below decide whether the quotes you receive can be compared line for line, so they deserve the most care.

Targets: hostnames and API paths, not "the website"

Write every hostname in full, including both the bare domain and www if both answer, and every API base path with its version. 1 min read

Environments: record what each one shares

For each environment, record the hostnames, the build deployed, where its data came from and what it shares with production. 1 min read

Roles, accounts, records and rules

List each role with what it may do, in one line, and roughly how many routes it can call. 1 min read

Source addresses and data limits

The provider supplies the addresses its test traffic will come from. 1 min read

Exclusions and the retest boundary

Every exclusion gets a reason, because the reason tells a later reader what the gap means. 1 min read

Third-party services and hosting: what your signature covers

An authorisation from your business can speak only for systems your business controls.

A typical web application leans on other companies for hosting, sign-in, payments, email, maps and file storage, and those companies' platforms are not yours to put in scope. NIST SP 800-115 makes the point in network terms: where an organisation does not control part of its network, such as systems housed on a third party's network, the owner of that network usually must also consent in writing to the assessment plan, and it treats systems shared between organisations as a similar case.

The boundary usually runs through the middle of a service rather than around it. Your code, your settings and your account's configuration are yours. The vendor's servers, hosted pages and other customers are not. Part 6 asks you to draw that line for each service and record which of three things applies: you read the vendor's published terms for customer testing on a stated date and they allow what the scope describes, the vendor gave written permission, or the service is excluded.

Hosts and vendors word these terms differently, and some hosts ask for notice or approval before testing starts, so read the current version yourself rather than relying on what another customer was told. Typical splits look like this:

  • Hosting platform: your deployed application and your account settings are yours to authorise, within the host's terms. The host's platform, control panel and shared infrastructure are not.
  • Hosted sign-in service: how your application checks the tokens it receives, which roles it trusts them to carry and when sessions end are yours. The vendor's hosted login pages and platform are not.
  • Payment provider: the checkout request your server builds, the amount it sends and the route that receives payment notifications are yours, tested in the provider's test mode. The hosted checkout page, card handling and the provider's dashboard are not.
  • Email and SMS delivery: whether your application limits how often it sends is yours, with messages going only to destinations the tester controls. The delivery platform is not.
  • Help desk, status page or booking tool on one of your subdomains: the DNS record is yours. WSTG v4.2's subdomain takeover test (WSTG-CONF-10) explains that a subdomain can be taken over when its record points to an external service or resource that is no longer active. The product behind the record belongs to the vendor.
  • File storage in your own cloud account: the bucket's access settings and the links your application issues are yours. The storage service itself is the provider's.

Why the schedule asks what data each service receives

OWASP's API9:2023 entry recommends an inventory of integrated services that documents their role in the system, what data is exchanged and their sensitivity. Part 6 asks for the role and the data exchanged, and adds how sensitive that data is. Beyond permission, the answers show the tester where your data leaves your control, which is where a weak link between your application and a vendor tends to matter most.

When something outside the scope turns up mid-test

Testing often finds things nobody listed: an old API version that still answers, a forgotten staging host, a subdomain pointing at a service you stopped paying for.

NCSC describes two ways to handle a system found outside the scope that could affect the ones inside it. The testing team can suggest a change to the scope, which is likely to alter the time frame and cost, or recommend that its exclusion be recorded as a limitation on testing.

NCSC says the choice will generally be down to the risk owner, with the testing team responsible for setting out the factors to consider.

Part 10 of the schedule settles that in advance: who may approve an addition in writing, and what happens if nobody does in time. Without that line, a tester either stops work to ask or carries on into something nobody authorised, and neither outcome helps you.

The same goes for anything that changes during the window. If developers will deploy while testing runs, say where, or freeze the build. NIST SP 800-115 says that when questions about scope or the level of authorisation arise during an assessment, the assessors and the organisation's identified point of contact should meet to discuss them, and NCSC asks for a technical point of contact who is available at short notice throughout the test phase. Part 12 names that person.

Scope gaps that come back as report limitations

A gap in the schedule does not disappear when testing starts.

It comes back in the report as a limitation. The WSTG v4.2 reporting chapter suggests the report introduction set out scope and limitations, and lists out-of-bounds areas, broken functionality, lack of time and lack of access or credentials among the limitations it can record. Most of them trace back to a line in the scope:

  • Accounts that arrive late, or for one role only, leave routes tested from one side only.
  • An integration switched off on staging becomes functionality the tester could not exercise.
  • A hostname missing from Part 2 becomes an out-of-bounds area, even when it runs the same code.
  • A vendor whose permission never arrived becomes an exclusion the report has to explain.
  • A build that changed halfway through leaves findings tied to a version that no longer exists.

Using the schedule with Clever Ops or another provider

The schedule is yours, not a provider's form.

Send the same copy to each provider you approach and ask them to mark any line they would change, with the reason. How they mark it tells you more about the test each one intends to run than the totals on their quotes.

If you bring it to a free scoping call with Clever Ops, the call goes straight to the parts that carry the risk, and you then receive a written scope and quote naming the targets, environment, routes, roles and exclusions, and what the one included retest covers.

No request is sent until the owner of each target has signed an authorisation and your hosting provider's testing policy has been checked, and services run by other businesses stay out of scope unless their owner agrees.

Destructive actions are off by default for real people's accounts and records that existed before the test. Reset, lockout and deletion checks run only on test accounts and test records, where the rules of engagement allow them.

Some schedules point to a different provider. If Clever Ops built or hosts the application, the work is a security review rather than an independent test, and the report says who built it and who hosts it. Where a tender, panel or contract requires CREST, Clever Ops is not CREST accredited, so we refer that work to a provider that is. Internal networks, staff devices, phishing and load testing go to specialists in those fields.

Frequently asked questions

At minimum: the exact hostnames and API paths in scope and those excluded, the environment and build, the roles with two test accounts each, the third-party services and who owns them, the tester's source addresses, the data limits, every exclusion with its reason, and what the retest covers. The template on this page sets these out in twelve parts, followed by a completed example.

No. The scope says what will be tested. The authorisation letter, signed by someone with authority over each target, gives permission to test it. The rules of engagement govern behaviour inside the testing window, such as request rates, pause conditions and who to call. Most engagements need all three, which is why Part 12 of the schedule lists the other two as attachments.

Only the parts you control, such as your deployed application, your account settings and the code that calls the service. The provider's own platform needs its written permission, or its published terms for customer testing have to allow what the scope describes. Read those terms before testing, record the date you read them, and exclude the service if neither applies.

For a web application, hostnames and API paths, with addresses only where you own them. An application on a cloud platform or behind a content delivery network can sit on addresses shared with other customers, and those addresses can change, so an address on its own can point a tester at someone else's system. The addresses that matter most are the tester's source addresses, which go in Part 7 and in the authorisation letter.

Staging, when it runs the same code and configuration as production and holds no real customer data, because the tester can then create and change records freely. Check what it shares with production first: a staging copy connected to the production database or file storage carries production's risks. Production can still be in scope for checks that need no account, or for signed-in testing with test accounts, under the rules of engagement.

Detailed enough that you and every provider count the same routes. Export it from the code's route definitions or the API schema on a named build, give the method and path of each route, mark which roles may call it, and include older versions that are still deployed. A count without a list makes quotes hard to compare, and a list without a build reference goes stale with the next release.

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.