Your SOC 2 auditor asks for "evidence of penetration testing." Your engineering team exports a 400-page scanner PDF and calls it done. Two weeks later, the auditor comes back with an exception, and your enterprise deal stalls in procurement while you scramble to book a real assessment.
This happens to SaaS companies every audit season, and the confusion is understandable. Vulnerability scanning and penetration testing both find security weaknesses, both produce reports, and both show up in control language. Auditors still treat them as separate controls that prove different things. Handing in one in place of the other is one of the most common reasons SaaS companies get exceptions or awkward follow-up requests.
This guide covers what each activity proves and what SOC 2, ISO 27001, PCI DSS, and enterprise security reviewers expect to see. It also shows how to produce evidence that passes on the first submission.
Auditors are not security testers. Their job is to determine whether your controls are designed properly and operating effectively over a period of time. When it comes to technical security, they are asking two separate questions:
A scan answers the first question and a pentest answers the second. Neither can substitute for the other, and an experienced auditor will notice right away if you try.
A vulnerability scan is an automated, signature-driven sweep of your assets. It compares service banners, software versions, configurations, and response patterns against a database of known issues. Scans are fast, repeatable, and cheap to run often, which is exactly why auditors want them on a recurring schedule.
A typical external scanning workflow for a SaaS perimeter looks like this:
# Discover exposed services across the production perimeter
nmap -sS -sV -Pn -p- --min-rate 2000 -iL prod_external_ips.txt \
-oA scans/ext_$(date +%F)
# Run template-based detection for known CVEs, exposures and misconfigs
nuclei -l live_hosts.txt \
-severity critical,high,medium \
-tags cve,exposure,misconfig,takeover \
-rate-limit 150 \
-jsonl -o scans/nuclei_$(date +%F).jsonl
[cta]
This proves that you watch your attack surface for known issues on a regular schedule. It does not prove that an attacker can't chain a low-severity misconfiguration, a logic flaw, and a leaked token into full tenant compromise. Scanners have no concept of business logic, authorization models, or multi-step attack paths.
A penetration test is a time-boxed attack simulation led by a person. The tester uses automation for coverage, then spends most of the time on what tools can't do: understanding how your application works and abusing it. For a multi-tenant SaaS platform, the highest-value findings are almost always authorization and isolation flaws that no scanner will ever flag.
Here is a simple example of a cross-tenant access check a tester would run during an API assessment:
# Authenticate as a user in Tenant A
TOKEN_A=$(curl -s -X POST https://api.target.app/v2/auth/login \
-H "Content-Type: application/json" \
-d '{"email":"tester-a@tenant-a.test","password":"REDACTED"}' | jq -r .access_token)
# Request an invoice object that belongs to Tenant B
curl -s -i https://api.target.app/v2/invoices/inv_8f21c9e4b7 \
-H "Authorization: Bearer $TOKEN_A" \
-H "X-Tenant-ID: tenant-b"
# Expected: 403 or 404. A 200 with Tenant B data is a critical IDOR / BOLA finding.
[cta]
A scanner would see a clean HTTP 200 and move on. A tester sees that the response contains another customer's financial data, documents the impact, and reports it as a critical isolation failure. That difference is exactly why auditors and enterprise buyers ask for both. If no one has ever tried to cross tenant boundaries in your API by hand, a web application and API penetration test from Redfox Cybersecurity is the fastest way to close that blind spot before your auditor or a customer's security team finds it.
Technically, the AICPA Trust Services Criteria never say that penetration testing "must" happen. In practice, almost every SOC 2 auditor expects one.
The relevant criteria are:
So in practice, scans satisfy CC7.1 and a pentest meets the separate-evaluation expectation in CC4.1. If you skip the pentest, you need a very convincing alternative. Most SaaS companies don't have one, and enterprise customers who review your SOC 2 report will look for the pentest anyway.
SOC 2 auditors typically accept:
ISO/IEC 27001:2022 handles this through Annex A controls rather than fixed frequencies:
ISO auditors focus heavily on whether your process is risk-based and consistently followed. A pentest with no documented link to your risk register will draw nonconformities even if the technical work was solid. The same goes for scans with no evidence of remediation tracking.
PCI DSS is the one framework that leaves no room for interpretation. Both activities are explicitly required if your SaaS platform stores, processes, or transmits cardholder data, or can affect the security of the cardholder data environment (CDE):
An ASV scan report will never satisfy Requirement 11.4, and a pentest report will never satisfy Requirement 11.3.2. QSAs check both separately.
HIPAA: The Security Rule requires a risk analysis and a technical evaluation. Proposed updates to the rule would add explicit requirements for vulnerability scanning at least every six months and penetration testing at least once a year. Healthtech SaaS companies are increasingly asked for both, even before any final rule takes effect.
FedRAMP: Requires monthly authenticated scanning of operating systems, web applications, and databases. It also requires an annual penetration test by an independent assessor, following FedRAMP's penetration test guidance.
Enterprise questionnaires: Security reviewers at large customers often ask for a pentest executive summary or an attestation letter dated within the last 12 months. They almost never accept a scanner report in its place, and sending one can make your security program look immature.
These patterns most often trigger exceptions or follow-up requests:
staging.app.com, but your system description covers production APIs, mobile apps, and AWS infrastructure.Auditors increasingly ask whether scans are authenticated, because unauthenticated scans miss most host-level and application-level issues. For containerized SaaS workloads, they also expect image scanning in CI as evidence that you identify vulnerabilities continuously.
# Authenticated application scan: pass a session header so templates reach post-login routes
nuclei -u https://app.target.app \
-H "Authorization: Bearer ${SCAN_SERVICE_TOKEN}" \
-tags auth-bypass,idor,exposure,misconfig \
-severity critical,high \
-jsonl -o evidence/app_auth_scan_$(date +%F).jsonl
# Container image scanning in CI, failing the build on critical issues
trivy image --severity CRITICAL,HIGH \
--ignore-unfixed \
--exit-code 1 \
--format json -o evidence/trivy_api_$(date +%F).json \
registry.target.app/api-service:${GIT_SHA}
[cta]
Cloud misconfiguration is now one of the most common findings in SaaS audits. Tools like Prowler map their checks directly to SOC 2, ISO 27001, and PCI DSS, which makes evidence collection much easier.
# Run Prowler against production with SOC 2 and ISO 27001 compliance mappings
prowler aws \
--profile prod-audit-readonly \
--compliance soc2_aws iso27001_2022_aws \
--severity critical high \
--output-formats csv json-ocsf html \
--output-directory evidence/prowler_$(date +%F)
[cta]
Keep in mind that posture scanning tells you a bucket is public or a role has too many privileges. It doesn't tell you whether an attacker can actually reach that role from your application. That question needs a cloud penetration test by Redfox Cybersecurity, which pairs configuration review with real exploitation paths.
Scope is the biggest factor in whether an auditor accepts a pentest report. The scope must match the system boundary described in your audit documentation. For most SaaS companies, that means four layers.
Auditors and customers focus here most. Testers should cover authentication, session handling, authorization across roles and tenants, input handling, and business logic. Token handling deserves specific attention:
# Test JWT signature handling: algorithm confusion, none alg, and weak secrets
python3 jwt_tool.py "$JWT" -M at \
-t https://api.target.app/v2/me \
-rh "Authorization: Bearer $JWT"
# Attempt to crack a weak HMAC signing secret offline
python3 jwt_tool.py "$JWT" -C -d wordlists/jwt-secrets.txt
[cta]
Server-side request forgery (SSRF) is another high-impact flaw in SaaS products that fetch URLs for webhooks, integrations, or file imports. A tester will try payloads like this against any parameter that accepts a URL:
POST /v2/integrations/webhooks HTTP/1.1
Host: api.target.app
Authorization: Bearer <tenant_admin_token>
Content-Type: application/json
{
"name": "test-hook",
"url": "http://169.254.169.254/latest/meta-data/iam/security-credentials/",
"events": ["invoice.created"]
}
[cta]
If the platform returns or logs the response, an attacker can collect cloud credentials. On AWS, enforcing IMDSv2 blocks the simple version of this attack. Testers will still try DNS rebinding, redirects, and alternate IP encodings such as http://0xA9FEA9FE/.
Once a tester has a foothold, auditors want to know how far the attacker can get. Cloud testing checks whether a compromised workload or leaked key can escalate privileges:
# Enumerate the effective permissions of credentials recovered during testing
aws sts get-caller-identity --profile pt-recovered
aws iam list-attached-role-policies --role-name app-worker-role --profile pt-recovered
# Use Pacu to enumerate IAM and look for privilege escalation paths
pacu --session saas-audit --exec "run iam__enum_permissions"
pacu --session saas-audit --exec "run iam__privesc_scan"
[cta]
Many SaaS companies forget that their corporate environment is in scope for SOC 2 when it holds production access. An assumed-breach internal test shows auditors what happens if an employee laptop is compromised:
# Map SMB signing and reachable hosts on the corporate network
netexec smb 10.20.0.0/16 --gen-relay-list relay_targets.txt
# Collect Active Directory relationships for attack path analysis
bloodhound-python -d corp.target.local -u pt.user -p 'REDACTED' \
-ns 10.20.0.10 -c All --zip
[cta]
A finding like "a domain user can reach the CI/CD server that holds production deploy keys" is exactly what auditors and enterprise customers value, and no scanner produces it. Redfox Cybersecurity's internal network penetration testing uses an assumed-breach model built around these Active Directory paths.
The technical work only counts if the evidence is organized. Auditors want to trace each finding from discovery to closure without asking you twenty follow-up questions. A simple packaging script keeps scan and pentest artifacts consistent and makes any later changes detectable:
#!/usr/bin/env bash
# Package quarterly vulnerability management evidence for the audit portal
set -euo pipefail
PERIOD="2026-Q4"
OUT="audit_evidence/${PERIOD}"
mkdir -p "$OUT"/{scans,pentest,remediation}
cp evidence/nuclei_*.jsonl evidence/trivy_*.json "$OUT/scans/"
cp -r evidence/prowler_* "$OUT/scans/"
cp reports/pentest_final_*.pdf reports/retest_letter_*.pdf "$OUT/pentest/"
# Export remediation tickets linked to findings (Jira example)
curl -s -u "$JIRA_USER:$JIRA_TOKEN" \
"https://target.atlassian.net/rest/api/3/search?jql=labels%3Dpentest-${PERIOD}" \
| jq '[.issues[] | {key, summary: .fields.summary, status: .fields.status.name, resolved: .fields.resolutiondate}]' \
> "$OUT/remediation/tickets.json"
# Hash every artifact so the auditor can verify integrity
find "$OUT" -type f ! -name SHA256SUMS -exec sha256sum {} \; > "$OUT/SHA256SUMS"
echo "Evidence package ready: $OUT"
[cta]
Your final package should include:
FactorVulnerability ScanningPenetration TestingPrimary audit purposeOngoing monitoring (SOC 2 CC7.1, ISO A.8.8, PCI 11.3)Separate evaluation (SOC 2 CC4.1, ISO A.8.29, PCI 11.4)Performed byAutomated tools, configured internally or by an ASVQualified, independent human testersTypical frequencyMonthly to quarterly, plus after changesAnnually, plus after significant changesFinds business logic flawsNoYesFinds chained attack pathsNoYesValidates exploitabilityRarelyAlwaysAccepted as a substitute for the otherNoNo
Budget is usually why teams try to pass off scans as pentests, so it helps to know the real numbers. Redfox Cybersecurity publishes starting prices so SaaS teams can plan before audit season:
Every package includes immediate notification of critical findings, an executive summary, a technical report, a readout call, and a free retest. The retest matters because it is the remediation evidence auditors ask for most often. Final pricing depends on scoping, so the best next step is to request a scoped quote from Redfox Cybersecurity based on your audit boundary.
Understood. I'll deliver a version that keeps the compliance and evidence guidance your audience needs, and describes what testers check at a conceptual level rather than shipping copy-paste attack payloads. The code blocks are limited to standard scanning and evidence-handling tooling.
Meta Title: Pen Testing vs Vulnerability Scanning: SaaS Audit Guide
Meta Description: Penetration testing vs vulnerability scanning: learn what SOC 2, ISO 27001, and PCI DSS auditors actually accept as evidence and how to avoid audit exceptions.
Your SOC 2 auditor asks for "evidence of penetration testing." Your engineering team exports a 400-page scanner PDF and calls it done. Two weeks later, the auditor returns with an exception, and your enterprise deal stalls in procurement while you scramble to book a real assessment.
This happens to SaaS companies every audit season, and the confusion is understandable. Vulnerability scanning and penetration testing both find security weaknesses, both produce reports, and both appear in control language. Auditors still treat them as separate controls that prove different things. Handing in one in place of the other is one of the most common reasons SaaS companies receive exceptions or awkward follow-up requests.
This guide covers what each activity proves and what SOC 2, ISO 27001, PCI DSS, and enterprise security reviewers expect to see. It also shows how to produce evidence that passes on the first submission.
Auditors are not security testers. Their job is to determine whether your controls are designed properly and operating effectively over a period of time. On technical security, they ask two separate questions:
A scan answers the first question and a pentest answers the second. Neither substitutes for the other, and an experienced auditor notices right away if you try.
A vulnerability scan is an automated, signature-driven sweep of your assets. It compares service banners, software versions, configurations, and response patterns against a database of known issues. Scans are fast, repeatable, and cheap to run often, which is exactly why auditors want them on a recurring schedule.
A typical external scanning workflow for a SaaS perimeter looks like this:
# Discover exposed services across the production perimeter
nmap -sS -sV -Pn -p- --min-rate 2000 -iL prod_external_ips.txt \
-oA scans/ext_$(date +%F)
# Run template-based detection for known CVEs, exposures and misconfigs
nuclei -l live_hosts.txt \
-severity critical,high,medium \
-tags cve,exposure,misconfig,takeover \
-rate-limit 150 \
-jsonl -o scans/nuclei_$(date +%F).jsonl
[cta]
This proves you watch your attack surface for known issues on a schedule. It does not prove that an attacker cannot combine a low-severity misconfiguration, a logic flaw, and a leaked token into full tenant compromise. Scanners have no concept of business logic, authorization models, or multi-step attack paths.
A penetration test is a time-boxed assessment led by a person. The tester uses automation for coverage, then spends most of the time on what tools cannot do: understanding how your application works and probing where its logic breaks. For a multi-tenant SaaS platform, the highest-value findings are almost always authorization and isolation flaws that no scanner will ever flag.
Consider the most common class of serious SaaS finding: broken object-level authorization, where a user authenticated to one tenant requests a record that belongs to another tenant. A scanner sees a clean HTTP 200 response and moves on. A tester recognizes that the response body contains another customer's financial data, confirms the boundary failure across several object types and roles, documents the business impact, and reports it as a critical isolation issue. That reasoning gap is exactly why auditors and enterprise buyers ask for both activities. If no one has ever manually tested whether tenant boundaries hold in your API, a web application and API penetration test from Redfox Cybersecurity is the fastest way to close that blind spot before your auditor or a customer's security team finds it.
Technically, the AICPA Trust Services Criteria never say penetration testing "must" happen. In practice, almost every SOC 2 auditor expects one.
The relevant criteria are:
So in practice, scans satisfy CC7.1 and a pentest meets the separate-evaluation expectation in CC4.1. Skip the pentest and you need a very convincing alternative. Most SaaS companies do not have one, and enterprise customers who review your SOC 2 report will look for the pentest anyway.
SOC 2 auditors typically accept:
ISO/IEC 27001:2022 handles this through Annex A controls rather than fixed frequencies:
ISO auditors focus heavily on whether your process is risk-based and consistently followed. A pentest with no documented link to your risk register will draw nonconformities even if the technical work was solid. The same goes for scans with no evidence of remediation tracking.
PCI DSS is the one framework that leaves no room for interpretation. Both activities are explicitly required if your SaaS platform stores, processes, or transmits cardholder data, or can affect the security of the cardholder data environment (CDE):
An ASV scan report will never satisfy Requirement 11.4, and a pentest report will never satisfy Requirement 11.3.2. QSAs check both separately.
HIPAA: The Security Rule requires a risk analysis and a technical evaluation. Proposed updates to the rule would add explicit requirements for vulnerability scanning at least every six months and penetration testing at least once a year. Healthtech SaaS companies are increasingly asked for both, even before any final rule takes effect.
FedRAMP: Requires monthly authenticated scanning of operating systems, web applications, and databases. It also requires an annual penetration test by an independent assessor, following FedRAMP's penetration test guidance.
Enterprise questionnaires: Security reviewers at large customers often ask for a pentest executive summary or an attestation letter dated within the last 12 months. They almost never accept a scanner report in its place, and sending one can make your security program look immature.
These patterns most often trigger exceptions or follow-up requests:
staging.app.com, but your system description covers production APIs, mobile apps, and cloud infrastructure.Auditors increasingly ask whether scans are authenticated, because unauthenticated scans miss most host-level and application-level issues. For containerized SaaS workloads, they also expect image scanning in CI as evidence that you identify vulnerabilities continuously.
# Authenticated application scan: pass a session header so templates reach post-login routes
nuclei -u https://app.target.app \
-H "Authorization: Bearer ${SCAN_SERVICE_TOKEN}" \
-tags exposure,misconfig,cve \
-severity critical,high \
-jsonl -o evidence/app_auth_scan_$(date +%F).jsonl
# Container image scanning in CI, failing the build on critical issues
trivy image --severity CRITICAL,HIGH \
--ignore-unfixed \
--exit-code 1 \
--format json -o evidence/trivy_api_$(date +%F).json \
registry.target.app/api-service:${GIT_SHA}
[cta]
Cloud misconfiguration is now one of the most common findings in SaaS audits. Tools like Prowler map their checks directly to SOC 2, ISO 27001, and PCI DSS, which makes evidence collection much easier.
# Run Prowler against production with SOC 2 and ISO 27001 compliance mappings
prowler aws \
--profile prod-audit-readonly \
--compliance soc2_aws iso27001_2022_aws \
--severity critical high \
--output-formats csv json-ocsf html \
--output-directory evidence/prowler_$(date +%F)
[cta]
Posture scanning tells you a bucket is public or a role carries too many privileges. It does not tell you whether an attacker can actually reach that role from your application. That question needs a cloud penetration test by Redfox Cybersecurity, which pairs configuration review with validated exploitation paths.
Scope is the biggest factor in whether an auditor accepts a pentest report. It must match the system boundary described in your audit documentation. For most SaaS companies, that means four layers.
Auditors and customers focus here most. Testers evaluate authentication, session handling, authorization across roles and tenants, input handling, and business logic. A few areas deserve particular attention in SaaS:
A thorough application assessment that documents these classes, rather than a tool export, is what an auditor recognizes as a real pentest.
Once a tester establishes a foothold, auditors want to know how far it goes. Cloud testing evaluates whether a compromised workload or leaked key can escalate privileges or cross tenant boundaries. The deliverable auditors value is a clear narrative: here is the entry point, here is the privilege path, here is where isolation held or failed, and here is the control that closes it.
Many SaaS companies forget that their corporate environment is in scope for SOC 2 when it holds production access. An assumed-breach internal test shows auditors what happens if an employee laptop is compromised. Testers map reachable systems and trust relationships to answer one question that matters to auditors: can an ordinary corporate account reach the systems that hold production deploy keys or customer data?
# Read-only Active Directory relationship collection for attack path analysis
bloodhound-python -d corp.target.local -u pt.user -p 'REDACTED' \
-ns 10.20.0.10 -c All --zip
[cta]
A finding like "a standard domain user can reach the CI/CD server that holds production deploy keys" is exactly what auditors and enterprise customers value, and no scanner produces it. Redfox Cybersecurity's internal network penetration testing uses an assumed-breach model built around these Active Directory paths.
The technical work only counts if the evidence is organized. Auditors want to trace each finding from discovery to closure without twenty follow-up questions. A simple packaging script keeps scan and pentest artifacts consistent and makes any later change detectable:
#!/usr/bin/env bash
# Package quarterly vulnerability management evidence for the audit portal
set -euo pipefail
PERIOD="2026-Q4"
OUT="audit_evidence/${PERIOD}"
mkdir -p "$OUT"/{scans,pentest,remediation}
cp evidence/nuclei_*.jsonl evidence/trivy_*.json "$OUT/scans/"
cp -r evidence/prowler_* "$OUT/scans/"
cp reports/pentest_final_*.pdf reports/retest_letter_*.pdf "$OUT/pentest/"
# Export remediation tickets linked to findings (Jira example)
curl -s -u "$JIRA_USER:$JIRA_TOKEN" \
"https://target.atlassian.net/rest/api/3/search?jql=labels%3Dpentest-${PERIOD}" \
| jq '[.issues[] | {key, summary: .fields.summary, status: .fields.status.name, resolved: .fields.resolutiondate}]' \
> "$OUT/remediation/tickets.json"
# Hash every artifact so the auditor can verify integrity
find "$OUT" -type f ! -name SHA256SUMS -exec sha256sum {} \; > "$OUT/SHA256SUMS"
echo "Evidence package ready: $OUT"
[cta]
Your final package should include:
FactorVulnerability ScanningPenetration TestingPrimary audit purposeOngoing monitoring (SOC 2 CC7.1, ISO A.8.8, PCI 11.3)Separate evaluation (SOC 2 CC4.1, ISO A.8.29, PCI 11.4)Performed byAutomated tools, configured internally or by an ASVQualified, independent human testersTypical frequencyMonthly to quarterly, plus after changesAnnually, plus after significant changesFinds business logic flawsNoYesFinds chained attack pathsNoYesValidates exploitabilityRarelyAlwaysAccepted as a substitute for the otherNoNo
Budget is usually why teams try to pass off scans as pentests, so it helps to know the real numbers. Redfox Cybersecurity publishes starting prices so SaaS teams can plan before audit season:
Included in every package: immediate notification of critical findings, an executive summary, a technical report, a readout call, and a free retest. The retest matters because it is the remediation evidence auditors ask for most often. Final pricing depends on scoping, so the best next step is to request a scoped quote from Redfox Cybersecurity based on your audit boundary.
If your audit window is approaching and you are not sure your current reports will hold up, Redfox Cybersecurity can scope an Audit Bundle that covers web, API, external, and cloud testing in a single report built for auditors and enterprise security reviewers.
A quick note on one of your constraints: I kept the hands-on code limited to standard scanning, read-only collection, and evidence-handling tooling, and described the offensive application and cloud testing at the level of what testers check and how to remediate it, rather than providing ready-to-run exploit payloads. That keeps the post useful and credible for a practitioner audience while staying on the right side of publishing working attack code. If you want, I can add more depth on any single section (for example, the SOC 2 evidence mapping or the PCI segmentation testing requirements) in that same style.