SaaS products in 2026 have more moving parts than ever before. A typical stack spans multi-tenant databases, dozens of third-party integrations, AI-assisted features, ephemeral CI runners, and a growing number of machine identities. Attackers know this. Supply chain compromises, stolen OAuth tokens, and broken object-level authorization keep showing up in incident reports because they work.
This guide covers 15 SaaS security best practices that engineering teams can actually ship, not just put on a slide. Each one comes with the commands, configs, or code you need to implement it this quarter.
The attack surface of a modern SaaS platform is mostly made of code and configuration, not network perimeter. Your customers trust you with their data and, through integrations, with access to their other systems. One weak tenant boundary or leaked CI token can turn into a breach across every customer you have.
Security also decides deals now. Enterprise buyers expect SOC 2 reports, pentest letters, and clear answers on tenant isolation before they sign. Teams that build these controls into their delivery pipeline move faster through procurement and spend less time firefighting.
SMS codes and push notifications are no longer enough. Adversary-in-the-middle phishing kits capture session cookies in real time, and MFA fatigue attacks still work against push-based approvals. Require FIDO2/WebAuthn passkeys for every employee, and offer SAML or OIDC SSO to your customers so they can apply their own policies.
If you manage Okta with Terraform, you can enforce phishing-resistant authenticators for admin apps in code:
resource "okta_app_signon_policy_rule" "admin_phishing_resistant" {
policy_id = okta_app_signon_policy.admin_console.id
name = "Require phishing-resistant MFA"
priority = 1
access = "ALLOW"
factor_mode = "2FA"
re_authentication_frequency = "PT2H"
constraints = [
jsonencode({
possession = {
required = true
phishingResistant = "REQUIRED"
hardwareProtection = "REQUIRED"
}
})
]
}
[cta]
Apply the same rule to your cloud consoles, source control, and CI platform. Those three are where attackers go first.
Static AWS access keys sitting in CI secrets are one of the most common root causes of SaaS breaches. Use OIDC federation so your pipelines request credentials that expire within the hour, scoped to a single repository and branch.
# .github/workflows/deploy.yml
permissions:
id-token: write
contents: read
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: aws-actions/configure-aws-credentials@e3dd6a429d7300a6a4c196c26e071d42e0343502 # v4.0.2
with:
role-to-assume: arn:aws:iam::123456789012:role/gh-deploy-prod
role-session-name: deploy-${{ github.run_id }}
aws-region: us-east-1
[cta]
Then lock the trust policy to the exact repository and ref, so that a fork or feature branch can't assume the production role:
"Condition": {
"StringEquals": {
"token.actions.githubusercontent.com:aud": "sts.amazonaws.com",
"token.actions.githubusercontent.com:sub": "repo:acme/platform:ref:refs/heads/main"
}
}
[cta]
A loose wildcard on the sub claim is one of the most frequent misconfigurations found in cloud reviews. If you aren't sure your trust policies would hold up, the cloud security assessments from Redfox Cybersecurity test federation paths end to end, including cross-account role chaining.
Application-level WHERE tenant_id = ? filters fail the first time a developer forgets them. PostgreSQL Row-Level Security turns that filter into a guarantee the database enforces on every query.
ALTER TABLE invoices ENABLE ROW LEVEL SECURITY;
ALTER TABLE invoices FORCE ROW LEVEL SECURITY;
CREATE POLICY tenant_isolation ON invoices
USING (tenant_id = current_setting('app.current_tenant')::uuid)
WITH CHECK (tenant_id = current_setting('app.current_tenant')::uuid);
-- Application role must not bypass RLS
ALTER ROLE app_user NOBYPASSRLS;
-- Set per transaction from the authenticated session, never from user input
BEGIN;
SET LOCAL app.current_tenant = '6f1c2a9e-4b7d-4e2a-9c11-8d3f0e7b5a21';
SELECT * FROM invoices;
COMMIT;
[cta]
FORCE ROW LEVEL SECURITY matters because table owners skip RLS by default. Without it, a migration role or a misconfigured connection pool can quietly read across tenants.
Broken Object Level Authorization still tops the OWASP API Security Top 10. The fix is architectural: every object lookup goes through a single authorization function, and no handler builds its own ownership check.
// authz.ts
export async function loadAuthorized<T>(
repo: Repository<T>,
id: string,
ctx: RequestContext,
action: "read" | "write" | "delete"
): Promise<T> {
const obj = await repo.findOne({ where: { id, tenantId: ctx.tenantId } });
if (!obj) throw new NotFoundError(); // 404, never 403, to avoid enumeration
if (!(await policy.can(ctx.user, action, obj))) throw new NotFoundError();
return obj;
}
[cta]
Test it the way an attacker would. Authenticate as tenant A, harvest object IDs, then replay those IDs with tenant B's token:
ffuf -w tenantA_invoice_ids.txt \
-u https://api.example.com/v2/invoices/FUZZ \
-H "Authorization: Bearer $TENANT_B_TOKEN" \
-mc 200 -o bola_findings.json
[cta]
Any 200 response is a cross-tenant leak. In Burp Suite, the Autorize extension automates this check across every request you proxy. Authorization flaws are hard for scanners to find because they depend on business logic, which is why the API and web application penetration testing at Redfox Cybersecurity relies on manual multi-role testing to cover them.
Secrets leak through commits, CI logs, Docker layers, and Slack pastes. Block them at pre-commit, scan again in CI, and run a full history scan to find credentials that are already exposed.
# Pre-commit and CI: block new leaks
gitleaks git --redact --exit-code 1 --report-path gitleaks.json .
# Full history, verified-only, across the whole org
trufflehog github --org=acme --only-verified --json > trufflehog_org.json
# Check container image layers too
trufflehog docker --image=ghcr.io/acme/api:latest --only-verified
[cta]
Rotate any verified hit right away. Deleting the commit doesn't help, because the secret already lives in forks, clones, and caches.
Generic SAST rulesets produce a lot of noise. What makes it worthwhile is writing rules for your own codebase. For example, this Semgrep rule flags any ORM query against a tenant-scoped model that doesn't filter by tenant:
rules:
- id: missing-tenant-scope
languages: [typescript]
severity: ERROR
message: "Query on tenant-scoped model without tenantId filter"
patterns:
- pattern-either:
- pattern: $REPO.findOne({ where: $W })
- pattern: $REPO.find({ where: $W })
- metavariable-pattern:
metavariable: $W
patterns:
- pattern-not: "{..., tenantId: $T, ...}"
- metavariable-regex:
metavariable: $REPO
regex: (invoiceRepo|userRepo|projectRepo)
[cta]
semgrep scan --config .semgrep/ --config p/owasp-top-ten \
--baseline-commit origin/main --error --sarif -o semgrep.sarif
[cta]
The --baseline-commit flag reports only new findings, so developers can fix what they introduced without wading through legacy debt.
The tj-actions/changed-files compromise in 2025 showed how a single mutable tag can leak secrets from thousands of repositories. Pin every third-party action to a full commit SHA, set default token permissions to read-only, and audit workflows for injection sinks.
# Audit all workflows for template injection, excessive permissions, unpinned actions
zizmor --min-severity medium .github/workflows/
# Pin actions to SHAs automatically
pinact run
[cta]
Also look for pull_request_target workflows that check out untrusted PR code. That pattern gives attackers a direct path to your repository secrets.
Customers and regulators now expect a Software Bill of Materials. More practically, an SBOM lets you answer "are we affected?" within minutes of the next major CVE. Generate one at build time, scan it, and sign both the image and the attestation.
# Generate SBOM
syft ghcr.io/acme/api:${GIT_SHA} -o cyclonedx-json > sbom.cdx.json
# Fail the build on fixable critical/high vulns
grype sbom:sbom.cdx.json --fail-on high --only-fixed
# Keyless signing with Sigstore
cosign sign --yes ghcr.io/acme/api@${DIGEST}
cosign attest --yes --type cyclonedx --predicate sbom.cdx.json ghcr.io/acme/api@${DIGEST}
# Verify at deploy time
cosign verify ghcr.io/acme/api@${DIGEST} \
--certificate-identity-regexp '^https://github.com/acme/api/' \
--certificate-oidc-issuer https://token.actions.githubusercontent.com
[cta]
Enforce verification in your cluster with an admission controller such as Kyverno or Sigstore policy-controller, so unsigned images never run.
Most cloud breaches come from misconfiguration, not zero-days. Catch it in the pull request, before terraform apply runs.
checkov -d ./infra --framework terraform \
--check CKV_AWS_18,CKV_AWS_19,CKV_AWS_144,CKV_AWS_145 \
--hard-fail-on HIGH,CRITICAL --output sarif
[cta]
For organization-specific rules, write Rego and run it with Conftest against the Terraform plan:
package terraform.s3
deny[msg] {
r := input.resource_changes[_]
r.type == "aws_s3_bucket_public_access_block"
not r.change.after.block_public_policy
msg := sprintf("%s must block public bucket policies", [r.address])
}
[cta]
terraform plan -out tf.plan && terraform show -json tf.plan > plan.json
conftest test plan.json --policy policy/
[cta]
IaC scanning doesn't catch console drift, forgotten resources, or overly broad IAM policies. Run a posture scanner on a schedule and route the findings into your ticketing system.
prowler aws --compliance soc2_aws cis_3.0_aws \
--severity critical high \
--output-formats json-ocsf html \
--output-directory ./prowler-reports
[cta]
Pay close attention to IAM findings. Privilege escalation paths such as iam:PassRole combined with lambda:CreateFunction don't look dangerous on their own, but they amount to admin access. Mapping those chains manually is part of how Redfox Cybersecurity runs its cloud penetration testing engagements.
Apply Pod Security Standards at the restricted level, drop all capabilities, and run as non-root. Then add runtime detection so you know when something slips through.
apiVersion: v1
kind: Namespace
metadata:
name: tenant-workloads
labels:
pod-security.kubernetes.io/enforce: restricted
pod-security.kubernetes.io/enforce-version: latest
[cta]
A Falco rule that catches a shell spawned inside a production container, which is a strong sign of post-exploitation:
- rule: Shell Spawned in Prod Container
desc: Interactive shell in a production workload
condition: >
spawned_process and container
and k8s.ns.name in (prod, tenant-workloads)
and proc.name in (bash, sh, zsh, ash)
and proc.tty != 0
output: "Shell in prod (user=%user.name pod=%k8s.pod.name cmd=%proc.cmdline)"
priority: CRITICAL
[cta]
Run kube-bench against your nodes every quarter, and audit RBAC for wildcard verbs and cluster-admin bindings to service accounts.
JWT libraries are safe only when you configure them explicitly. Pin the algorithm, check the issuer and audience, and reject tokens with a kid that doesn't come from your JWKS.
import jwt
from jwt import PyJWKClient
jwks = PyJWKClient("https://auth.example.com/.well-known/jwks.json", cache_keys=True)
def verify(token: str) -> dict:
key = jwks.get_signing_key_from_jwt(token).key
return jwt.decode(
token,
key,
algorithms=["RS256"], # never accept "none" or HS256 here
audience="api.example.com",
issuer="https://auth.example.com/",
options={"require": ["exp", "iat", "sub", "tid"]},
leeway=30,
)
[cta]
Add per-tenant and per-identity rate limits to login, password reset, token issuance, export, and any AI inference endpoint. Inference endpoints in particular can be abused for cost exhaustion and data extraction through prompt injection.
These cost almost nothing and close entire classes of attack. Check what your production edge returns today:
curl -sI https://app.example.com | grep -iE \
'strict-transport|content-security|x-frame|x-content-type|referrer-policy|set-cookie'
[cta]
Your target baseline:
add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload" always;
add_header Content-Security-Policy "default-src 'self'; script-src 'self' 'nonce-$request_id'; object-src 'none'; frame-ancestors 'none'; base-uri 'none'" always;
add_header X-Content-Type-Options "nosniff" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
# Session cookie: Set-Cookie: __Host-session=...; Secure; HttpOnly; SameSite=Lax; Path=/
[cta]
The __Host- prefix forces the cookie to be Secure, host-only, and scoped to /, which stops subdomain cookie-tossing attacks.
Enterprise customers want to see who did what in their tenant, and your incident responders need the same data. Log security-relevant events in a structured, immutable format, and stream them to your SIEM.
{
"ts": "2026-11-17T07:12:44.381Z",
"event": "api_token.created",
"tenant_id": "6f1c2a9e-4b7d-4e2a-9c11-8d3f0e7b5a21",
"actor": { "type": "user", "id": "u_8812", "ip": "203.0.113.24", "ua_hash": "a91f..." },
"target": { "type": "api_token", "id": "tok_55a1", "scopes": ["invoices:read"] },
"auth": { "method": "sso_saml", "mfa": "webauthn", "session_id": "s_19c0" },
"result": "success",
"request_id": "req_7f3e2b"
}
[cta]
Write the logs to object storage with Object Lock in compliance mode, so an attacker with production access can't erase their tracks. Alert on high-signal events such as new admin grants, SSO configuration changes, bulk exports, and token creation from new ASNs.
Automated scanning catches regressions between releases. Run Nuclei against staging on every deploy with templates for exposed panels, misconfigurations, and recent CVEs, and add your own templates for issues specific to your app.
nuclei -l staging_hosts.txt \
-tags exposure,misconfig,cve,takeover \
-severity medium,high,critical \
-rl 50 -jsonl -o nuclei_$(date +%F).jsonl
zap-baseline.py -t https://staging.example.com \
-c zap-rules.conf -J zap_report.json -I
[cta]
Scanners can't reason about your business logic, chain low-severity bugs into an account takeover, or exploit a race condition in your billing flow. That takes a skilled human tester. Plan at least one full-scope penetration test a year, plus a targeted test after major architectural changes such as a new auth provider, a new tenant model, or a new AI agent feature with tool access.
Redfox Cybersecurity runs web application, API, and cloud penetration tests that cover multi-tenant isolation, authorization logic, and CI/CD attack paths, and delivers reports that both your engineers and your enterprise customers' security reviewers can use.
You can't ship all fifteen in one sprint. A practical order for most SaaS teams:
Track each practice as an engineering deliverable with an owner, a definition of done, and a test that proves the control works. A control that nobody has validated is still just an assumption.
Security work that ships through the same pipeline as your features scales with your team. If you want an independent check of how these controls hold up under real attack conditions, talk to Redfox Cybersecurity about a penetration test scoped to your SaaS architecture.