Adding a security job to a pipeline is a start. The more important question is whether it examines the software your team delivers and gives someone enough information to act. A green pipeline can include an empty report, a skipped analyzer, or a scan of an image that never reaches production.
Begin with applications whose teams can help you follow a finding from the scan to a decision. Use what you learn to choose coverage, improve feedback, and prepare a wider rollout. If scans already run throughout your organization, the same approach can help explain why reports are missing or why developers aren't acting on them.
Start with the applications, not a list of scanners
Work with application owners to identify what each service contains and how it reaches users. Note its languages, package managers, container images, deployment targets, and any independently maintained release branches. Include the shared libraries and build configuration that affect it. An existing service inventory is a good starting point; you don't need a separate security spreadsheet if the information already has an owner.
Then choose checks for the problems those applications could have. Static analysis looks for weaknesses in source code. Dependency scanning checks the packages the application uses, while container scanning examines the image being delivered. Secret detection looks for exposed credentials. Dynamic testing examines a running application, where authentication and access to the intended routes matter as much as starting the scanner.
For example, a containerized web service may need all of those checks, while a library has no running web application for DAST to visit. The library still needs dependency and source checks, and a way to assess what consumers receive. Use the supported languages and package formats in each scanner's documentation to confirm the fit rather than assuming one successful job covers the whole repository.
Choose a manageable group of applications that includes the differences likely to affect the rollout. A large monorepo, an application using private packages, and a project with restricted runner connectivity can reveal different problems. Include an application owner, someone who maintains the pipeline, and someone who can help interpret security findings. You want to learn how the work reaches a resolution, not just how long the scanner takes.
Make the first results something you can trust
Introduce the chosen scanners through reviewed pipeline changes. Basic SAST and pipeline secret detection can provide downloadable reports across GitLab tiers; other scanners and the integrated review experience have their own availability requirements.1
Follow a completed job through to its report. Check which files, packages, or image it examined and which commit produced the result. In a monorepo, compare the packages in the report with the applications you intended to cover. For containers, confirm the scan used the image your release process will deliver, not an older image under a reused tag.
When enabling secret detection for an established repository, include a historic scan. Routine pipeline scanning isn't a substitute for examining earlier history. Use a non-working test credential when checking the detection path; there's no reason to expose a real secret to prove a scanner can find one. If the scan finds a live credential, arrange revocation or rotation as well as removing it from code.
Try a known finding in a test branch or representative test project and follow it into the report. Then correct it and compare the results. Also inspect what happens when a required input is unavailable, such as an image the job can't pull. Readers should be able to distinguish a completed scan with no findings from a scan that never examined its target. A passing pipeline alone doesn't make that distinction.
For new dependency-scanning setups, use GitLab's SBOM-based approach rather than copying an older Gemnasium configuration.2 Check that the generated inventory includes the packages you expect, including indirect dependencies. Keep the SBOM associated with its build or release so a future advisory can lead you back to the affected software. The inventory tells you what was found; it doesn't establish that those components are safe.
Put feedback where a team can act on it
Merge request scans help the author examine a proposed change. Default-branch scans help the team track problems in the code it has accepted. Configure both where they serve those purposes, and inspect the actual pipelines rather than assuming a scanner include runs for every event. For example, SAST runs in branch pipelines by default; merge request scanning needs to be enabled separately.
Check the source and target reports used by the merge request comparison. If the target has no comparable result, a reader may be unable to tell whether a finding came from this change or was already present. Restore the missing coverage before using that comparison to decide whether the change introduces a problem.
Make the result easy to find during review. GitLab's integrated security reports bring findings into the merge request and pipeline views.3 If your team reviews artifacts directly, agree on where the review outcome and follow-up issue will be recorded. A downloadable file is available information, but it isn't a triage process by itself.
New advisories can affect applications that haven't changed. Decide how those applications will be reassessed. GitLab's continuous dependency scanning can reassess supported SBOM components when advisory data changes; other checks may need scheduled pipelines.2 For long-lived releases, check that the chosen process covers the versions still in use rather than only the default branch.
Give scans the access and capacity they need
Run the pilot on the runner setup teams will actually use. Look at time waiting for a runner, scan duration, memory use, and repeated downloads. A scanner that works on a small project may time out on the largest repository. Adding concurrent scans can also slow unrelated jobs if they all compete for the same capacity.
For restricted networks, list the analyzer images, package repositories, advisory data, and application endpoints each job needs. Decide which resources should be mirrored internally and who will keep them current. A reachable analyzer image isn't enough if the scan then waits for a package registry it can't access. GitLab's offline scanner guidance explains the additional setup for restricted Self-Managed environments.
Treat dynamic scans as interaction with an application, not just another file check. Use a target intended for security testing, appropriate test accounts, and data that can tolerate the scan's actions. Confirm that authentication succeeded and that the scanner reached the routes you meant to test. A report from the login page doesn't tell you much about the application behind it.
When reducing scan time, examine what a proposed exclusion would omit. Generated files, vendored code, shared packages, and build outputs aren't interchangeable. An exclusion should have a reason that the next maintainer can understand. Keep a broader check where selective scanning would otherwise leave a release without the coverage it needs.
Work through findings while the rollout is still small
Review the first findings with the people who will handle them. Can the developer identify the affected code or package? Can they find repair advice that fits their framework? Who can help when the finding looks wrong, and who decides whether an unresolved risk can be accepted? These conversations often reveal more work than adding the pipeline job did.
Give urgent new findings a route to attention while the team works through the initial backlog. Enabling several scanners at once can reveal years of accumulated problems. That shouldn't leave a newly exposed credential waiting behind older findings simply because they were reported first.
Agree who restores failed scanning as well as who fixes application code. A missing report may be a pipeline-maintenance problem, not something the developer can solve by editing the flagged file. Keep the failure visible until coverage returns. The vulnerability-management recommendation explains how to carry findings through investigation, repair, and closure.
Expand coverage with the teams who will maintain it
Use the pilot to produce maintained configuration and a short explanation of how teams use the results. Describe the supported project types, the inputs teams need to provide, and where to ask for help. A versioned CI/CD component or shared configuration can make adoption easier, provided someone owns updates and checks them against representative consumers.
Distribution and enforcement need separate decisions. A normal pipeline include can be changed or removed by the project. If a scan must run independently of the application's configuration, GitLab security policies can enforce supported scans or additional pipeline jobs.4 Security policy from observation to enforcement explains how to introduce those requirements without confusing scan failures with approval decisions.
Expand to the next group of applications when the people operating scans and handling findings can support them. Look at incomplete scans, time to first review, repeated false positives, and developer waiting time alongside the number of projects enrolled. Those observations tell you whether to improve the configuration, add capacity, clarify ownership, or continue the rollout.
Revisit coverage when a team changes language, packaging, release strategy, or network access. A project that was well covered last month can add a service the old configuration never examines. Keep that discussion part of ordinary application and pipeline maintenance, rather than waiting for an annual security review to discover the gap.
Further Reading
Notes
-
Basic SAST and pipeline secret detection provide scanning and report artifacts on all tiers. GitLab Advanced SAST, dependency scanning, and DAST are available in Ultimate. Check the scanner's availability when choosing how to cover a particular application. ↩
-
Dependency scanning using SBOM and continuous dependency scanning are available in Ultimate. SBOM-based scanning is the recommended path for new projects; continuous scanning reassesses components from the default branch's latest successful pipeline as advisory data changes. ↩ ↩2
-
Integrated security reports and the vulnerability report are available in Ultimate. They bring findings into review and provide a shared place to track them; reviewing downloaded artifacts requires your own follow-up process. ↩
-
Security policies are available in Ultimate. Scan execution policies enforce supported scans, while pipeline execution policies can apply custom scanning jobs and other required pipeline configuration. ↩
- Choose application security checks to find the scanner documentation for your languages, packages, and running applications.
- Configure SAST and pipeline secret detection when adding initial coverage.
- Enable security scanning in merge request pipelines to put findings into the change-review workflow.
- Interpret security scanning results when checking reports, comparisons, and retention.
- Move to SBOM-based dependency scanning when updating an existing Gemnasium setup.
- Configure scanners for offline environments when analyzer images and advisory data need an internal distribution path.