Static analysis · Software composition analysis

SAST and SCA where developers merge.

VamiAppSec runs static code analysis with Semgrep and an LLM review for business-logic flaws, scans direct and transitive dependencies with Grype and Trivy and catches secrets and IaC misconfigurations — on every commit, as SARIF in the IDE and the pull request, with quality gates that block critical findings before they are merged.

Semgrep + LLM
SAST rules plus semantic review
Grype · Trivy
SCA for direct and transitive dependencies
PR · build gate
Critical findings blocked before merge
What static testing has to cover

Code, dependencies, secrets and infrastructure.

Most vulnerabilities enter a product long before it runs. Four sources need to be checked on every change:

SAST

Your own code

Injection, broken access control, insecure cryptography and business-logic flaws in the code your team writes — found while the change is still in review.

SCA

Open-source dependencies

Direct and transitive libraries with known vulnerabilities, matched against NVD, OSV, EPSS and CISA KEV.

Secrets

Credentials in Git

API keys, tokens and certificates committed by accident — caught in pre-commit and CI before they ship.

IaC and containers

Infrastructure as code

Misconfigurations in infrastructure-as-code templates and container images, checked with Checkov and Trivy.

How VamiAppSec covers it

One backlog, every scanner.

Each scan type runs at the pipeline stage where it fits — and every result lands in the same deduplicated backlog.

Scan typeHow VamiAppSec runs itWhat you get
SAST code stageSemgrep rules on every commit, plus a semantic review by the LLM for business-logic flaws.Findings as SARIF in the IDE and the pull request
Secrets pre-commit and CIGitleaks in pre-commit hooks and in the pipeline.Hits with age, exposure and rotation guidance
SCA build stageGrype and Trivy match direct and transitive dependencies against NVD, OSV, EPSS and KEV.Dependency findings with VEX statements
IaC and containers build stageCheckov and Trivy check infrastructure code and container images.Misconfigurations found before deployment
Enrichment LLMEach finding gets a plain-language explanation, an exploitability assessment and a fix written for your stack.Fix suggestion right in the pull request
Tracking and evidence DefectDojoDeduplicated and fingerprinted in DefectDojo, synced to Jira, Azure DevOps Boards or ServiceNow and mapped to OWASP ASVS 5.0.ASVS coverage per chapter and level
Gates in the pipeline

Block what is critical, let the rest flow.

Gates sit where a change is still cheap to fix. Critical findings stop the merge; regressions soft-fail, so teams keep shipping.

01

Commit

Pre-commit hooks run secrets scanning; SAST results show up as SARIF directly in the IDE.

02

Pull request

The PR gate runs SAST and secrets scanning; findings and a drafted fix appear as comments in the pull request.

03

Build

The build gate runs SCA, IaC and container scans and checks the SBOM for completeness.

04

Track

Everything lands deduplicated in DefectDojo or your tracker — with SLAs, risk acceptance and an audit trail.

Where the gates sit
PRSAST and secrets scanning
BuildSCA, IaC, containers and SBOM completeness
ReleasePolicy, VEX and evidence before shipping

Block on critical findings, soft-fail on regressions — defined as policy-as-code.

Where your code is analysed

Your source code stays in Germany.

SaaS on T Cloud Public

German data centers operated by Deutsche Telekom — EU jurisdiction, GDPR by design.

On-prem on your Kubernetes

Scanners, DefectDojo and the LLM on your own cluster, air-gapped if needed — your code never leaves your network.

Local LLM review

The LLM review can run on Qwen3.8 in Sankt Augustin or on your own GPUs — no third-country API, and your code is never used for AI training.

Every LLM call is logged with model version, prompt and output, and fix suggestions go through your normal code review — the model advises, your developers decide.

FAQ

SAST and SCA, answered.

What is the difference between SAST and SCA?

SAST analyses the code your team writes for vulnerabilities such as injection or broken access control. SCA checks the open-source and third-party components you use for known vulnerabilities. VamiAppSec runs both in the same pipeline and tracks the results in one backlog.

Which tools does VamiAppSec use for SAST and SCA?

Semgrep for SAST with a semantic review by the LLM, Grype and Trivy for SCA, Gitleaks for secrets and Checkov and Trivy for IaC and containers. You don't have to operate them yourself — VamiAppSec orchestrates them.

How does the LLM review help?

Rules find known patterns. The LLM review looks for business-logic flaws that rules cannot express and enriches every finding with a plain-language explanation, an exploitability assessment and a fix written for your stack.

Will critical findings block our merges?

If you want them to: the PR gate can block merges on critical findings while regressions only soft-fail. Results are attached to the pull request as SARIF.

Which CI/CD platforms are supported?

Native integrations for GitLab, GitHub and Azure DevOps — pipeline templates, PR/MR checks and quality gates — plus Bitbucket and Jenkins. Results are also available as SARIF and via a REST API.

How do the results map to OWASP ASVS?

SAST, DAST and review findings are mapped to OWASP ASVS 5.0 requirements, with coverage per chapter and verification level L1–L3 — useful for customer assessments and audits.

See SAST and SCA in 30 minutes.

We connect a sample repository, run SAST, SCA, secrets and IaC scans and show you the findings in the pull request, the DefectDojo board and an OWASP ASVS coverage report.

No credit card · SaaS from Germany or on-prem on Kubernetes · SaaS live in 24h