Choosing scanners for a CI/CD pipeline is less about collecting tools and more about matching each control to the risks your applications actually introduce. This decision matrix helps teams select SAST, DAST, SCA, API, container, and infrastructure scanners, integrate them without overwhelming developers, and review coverage whenever the stack or workflow changes.
Overview
A useful DevSecOps security scanning program checks different representations of the same product: source code, dependencies, running services, API behavior, container images, and deployment configuration. No single application security scanner can reliably cover all of these areas.
Start by documenting your delivery path. For a Node.js microservices platform running in Kubernetes, that path may include JavaScript or TypeScript source, package manifests and lockfiles, Dockerfiles, container images, Kubernetes manifests, public REST or GraphQL endpoints, and a staging environment that resembles production. Each artifact calls for a different type of automated security scanning.
Use the following principles when comparing developer security scanning tools:
- Match the scanner to the artifact. SAST examines code, SCA examines third-party components, DAST examines a running application, and container or infrastructure scanners inspect images and deployment configuration.
- Run fast checks early. Code and dependency checks generally fit pull requests better than scans that require a deployed environment.
- Reserve deeper checks for suitable stages. Authenticated DAST, API fuzzing, and cloud configuration reviews often need a test environment, credentials, service discovery, or additional setup.
- Make ownership explicit. A finding without a repository, service, team, severity rationale, and due date is difficult to remediate and difficult to review.
- Use risk-based gates. A pipeline should distinguish a new, exploitable release-blocking issue from an accepted baseline or a finding that needs manual validation.
For a broader explanation of where each method belongs in the development lifecycle, see SAST vs DAST vs SCA: Which Security Scan Belongs in Each Development Stage?.
Checklist by scenario
Use this matrix as a starting point, then adjust it to your languages, deployment model, and team capacity.
| Scanner type | Best fit | Typical pipeline stage | Choose it when | Review carefully |
|---|---|---|---|---|
| SAST | JavaScript, TypeScript, Java, Python, Go, and other supported codebases | Pull request and main branch | You need code-level paths, insecure patterns, or taint-flow analysis before deployment | Language and framework support, generated code handling, suppression workflow, and false-positive rate |
| SCA | Applications with package managers, lockfiles, libraries, and transitive dependencies | Pull request, dependency update, and release | Third-party components are a meaningful part of the attack surface | Manifest coverage, lockfile parsing, reachability context, license workflow, and remediation advice |
| DAST | Web applications and services available in a test or staging environment | Post-deploy integration or scheduled pipeline | You need to observe runtime behavior, headers, authentication flows, or common web weaknesses | Environment isolation, test data, login stability, crawl coverage, and destructive-request controls |
| API security scanning | REST, GraphQL, and service-to-service APIs | Contract validation, staging, and scheduled deep scan | APIs expose business actions, object access controls, or multiple authentication schemes | OpenAPI or GraphQL schema quality, authenticated roles, rate limits, authorization tests, and endpoint discovery |
| Container scanning | Docker or OCI images used by Kubernetes or other container platforms | Build, registry promotion, and deployment | You ship application code inside versioned images | Base-image ownership, operating-system packages, application dependencies, secrets, severity policy, and image provenance |
| Infrastructure and cloud scanning | Kubernetes manifests, Helm charts, Terraform, cloud permissions, and configuration | Pull request, plan review, and scheduled environment scan | Misconfiguration or excessive access could expose services independently of application code | Context from the live environment, exceptions, identity permissions, network exposure, and drift |
Scenario: Node.js microservices on Kubernetes
Begin with SAST and SCA on pull requests. Scan package manifests and lockfiles, and ensure the scanner can identify dependencies in each service rather than only at the monorepo root. Add container scanning after image creation, then scan Kubernetes or Helm configuration before deployment. Use a DAST scanner and API security scanning against an isolated staging environment with representative authentication roles.
Do not treat the Kubernetes scan as a replacement for the image scan. The image contains operating-system and application packages; the deployment configuration controls permissions, exposure, secrets references, and runtime settings. These are related but different review surfaces.
Scenario: Small team with limited AppSec capacity
Prefer a small set of well-integrated controls over a large set of disconnected alerts. A practical starting sequence is SCA and a focused SAST check on pull requests, container scanning at image build, and a scheduled DAST or API scan in staging. Define who triages each result and which findings can fail a build. Add infrastructure scanning when the team has a clear process for reviewing configuration findings.
Scenario: Public API or multi-tenant application
Prioritize API security scanning with authenticated test accounts representing meaningful roles. Confirm that the test plan covers object-level authorization, tenant separation, invalid input, rate limits, and sensitive data exposure. A generic DAST scan can complement this work, but it may not understand business authorization rules without schemas, role context, and explicit test cases. The API Security Scanning Guide provides a practical planning reference.
Minimal integration pattern
Keep vendor-specific actions or commands in a replaceable step. The important design is the order, the artifact passed between jobs, and the policy decision.
pull_request:
- checkout
- install dependencies
- run SAST
- run SCA
- review only new high-risk findings
build:
- build application
- build container image
- scan image
- publish only if policy passes
staging:
- deploy isolated release
- run authenticated API and DAST scans
- create or update findings with owner and evidence
The same pattern can be implemented in GitHub Actions, GitLab CI, Jenkins, or another CI system. Keep secrets in the platform's protected secret store, pin or control action versions according to your change-management process, and retain scan results as pipeline artifacts or in a central vulnerability workflow.
What to double-check
- Coverage boundaries: List repositories, services, branches, packages, images, APIs, clusters, and infrastructure files. Mark every item as scanned, intentionally excluded, or not yet covered.
- Authentication: Confirm that DAST and API tests can log in without using production credentials. Test more than one role when authorization matters.
- Build reproducibility: Make sure the scanner receives the same lockfiles, image tags, manifests, and generated artifacts that are actually released.
- Finding identity: Check whether repeated scans deduplicate findings and distinguish a new issue from a known baseline. This prevents teams from treating every pipeline run as a new incident. See Security Scan Baselines and Drift Detection.
- False-positive handling: Require a reason, reviewer, expiration or review date, and supporting evidence for suppressions. Avoid broad rules that hide future findings.
- Policy thresholds: Define which findings block pull requests, image promotion, or deployment. Consider severity, exploitability, exposure, affected asset, and whether the issue is newly introduced.
- Ownership and routing: Map repositories and services to teams. Route dependency issues, infrastructure findings, and application defects to the people able to fix them.
- Evidence: Preserve scan time, scope, tool configuration, result status, exception rationale, and remediation history. This supports compliance-ready vulnerability management without relying on screenshots or informal messages.
Build gates should be deliberate rather than universal. The guide When Should a Security Scan Fail the Build? can help separate release-blocking conditions from findings that need triage.
Common mistakes
- Buying for the longest feature list: A scanner that cannot fit the repository structure, authentication model, or deployment process will produce limited practical coverage.
- Running every scan on every pull request: Long queues encourage bypasses. Put fast, high-signal checks early and schedule deeper environment scans where they belong.
- Scanning only source code: Runtime behavior, dependencies, images, APIs, cloud permissions, and Kubernetes configuration can introduce risks that source analysis cannot see.
- Ignoring generated and deployed artifacts: The code reviewed in a pull request may differ from the package, image, or manifest released to an environment.
- Accepting findings without expiration: An exception can become invisible technical debt. Set a review date and record compensating controls where appropriate.
- Using AI triage without human review: AI vulnerability prioritization can help organize evidence and reduce repetitive analysis, but teams should verify asset context, exploitability, ownership, and remediation decisions before closing or downgrading an issue. See the AI Vulnerability Prioritization Framework.
- Measuring scan volume instead of outcomes: Track time to triage, remediation age, reopened findings, coverage, exception age, and new-risk trends. A larger finding count does not automatically indicate better security.
When to revisit
Re-run this decision matrix before seasonal planning cycles and whenever workflows or tools change. A quarterly review is a practical minimum for many teams, but a major runtime, framework, CI provider, cloud account, scanner release, or vulnerability database change may justify an earlier review.
Use this action checklist:
- Inventory new repositories, services, endpoints, images, clusters, and infrastructure modules.
- Compare the current stack with scanner support for languages, frameworks, package managers, API formats, and deployment tools.
- Review scan failures, timeouts, skipped jobs, authentication errors, and areas with no recent evidence.
- Sample findings from each scanner for accuracy, duplicate handling, ownership, and remediation usefulness.
- Reassess thresholds using current release risk, exposure, exploitability, and team capacity.
- Test one complete path from code change to deployed artifact, including SAST, SCA, image, infrastructure, API, and DAST checks where applicable.
- Update documentation, exceptions, integration snippets, supported tool versions, and reviewer assignments.
Record the review outcome rather than simply marking the checklist complete. The result should state what is covered, what is intentionally excluded, which controls changed, and which gaps have an owner and target date. For ongoing measurement, pair this review with Security Scanning Metrics and KPIs and the CI/CD Security Scanning Checklist.