GitLab CI step by step
A numbered path from a token to merge requests blocked by real findings, then every variable, tested recipes and GitLab-specific troubleshooting.
This guide takes a GitLab project from nothing to ScanSuite scans that gate merge requests and the default branch. Follow the numbered steps the first time; the variables, recipes and troubleshooting after them are reference. Every option of the client is in CI/CD and automation.
Pipeline scans use the team API, which is part of ScanSuite Teams.
If you know GitLab CI already, this is all of it. Add four CI/CD variables (Settings → CI/CD → Variables): SCANSUITE_URL, SCANSUITE_TEAM (the name the Automation and API tokens card shows), SCANSUITE_PRODUCT, and SCANSUITE_TOKEN (Masked, Protect variable cleared). Include the template from your server:
include:
- remote: '<YOUR_SCANSUITE_URL>/ci/scansuite.gitlab-ci.yml'Then turn on Settings → Merge requests → Merge checks → Pipelines must succeed.
The screenshots and the tested results at the end come from a run on GitLab CE 19.4 (self-managed) with a self-hosted runner, against a sample Flask application with known problems: SQL injection, command injection, path traversal, vulnerable dependencies and a committed GitHub token.
What you get
A GitLab job runs the ScanSuite CI client from the image appsec4u/scansuite-ci:1. It uploads the files Git tracks, starts a scan on your ScanSuite server and waits for it, so the runner needs no scanners and little memory. When the scan ends, the job passes or fails on the gate (by default: any High or Critical finding, or any secret new to the product).
| Result | What you get |
|---|---|
| The job passes | Nothing blocks. The findings are still in ScanSuite. |
| The job fails | The log lists every blocking finding and secret; the pipeline's Tests tab and the merge request show them as failed tests. |
| Reports | scansuite-junit.xml (GitLab test report), scansuite.json (summary) and scansuite.sarif, kept as job artifacts for 30 days. |
Before you start
| You need | How to check |
|---|---|
| ScanSuite: the Team admin role in a team | The Teams page says Your role in this team: Team admin. |
| A product for the findings | It is listed on the Products page, or let the pipeline create it (see Monorepo and new products). |
| For the default merge request job (quick-classic): the static scanner images on the server | On the ScanSuite server, in the installation directory, grep SCANSUITE_SCANNERS .env prints static or all. A default installation prints none; a system administrator runs ./scansuite update --static-only. Or use quick-ai (step 7). |
| For the default-branch job (standard-ai) and quick-ai: an AI provider for the team | Teams page, AI tab. After step 2, --list-scanners must not mark mlsast NOT AVAILABLE. |
| GitLab: the Maintainer role in the project | Settings → CI/CD is in the project menu. |
| A runner | Settings → CI/CD → Runners lists an Online runner with the Docker executor that runs untagged jobs, can pull appsec4u/scansuite-ci:1 from Docker Hub and reaches your ScanSuite server over HTTPS. Shared runners on GitLab.com qualify when the server is reachable from the Internet. |
Set it up
Step 1. Create a token in ScanSuite
The pipeline signs in with the token of a service account, not with a person's password. A service account belongs to the team and keeps working when people leave it.
- 01Open the Teams page
Teams in the sidebar, then the People tab. Scroll to Automation and API tokens. The line at the top of the card reads This team's name in pipelines and API addresses (SCANSUITE_TEAM), with the name in bold: that is the value of SCANSUITE_TEAM. The first team of an installation is default, whatever it was renamed to.
- 02Create a service account
Under New service account, type a name such as gitlab-ci, set Role to Operator (the default, Reader, cannot start scans) and select Create. Check: the account is listed with the role Operator and the badge Active.
- 03Issue a token
Select New token on the new account. Fill in Token name (for example gitlab-backend), Valid for (days) (30 by default, at most 90), keep What can it do? on CI pipeline and select Create token. Check: the Your new token dialog opens.


The Your new token dialog shows the token with a Copy button, the row This team's name in pipelines and API addresses (SCANSUITE_TEAM), and Test the connection with two commands that already contain the server, the team and the token: With the pipeline client (Docker) and With curl.
Copy the token. It is shown once; keep it only until step 3 puts it in GitLab, and never paste it into a chat, a ticket or the repository. If you lose it, revoke it on the card and issue another.
The CI pipeline preset gives the token what a pipeline needs and nothing more: start and stop scans, see products, scans, findings and discovered credentials, download reports, and create products. Each token is listed with its expiry date; the job log warns when it expires within 14 days. The permission list is in CI/CD and automation.
Step 2. Test the token
Run these commands in your own terminal: the second one asks you to paste the token.
An agent asks you to run them and reads only the output, which contains no token.
export SCANSUITE_URL=<YOUR_SCANSUITE_URL> SCANSUITE_TEAM=<YOUR_TEAM>
read -rs SCANSUITE_TOKEN && export SCANSUITE_TOKEN
docker run --rm -e SCANSUITE_URL -e SCANSUITE_TEAM -e SCANSUITE_TOKEN appsec4u/scansuite-ci:1 --checkExpected: Connected to … the server accepts the API token for team … (role operator), the token's permissions and expiry, and The token can run pipeline scans. A refused token ends with exit code 3 and the reason: expired, revoked, service account deactivated, team not active, unknown token, or a token of another team (the message then names the team to set). The fix for each is in CI/CD and automation. Add --list-scanners instead of --check to see which scanners your team can run.
Step 3. Add the CI/CD variables in GitLab
In the GitLab project: Settings → CI/CD → Variables → Add variable, once for each variable:
| Key | Value | Visibility and flags |
|---|---|---|
| SCANSUITE_URL | The address of your ScanSuite server, for example https://scansuite.example.com | Visible |
| SCANSUITE_TEAM | The team name from the Automation and API tokens card (step 1), or from the new-token dialog. | Visible |
| SCANSUITE_PRODUCT | The product's exact name, as on the Products page. Or SCANSUITE_PRODUCT_ID with its number. | Visible |
| SCANSUITE_TOKEN | The token from step 1. | Masked, Protect variable cleared |
Add SCANSUITE_TOKEN yourself, with Masked set and Protect variable cleared.
An agent tells you which variables to add and waits.

GitLab ticks Protect variable by default. A protected variable reaches only pipelines on protected branches and tags, so every merge request from an ordinary branch fails with Set SCANSUITE_TOKEN ... and exit code 3. Protect it only if every pipeline that scans runs on a protected branch or tag.

Check: the project's CI/CD variables list the four keys, and only SCANSUITE_TOKEN shows as masked. Variables set here apply to every job and win over variables written in .gitlab-ci.yml; see Monorepo and new products for what that means when one job reports to another product.
Step 4. Check the runner
Settings → CI/CD → Runners lists the runners the project can use. One of them must be Online, use the Docker executor, and run untagged jobs. If your runners only take tagged jobs, add the tag to the template's hidden job in your .gitlab-ci.yml:
.scansuite:
tags: [docker]
Step 5. Add the pipeline
Your ScanSuite server serves a GitLab CI template that always matches its version. Add this to .gitlab-ci.yml in the root of the repository (create the file if the project has none), with your server's address, and commit it to the default branch. The push starts the first pipeline.
include:
- remote: '<YOUR_SCANSUITE_URL>/ci/scansuite.gitlab-ci.yml'| Job the template adds | Runs on | Scan |
|---|---|---|
| scansuite-merge-request | Every merge request | quick-classic (rule-based Semgrep, no AI) on the files the merge request changes |
| scansuite-default-branch | Every push to the default branch | standard-ai (AI SAST with reachability, secrets with AI verification, dependency checks) on the whole repository |
Add ScanSuite to this repository's .gitlab-ci.yml by following https://scansuite.eu/documentation/reference/gitlab-ci: include the template from our ScanSuite server, use quick-ai for merge requests if our team has AI set up, and list the CI/CD variables I must add. Stop at every step marked "A person does this step". Never ask me for the token: I will add SCANSUITE_TOKEN myself as a masked, unprotected variable.Paste it into Claude Code or another coding agent. See Working with AI agents.
Your pipeline already has stages? Keep them and add test if it is missing: the template's jobs run in the test stage. If you would rather not include a remote file, copy the template's content from the same address into your repository; AI SAST reports an unpinned remote include as a Medium finding.
Check: Build → Pipelines shows a new pipeline with the job scansuite-default-branch. The last [scansuite] lines of its log are either Quality gate passed or Quality gate FAILED: N blocking finding(s), M blocking secret(s). Any other ending is in Troubleshooting.
Step 6. Check the result
Open Build → Pipelines, the newest pipeline, then the job. The end of its log says what the scan found and why the job failed:


| Log line | Meaning |
|---|---|
| Team default, product shop-api (#8) | The team and product the job reports to. |
| Scan jfzyghvb (#95) Queued … Finished | The scan's reference; search for it in ScanSuite. |
| Open findings in this scan: Critical 1, High 2, … | Everything the scan reported. |
| BLOCKING [Critical] OS command injection -- app.py::host (Reachable) | One line per finding that fails the gate, with the file, the code location and the reason. |
| BLOCKING [Secret] github_token -- …/settings.py#L3 | A secret that blocks, with a link to the file in GitLab. |
| Quality gate FAILED: 3 blocking finding(s), 1 blocking secret(s) | The verdict. |
| Exit code 1: the quality gate failed … | Why the job failed. GitLab always prints exit code 1 below it; this line has the real code. |
The pipeline's Tests tab shows each blocking finding as a failed test, per job. Download or Browse under Job artifacts on the job page gives the JSON and SARIF reports.

In ScanSuite, the pipeline's scan is an ordinary scan of the product: it appears in Scan History under the name of the project's archive, and its page lists what it found. Findings link to the file and line in GitLab at the scanned commit. Triage there as usual: the gate counts only findings that are Open or In Progress, so a finding you close as a false positive or accepted risk no longer fails the next pipeline.


Step 7. Gate merge requests
A failed job blocks merging only when the project asks for it.
In GitLab, turn on Settings → Merge requests → Merge checks → Pipelines must succeed, and save. It changes how every merge request in the project is merged, so the project's maintainers decide it.

Check: a merge request whose pipeline failed shows the blocking findings as failed tests and cannot be merged until a pipeline passes.

If your team has AI set up, make quick-ai the merge request gate: in the test it caught code execution that the rule-based quick-classic missed (see Tested results). Both scan only the changed files; secrets and dependency checks need the whole repository and run on the default branch.
include:
- remote: '<YOUR_SCANSUITE_URL>/ci/scansuite.gitlab-ci.yml'
scansuite-merge-request:
variables:
SCANSUITE_PROFILE: quick-aiVariables
Set a variable on one job under variables:, or for every job in Settings → CI/CD → Variables (project variables win over job variables). Gate options, bundles and every other option are described in CI/CD and automation.
| Variable | Default in the template | What it does |
|---|---|---|
| SCANSUITE_URL, SCANSUITE_TEAM, SCANSUITE_TOKEN | — | The server, the team name and the token (step 3). |
| SCANSUITE_PRODUCT or SCANSUITE_PRODUCT_ID | — | The product, by exact name or number. |
| SCANSUITE_CREATE_PRODUCT | off | 1 creates SCANSUITE_PRODUCT on the first run. |
| SCANSUITE_PROFILE | quick-classic on the merge request job, standard-ai on the default-branch job | The bundle; for DAST quick, standard or deep. |
| SCANSUITE_CHANGED_ONLY | 1 on the merge request job | Scan only the changed files. |
| SCANSUITE_BASE | the merge request target | What --changed-only compares with. |
| SCANSUITE_SCAN_TYPE | sast | dast or infra for the recipes below. |
| SCANSUITE_TARGETS | — | DAST URLs, or infrastructure hosts and images. |
| SCANSUITE_PORTS | All TCP | Infrastructure ports, such as Top 1000 TCP/UDP. Use this variable, not SCANSUITE_EXTRA_ARGS, because the value contains spaces. |
| SCANSUITE_FAIL_ON_SEVERITY | high | Lowest blocking severity; none turns it off. |
| SCANSUITE_MAX | — | Allowed findings per severity, such as high=0,medium=10. |
| SCANSUITE_BLOCK_CLASS | — | Classes that block at any severity. |
| SCANSUITE_MIN_CONFIDENCE | any | reachable: only findings confirmed reachable block. |
| SCANSUITE_FAIL_ON_SECRETS | new | new, all or none. |
| SCANSUITE_SOURCE, SCANSUITE_GIT_URL, SCANSUITE_BRANCH | auto, the project, the pipeline branch | Let the server clone instead of uploading (see Large repository). |
| SCANSUITE_TIMEOUT | 7200 | Seconds the client waits for the scan. |
| SCANSUITE_IDEMPOTENCY_KEY | derived from the GitLab job | Rarely needed: GitLab jobs are told apart by instance, project and start time. |
| SCANSUITE_CA_BUNDLE, SCANSUITE_STRICT_TLS | —, off | A path in the repository to your CA certificate; 1 stops on a certificate the runner cannot verify. |
| SCANSUITE_EXTRA_ARGS | empty | Any other client option, such as --report-zip scansuite-report.zip or --include-unreachable (which has no variable). It is split on spaces with no quoting, so a value that contains spaces needs its own variable. |
| GIT_DEPTH | 50 | Clone depth. The client fetches the merge request target if the clone lacks it. Set "0" for full-ai and other Git history scans. |
The template's hidden .scansuite job runs in the test stage with the image appsec4u/scansuite-ci:1, writes scansuite-junit.xml (published as the test report), scansuite.json and scansuite.sarif, and keeps them for 30 days.
Choose what to scan, and when
| Trigger | Without AI | With AI |
|---|---|---|
| Merge request | quick-classic | quick-ai |
| Default branch | standard-classic | standard-ai |
| Nightly or release | full-classic | full-ai (slowest, the highest AI cost) |
Set the bundle with SCANSUITE_PROFILE on a job. To tune what fails the job, see When the build fails; for single scanners and AI options, see Static analysis.
The first scan of a product sees every secret as new. A job that creates the product, or the first scan of an existing repository, fails on secrets already committed. Triage them in ScanSuite, or start with SCANSUITE_FAIL_ON_SECRETS: none.
Recipes
Each recipe is a job to add to .gitlab-ci.yml under the include. Jobs extend the template's hidden .scansuite job, which brings the image, the reports and the artifacts.
| Goal | Job | Key variables | Recipe |
|---|---|---|---|
| Scan the deployed application and the built image | scansuite-dast, scansuite-image | SCANSUITE_SCAN_TYPE, SCANSUITE_TARGETS | DAST and container image scans |
| Everything, every night | scansuite-nightly | SCANSUITE_PROFILE: full-ai, GIT_DEPTH: "0", SCANSUITE_MAX | Nightly full scan |
| A strict gate on release tags | scansuite-release | SCANSUITE_MIN_CONFIDENCE: reachable, SCANSUITE_FAIL_ON_SECRETS: all | Release gate on tags |
| One product per service, created on the first run | scansuite-services | SCANSUITE_EXTRA_ARGS with --product-name and --create-product | Monorepo and new products |
| Report without blocking anyone | scansuite-default-branch | SCANSUITE_FAIL_ON_SEVERITY: none | Roll out without blocking |
| A large repository the server clones | scansuite-incremental | SCANSUITE_SOURCE: git, --mode incremental | Large repository |
| No remote include | scansuite | — | Without the template |
DAST and container image scans
When: after the deployment to staging and after the image build, in a later stage. needs: [] lets them start even when a static scan failed the build; without it GitLab skips them.
stages: [test, verify]
scansuite-dast:
extends: .scansuite
stage: verify
needs: []
variables:
SCANSUITE_SCAN_TYPE: dast
SCANSUITE_TARGETS: https://staging.example.com
SCANSUITE_PROFILE: quick
SCANSUITE_FAIL_ON_SEVERITY: critical
rules:
- if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH && $CI_PIPELINE_SOURCE != "merge_request_event"
scansuite-image:
extends: .scansuite
stage: verify
needs: []
variables:
SCANSUITE_SCAN_TYPE: infra
SCANSUITE_TARGETS: registry.example.com/shop/api:$CI_COMMIT_SHORT_SHA
SCANSUITE_EXTRA_ARGS: --scanners docker_image_scan
SCANSUITE_FAIL_ON_SEVERITY: critical
rules:
- if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH && $CI_PIPELINE_SOURCE != "merge_request_event"Expected log line: Quality gate passed, or Quality gate FAILED: … with one BLOCKING line per Critical finding. Caveat: the targets must be allowed for the team (Teams page, Scanning tab, Web targets and Infrastructure targets); otherwise the job stops with exit code 3 before a scan starts, naming the refused target.
Nightly full scan
When: a scheduled pipeline. Create the schedule in Build → Pipeline schedules, then add the job. full-ai analyses Git history, so the job fetches all of it.
scansuite-nightly:
extends: .scansuite
timeout: 4h
variables:
SCANSUITE_PROFILE: full-ai
GIT_DEPTH: "0"
SCANSUITE_MAX: high=0,critical=0,medium=10
SCANSUITE_TIMEOUT: "14400"
rules:
- if: $CI_PIPELINE_SOURCE == "schedule"
Expected log line: a blocking Medium finding over the budget reads Medium: 12 found, 10 allowed. Caveat: GitLab stops a job at its own timeout (one hour by default, shown as Timeout on the job page) before SCANSUITE_TIMEOUT is reached, hence timeout: 4h on the job; the runner's own limit still applies.
Release gate on tags
When: a tag is pushed. Stricter than the merge request gate, limited to what is reachable, counting every secret the product has, and keeping the full report with the release.
stages: [test, release]
scansuite-release:
extends: .scansuite
stage: release
variables:
SCANSUITE_PROFILE: standard-ai
SCANSUITE_FAIL_ON_SEVERITY: medium
SCANSUITE_MIN_CONFIDENCE: reachable
SCANSUITE_FAIL_ON_SECRETS: all
SCANSUITE_EXTRA_ARGS: --report-zip scansuite-report.zip
artifacts:
when: always
paths: [scansuite-report.zip, scansuite.json]
rules:
- if: $CI_COMMIT_TAG
Expected: the job artifacts list scansuite-report.zip. Caveat: all counts secrets earlier scans already knew, so a release fails until every open secret is triaged.
Monorepo and new products
When: one job per service folder, each reporting to its own product, created on the first run. Pass the product as an option: a SCANSUITE_PRODUCT variable in the job would lose to the project's variable from step 3, and every service would report to the same product.
scansuite-services:
extends: .scansuite
parallel:
matrix:
- SERVICE: [payments, web]
variables:
SCANSUITE_PROFILE: quick-classic
SCANSUITE_CHANGED_ONLY: "1"
SCANSUITE_EXTRA_ARGS: --source-dir services/$SERVICE --product-name $SERVICE --create-product
rules:
- if: $CI_PIPELINE_SOURCE == "merge_request_event"For a single new repository, set it once on the hidden job so every job inherits it (or set SCANSUITE_CREATE_PRODUCT to 1 next to SCANSUITE_PRODUCT in the project's variables):
.scansuite:
variables:
SCANSUITE_EXTRA_ARGS: --product-name $CI_PROJECT_NAME --create-productExpected log line: Created product payments (#10) on the first run, then Team default, product payments (#10) on every run. Caveat: a job that sets its own SCANSUITE_EXTRA_ARGS replaces the hidden job's value, so repeat both options there.
Roll out without blocking
When: the team is getting used to the results. Scan and publish the reports, but never fail the pipeline:
scansuite-default-branch:
variables:
SCANSUITE_FAIL_ON_SEVERITY: none
SCANSUITE_FAIL_ON_SECRETS: noneTo keep failing on findings but not on a ScanSuite outage, set SCANSUITE_EXTRA_ARGS: --soft-fail instead. Expected log line during an outage: WARNING: --soft-fail: exiting 0 instead of 5.
Large repository: let the server clone it
When: uploading the checkout is slow. The ScanSuite server clones the branch itself; with --mode incremental it then scans only what changed since its last scan of that branch.
- 01Make a key pair for ScanSuite
Without a passphrase: ScanSuite refuses a key protected by one. Use it only for this.
Shellssh-keygen -t ed25519 -N "" -f scansuite-deploy - 02Give GitLab the public half
In the project: Settings → Repository → Deploy keys → Add new key, with the content of scansuite-deploy.pub. Leave write access off.
- 03Give ScanSuite the private half
Teams page → Scanning tab → Team SSH key: paste the content of scansuite-deploy into Private key and select Save. Check: the card shows the key's fingerprint. Then delete the file.
- 04Add the job
With the SSH address of the project. A GitLab whose SSH port is not 22 needs the ssh:// form with the port, as below.
Pasting the private key into ScanSuite is a step for a team admin or operator.
An agent never handles the private key.

scansuite-incremental:
extends: .scansuite
variables:
SCANSUITE_SOURCE: git
SCANSUITE_GIT_URL: ssh://git@gitlab.example.com:2222/$CI_PROJECT_PATH.git
SCANSUITE_PROFILE: standard-ai
SCANSUITE_EXTRA_ARGS: --mode incremental
rules:
- if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCHExpected log line: Source: ssh://…/shop-backend.git @ main (the server clones the branch head, not necessarily …); on a run with no new commits, Nothing to scan: … and the job passes. Caveats: pipeline scans always clone with the Team SSH key, never a person's own key. The server scans the branch as it is when the scan starts, which can be newer than the pipeline's commit. It trusts the Git server's SSH host key on the first clone and refuses a changed key afterwards: if GitLab is reinstalled or moved, clones stop with could not resolve the remote revision: @@@@… until a ScanSuite administrator removes the old key from /var/tmp/scansuite/git-auth/known_hosts in the worker container. More on keys in Git repository authentication.
Without the template
When: you cannot include a remote file. Clear the image's entrypoint, because GitLab runs its own shell in the container:
scansuite:
stage: test
image:
name: appsec4u/scansuite-ci:1
entrypoint: [""]
variables:
GIT_DEPTH: "50"
script:
- scansuite-ci --profile quick-classic --changed-only --junit scansuite-junit.xml --sarif scansuite.sarif
artifacts:
when: always
reports: { junit: scansuite-junit.xml }
paths: [scansuite.sarif]
rules:
- if: $CI_PIPELINE_SOURCE == "merge_request_event"The same recipes are in the GitLab examples of the scansuite-ci repository.
Troubleshooting
GitLab ends every failed job with ERROR: Job failed: exit code 1, whatever went wrong. The client's last [scansuite] line has the real exit code; the codes are explained in CI/CD and automation.

| Message or symptom | Cause and fix |
|---|---|
| Set SCANSUITE_TOKEN ... | The token did not reach the job. It is Protected and the pipeline runs on an unprotected branch (step 3), or the variable is missing. |
| The server rejected the API token … | The message gives the reason: expired, revoked, deactivated, another team, unknown. Run the test in step 2. |
| Product 'X' was not found in team Y | SCANSUITE_PRODUCT does not match a product name exactly, or SCANSUITE_TEAM is wrong. Add --create-product to create it. |
| The API token lacks permission(s): ... | The token was issued without the CI pipeline preset, or the service account is a Reader. Issue a new token. |
| Cannot run on this server: openvas: ... | The scanner is not set up for your team; the message says where to set it up. |
| Findings land in the wrong product | A job sets SCANSUITE_PRODUCT, but the project's variable wins. Pass --product-name in SCANSUITE_EXTRA_ARGS. |
| --changed-only: no base to compare with | Not a merge request pipeline, or the clone lacks the target branch. The job then scans everything. |
| This is a shallow clone, so Git history analysis sees only ... | Set GIT_DEPTH: "0" on full-ai and other Git history scans. |
| A later-stage job was skipped | A scan in an earlier stage failed. Give the job needs: []. |
| The job ends as Timeout | GitLab's job timeout (one hour by default) came first. Add timeout: 4h to the job. |
Cancelling a job cancels its scan. When you cancel the pipeline in GitLab, the client stops the scan in ScanSuite before the job ends (Cancelled scan … (pipeline interrupted)). When the client itself stops waiting (SCANSUITE_TIMEOUT, exit code 4), the scan keeps running unless you add --cancel-on-timeout.
Tested results
What each setup did on the sample application in the 2026-10-03 run. Times depend on the code base and the AI provider.
| Setup | Bundle | Time | Result |
|---|---|---|---|
| Template default-branch job | standard-ai | About 3 minutes | Failed on 3 reachable findings (the injections and the path traversal) and 1 verified secret. |
| Default branch without AI | standard-classic | 3 to 4 minutes | Failed on 15, including the same injections found by several rules and the vulnerable pyyaml, flask, jinja2 and requests versions. |
| Merge request adding pickle.loads and eval | quick-classic | About a minute | Passed: the rule-based rules matched neither line. |
| The same merge request | quick-ai | About 30 seconds | Failed with two Critical findings: insecure deserialization and code execution through eval. |
| Gate tuned to critical plus blocked classes | standard-ai | — | Still failed on the High SQL and command injections, marked blocked class sql_injection. |
| DAST and container image scans | quick; docker_image_scan | — | DAST passed (High and Medium issues, below its critical threshold); the image failed on 9 Critical CVEs in python:3.8-slim. |
| Nightly full scan | full-ai | 7 to 25 minutes | 2 Critical, 3 High and 2 Medium: the 5 High and Critical failed the job, the Medium stayed within the budget. |
| Release gate | standard-ai | — | Failed on six reachable findings down to Medium, including an SSH ingress open to the Internet in main.tf and the unpinned remote include, plus the known GitHub token. |
| Monorepo, a merge request touching both services | quick-classic | — | The payments job failed on a SQL injection, the web job passed: the merge request was blocked by one service. |
| Soft fail, server unreachable | — | About a minute of retries | Logged --soft-fail: exiting 0 instead of 5; the job passed. |
| Server clone, incremental | standard-ai | 13 seconds on the second run | The first run scanned the whole branch; the second found no new commits and passed. |
| AI scanners one at a time | mlsast with every option | Under 4 minutes | AI SAST failed on 2 Critical and 3 High; reachable dependencies only: passed (no vulnerable dependency was reachable); verified new secrets only: passed (the secret was already known). |
Last reviewed 2026-10-19