Three acronyms, three different blind spots. A decision table for engineering leads who need to pick what to adopt first and how the tools fit together in the pipeline.
In short
SAST reads your source code for insecure patterns, DAST attacks the running application from the outside, and SCA checks the open-source components you depend on for known vulnerabilities and licence issues. Most teams should start with SCA, add SAST in pull requests, and run DAST against a staging environment, because each finds problems the others cannot see.
Application security (in Swedish, applikationssäkerhet) testing tools are often sold as if one of them were enough. This comparison is written by Devies, a Gothenburg-based product and engineering consultancy, for CTOs and engineering leads choosing between SAST, DAST and SCA, or deciding the order in which to adopt them. It explains what each method is, compares them side by side, and shows when to choose which.
What are SAST, DAST and SCA?
SAST, DAST and SCA are three automated ways to find security weaknesses in software, and they differ in what they look at: your code, your running application, or the third-party code inside it.
- SAST (static application security testing) is analysis of source code, bytecode or binaries without running them, looking for patterns such as unsanitised input reaching a database query. OWASP describes these as source code analysis tools.
- DAST (dynamic application security testing) is testing of a running application from the outside, sending crafted requests and observing responses, the way an attacker would probe it. OWASP lists them as vulnerability scanning tools for web applications.
- SCA (software composition analysis) is identification of the open-source and third-party components in your software, matched against vulnerability databases and licence rules. OWASP calls this component analysis.
Two neighbours are often confused with them. IAST (interactive testing) instruments the application while tests run, combining parts of SAST and DAST. Secret scanning looks for keys and passwords committed to repositories; it is a separate control, not a kind of SAST.
How do SAST, DAST and SCA compare?
The three methods are complementary rather than competing, because each covers a different layer and fails in a different way.
Criterion
SAST
DAST
SCA
What it examines
SAST
Your own source code
DAST
The running application
SCA
Third-party and open-source components
When it runs
SAST
In the IDE, on pull requests
DAST
Against a deployed test or staging environment
SCA
On every build, and continuously after release
Typical findings
SAST
Injection flaws, unsafe functions, hard-coded values, missing input validation
DAST
Misconfigured headers, authentication and session flaws, injection that is actually reachable
SCA
Known CVEs in dependencies, outdated versions, licence conflicts
Needs source code
SAST
Yes
DAST
No
SCA
Manifest, lock files or binary
Language dependent
SAST
Yes, per language and framework
DAST
No, works at the HTTP or API level
SCA
Per package ecosystem
False positives
SAST
Often high until tuned
DAST
Lower, but coverage depends on crawling and authentication
SCA
Low for detection, but many findings are not exploitable in your use
Points to the line of code
SAST
Yes
DAST
No, points to a URL or request
SCA
Points to a package and version
Blind spots
SAST
Configuration, runtime behaviour, business logic
DAST
Code paths it never reaches, logic flaws
SCA
Your own code, unknown vulnerabilities
Setup effort
SAST
Medium: tuning rules per codebase
DAST
Medium to high: environments, test accounts, scope
SCA
Low: often minutes per repository
Two points from the table matter most for planning. First, SCA has the best ratio of effort to value for most modern products, because the majority of the code shipped is third-party. Second, DAST is the only one of the three that tests what actually runs, including configuration and the infrastructure in front of the application.
When should you choose SAST, DAST or SCA first?
Choose based on where your risk sits and how your team works, then add the others in a deliberate order rather than all at once.
Choose SCA first when:
- Your product depends heavily on open-source packages, which is almost every web, mobile or cloud product.
- You sell products in the EU and need a software bill of materials and vulnerability handling for the Cyber Resilience Act.
- You want quick value with low setup cost.
Choose SAST first when:
- You write a lot of your own business logic, especially in languages where injection and memory errors are common.
- Your developers will act on findings in pull requests, so feedback arrives while the code is fresh.
- You have someone to tune the rules in the first weeks, or the noise will train people to ignore it.
Choose dynamic testing first when:
- You run internet-facing web applications or APIs and want to see what an attacker sees.
- You have a stable staging environment with test accounts.
- You inherited an application whose source you cannot easily scan, or a third-party application you host.
For most product teams the practical order is SCA, then SAST on pull requests, then a scheduled DAST scan against staging. The DevSecOps view of where each gate sits is covered in DevSecOps: security built into every release.
How do the three fit into one pipeline?
The three tools fit into one pipeline when each runs where its feedback is cheapest to act on and the findings land in one triage queue.
A workable setup:
- On commit and pull request: SAST on the changed code and secret scanning. Block only on new high-confidence findings.
- On build: SCA against lock files, generating an SBOM as an artefact. Block on known exploited or critical vulnerabilities with an available fix.
- After deploy to staging: DAST, authenticated, against the main user journeys and APIs. Run a short scan nightly and a full scan before major releases.
- After release: keep SCA monitoring running against the SBOMs of shipped versions, because new CVEs are published after you ship.
- In triage: deduplicate findings, assign an owner and a deadline by severity, and track exceptions with an expiry date.
The NIST Secure Software Development Framework (SP 800-218) asks for both code review and analysis and testing of executable code, which maps directly to SAST and DAST. Use the OWASP Top 10 as the shared language for findings; see OWASP Top 10 explained. For the dependency side beyond SCA, such as build integrity and choosing packages, read software supply chain security.
What do these tools not replace?
Automated testing does not replace threat modelling, manual code review or penetration testing, because tools cannot judge business logic or design flaws.
Typical misses: a user who can see another customer's orders by changing an ID, a discount that applies twice, or an admin function missing an authorisation check that every scanner reaches only as a logged-in admin. These belong to authorisation and logic, and people who understand the product find them, not scanners. Use the tools to remove the predictable issues so that manual testing time goes to the hard ones.
Devies
Want a second opinion?
Devies, a Gothenburg-based product and engineering consultancy, works on questions like this with Nordic product and IT teams. Tell us where you are and we will suggest a sensible first step.
Frequently asked questions
What is the difference between SAST and DAST?
SAST analyses source code without running it and points to the exact line where a weakness is, which makes it useful early in development. DAST tests the running application from the outside like an attacker, so it finds configuration and runtime issues and confirms that a problem is reachable, but it cannot point to the code. They complement each other and are usually combined.
Is SCA the same as an SBOM?
No. An SBOM is a list of the components in your software. SCA is the analysis that creates or reads that list and checks each component against vulnerability databases and licence rules. Most SCA tools can export an SBOM in SPDX or CycloneDX format, and the SBOM lets you keep checking shipped versions after release when new vulnerabilities are published.
Can we rely on DAST instead of a penetration test?
No. DAST finds common, well-defined issues automatically and repeatedly, which makes it a good regular control. A penetration test uses human judgement to chain weaknesses, test business logic and authorisation, and explore paths a scanner does not reach. Use DAST continuously and a penetration test before major releases, after significant architectural change or when a customer or regulation requires independent testing.
Do open-source tools work, or do we need commercial ones?
Open-source tools are a solid start: there are established options for SAST rules, dependency checking and web scanning, many listed on OWASP's pages. Commercial tools usually add broader language support, better triage, dashboards and support. Start with what your platform already offers, measure how many findings developers act on, and pay for more only when the gap is clear.










