A scanner can find a vulnerable dependency in minutes. Getting it fixed can take much longer: the finding waits for triage, moves between teams, and eventually reaches a release whose connection to the original report isn't clear. Adding more scanners won't resolve those delays.
Build the process around the decisions people need to make. A finding should lead to an owner, a reason for its priority, and either remediation or a clear decision to accept the risk. Closure should tell the next person what changed, not just that a ticket was closed. This approach works whether you're introducing scanning or trying to make an existing backlog manageable.
Start with results people can use
Choose scanners for the software you deliver: its languages, dependencies, container images, and running services. Then look at a recent result with someone who knows the application. Can they identify the affected code or package, understand the reported weakness, and find the pipeline and commit that produced it? If not, improve that connection before expanding scanning across more projects.
Check coverage as well as findings. A scanner that doesn't support a language, excludes an important directory, or examines an old container image can produce a successful job without answering the question you intended. Failed, skipped, or missing scans need attention from whoever maintains scanning; they aren't clean results. If you need to establish or repair that setup, establish security scan coverage explains how to choose checks, run them in the right pipelines, and keep them working as adoption grows.
GitLab's vulnerability report gives teams a place to review findings and connect them with follow-up work.1 Without that view, you can use issues and merge requests alongside downloadable scanner reports. Basic SAST, pipeline secret detection, and container scanning provide reports on Free and Premium; other scanners have their own availability and setup requirements.2 Agree where decisions will be recorded so nobody has to reconcile a security spreadsheet with an unrelated development backlog.
When tracking a finding in an issue, include the affected application, file or component, scanner or report source, relevant commit, and a link to the report. Add the decision and repair work as they happen. Keep enough detail to revisit the finding after job artifacts expire, using access appropriate for the information. An issue can contain a redacted description of an exposed credential without copying the credential itself.
Make room for new findings while reducing the backlog
The first scans often reveal years of accumulated work. Trying to assign every result the same deadline can leave teams spending more time negotiating dates than reducing risk. Start with applications where a compromise would matter most, then work through findings according to their exposure and likely impact.
For example, reviewing the exploitable weaknesses in a customer-facing service gives the team a meaningful starting point. As it works through them, it may discover an unmaintained dependency, unclear ownership, or a scanner setting that needs correction. Fixing those problems makes the next group of findings easier to handle. Grouping work by a shared dependency upgrade or code change can also avoid asking a team to investigate the same cause repeatedly.
Keep capacity for new reports while that work continues. A newly disclosed vulnerability, a customer report, or a suspected compromise may need attention ahead of older findings. Give those reports an entry point and a person who can assess urgency. Suspected active exploitation should enter the incident-response process rather than wait for the next backlog review.
Agree separately on how quickly someone will assess a finding and how quickly the team aims to remediate it. The first decision may be urgent even when a fix needs coordination with a supplier or a scheduled release. If the target can't be met, someone needs to decide whether a temporary mitigation, escalation, or accepted risk is appropriate.
Set priority using the application, not just the severity
Read the finding and its advisory, then follow the affected component into the application. Establish which versions are in use, whether an attacker can reach the vulnerable behavior, and what a successful attack would allow. Exposure, known exploitation, sensitive data, and service importance help turn a scanner's severity into a work priority.
Consider a vulnerable parser used by both a public upload service and an internal reporting tool. The public service accepts untrusted files, so the attack path may be straightforward. The reporting tool may only process files produced by a controlled system, which changes the immediate exposure. That isn't a reason to dismiss it without investigation: another import path or a compromised upstream system might still reach the parser. Record the actual reason for the decision so the team can revisit it when usage changes.
Treat missing information as something to investigate, not a reason to lower priority. If nobody knows whether a vulnerable function is reachable, assign that question to someone familiar with the code. Likewise, a compensating control only helps if it covers the attack path and someone maintains it. “Internal application” doesn't explain whether an attacker could reach it.
The conclusion should tell the application team what to do next. For example: upgrade the affected library before the next release; disable an exposed feature while a fix is prepared; or investigate a suspected false positive and record why the rule doesn't apply. You don't need a lengthy scoring exercise for every finding, but a decision that departs from the apparent severity needs enough explanation for someone else to follow it.
Put the next action in someone's hands
Application teams usually know the code and release constraints. Security reviewers bring attack analysis and help decide the response. Platform or security engineering keeps scanning operational. Name the person or team responsible when work passes between them; sending a finding to a general security queue isn't enough if nobody accepts the next action.
In the vulnerability report, new records normally start at Needs triage. Use Confirmed when triage establishes that a finding needs further analysis or remediation, and connect it to the work that will follow. A dismissal needs a reason and a comment explaining the decision. If you track findings in issues instead, a small set of agreed labels can distinguish investigation, planned remediation, and an accepted risk. The labels help people find work; the issue explains the decision.
Give the person making the fix more than a scanner description. Include the affected behavior, how it affects the application, the intended response, and how the team will check it. When a fix spans projects or supported releases, one coordinating issue can link the separate changes and keep unfinished work visible. Keep links in both directions so the developer and security reviewer can find the same discussion.
In a small team, people will fill several roles. The important exception is a consequential risk decision: the person under pressure to ship shouldn't be its only reviewer. Agree who can accept that risk and who can step in when the usual reviewer is unavailable. That avoids turning an absent reviewer into either an indefinite delay or an undocumented exception.
Follow the fix into the software people use
A repair should remove the cause or prevent the unsafe behavior. For a code flaw, reproduce the relevant behavior in a regression test and consider a plausible bypass. For a dependency finding, check that the intended version is actually installed and included in the built application. A changed version constraint isn't enough if the lockfile or resulting image still contains the vulnerable package.
Review the complete merge request, including tests and scanner results. Run the relevant checks against the proposed change, then check the successful post-merge scan separately. Integrated merge request security reports make that comparison easier; teams working from job artifacts need to bring those results into their review themselves.3
The default branch is the starting point for GitLab's vulnerability tracking. If your project tracks additional branches or tags, check the specific ref you're reviewing rather than assuming a result for one covers the others.4 A default-branch fix may still need a backport, a rebuilt package, or deployment. Keep those tasks connected to the finding until the affected releases or services have been addressed.
In GitLab, No longer detected describes a scan result; it doesn't by itself change the vulnerability's status to Resolved. Compare the fix with the successful scan before updating the status. An excluded directory or changed scanner can also explain why a finding disappeared. A release owner can then confirm where the fixed software is running or available. If a deployment is still pending, the tracking issue should make that remaining exposure clear even if the source-code vulnerability has been resolved.
For exposed secrets, contact the credential owner promptly and revoke or rotate the credential. Removing the value from source doesn't remove the access it granted. Coordinate any replacement with the services that use it, review whether it was misused, and remove exposed copies where appropriate. Record the revocation or rotation outcome without adding the secret to a ticket. GitLab's vulnerability-management auto-resolution excludes secret-detection findings, so this response still needs a person's follow-through.5
Make accepted risk a decision you can revisit
Sometimes a fix isn't available, or introducing it immediately would create a larger operational problem. The team can choose a temporary mitigation or accept the remaining risk, but that decision needs someone authorized to make it. Explain the affected systems, likely consequence, alternatives considered, and why the chosen approach fits the situation.
Give the decision a review date and an earlier reason to revisit it. A supplier releasing a fix, a service becoming public, or a compensating control changing can matter more than the calendar. Assign the review as actual work in the team's tracking system. Writing a date in a comment won't bring the decision back to someone's attention on its own.
Keep false positives distinct from accepted risks. A false positive means the reported weakness isn't present; accepting a risk acknowledges that it remains. GitLab's dismissal reasons include False positive, Acceptable risk, and Mitigating control, so choose the one that matches the decision and explain it. Dismissed findings stay dismissed when detected in later scans; the next scan won't reconsider the risk for you.
For example, a team might temporarily restrict access to a vulnerable service while waiting for a supported patch. The decision can name who maintains the restriction, when the patch will be reviewed, and what happens if the restriction can't be kept in place. When the review comes around, check those conditions again rather than simply extending the date. An accepted risk can remain acceptable, but it should remain a deliberate choice.
Automate decisions that have become repeatable
Once the team understands a recurring pattern, vulnerability management policies can handle some of the bookkeeping.5 They can resolve findings no longer detected by the same scanner, dismiss matches, or adjust severity. They affect records in Needs triage or Confirmed, not every finding indiscriminately.
Choose criteria you can explain and inspect. A test-file location alone may be too broad: a real credential in a test fixture still grants access. A dismissal rule should reflect an investigated pattern, with someone responsible for reviewing it when the code or threat changes. A repeated false positive may instead warrant a scanner-rule correction.
Apply a new rule to a limited set of projects, then inspect the bot's status notes and the records it left unchanged. For tracked branches, policy evaluation happens per branch. Auto-resolve and auto-dismiss process at most 1,000 matching vulnerabilities per pipeline, continuing in later pipelines; a remaining backlog isn't necessarily a failed rule. Keep a route for people to challenge an automated decision and adjust the policy when its results don't match the intent.
If you're ready to introduce wider enforcement, roll out security policy progressively explains how to bring teams into that change without making a noisy queue harder to manage.
An agent can also help investigate a finding or prepare a repair. That is a separate choice from automating vulnerability-record updates: neither an accepted patch nor a changed status establishes that the exposed service is fixed. The same prioritization, checks, and release follow-through still apply. For work the team wants to delegate, choosing and revisiting workflow autonomy explains how to decide which actions can proceed and where a person should stay involved. Teams can keep a human-led remediation process without changing the security outcome they're pursuing.
Use completed work to improve the process
Look at how recent findings moved through the team. Where did they wait: for someone to investigate, for an application owner, for review, or for a release? Improving that handoff may reduce exposure more than adding another scanner. Compare time to first decision and time to remediation for similar applications and risks, rather than treating every finding as interchangeable.
For urgent exposure, distinguish time to containment from time to completed remediation. Restricting an affected endpoint can reduce immediate harm while a repair is prepared and released. The final check should establish that the unsafe behavior is addressed in the affected software, including supported versions still in use. Keeping those milestones separate shows whether the team became faster at protecting users, finishing repairs, or only closing records.
Review overdue fixes alongside accepted risks and recurring findings. A falling count can reflect repairs, but it can also reflect bulk dismissal or reduced scan coverage. Before calling it progress, check what changed. A growing count after adding coverage may be expected; the more helpful question is whether the team can understand and act on the new results.
Turn repeated weaknesses into changes developers can reuse. Several injection findings may point to a shared query helper or coding example that needs improvement. Repeated vulnerable images may call for a maintained base image and a clearer update process. Investigated false positives can improve scanner settings. Give those improvements owners, then look at later findings to see whether the pattern actually became less common.
Further Reading
Notes
-
The vulnerability report is available in Ultimate. It brings triage, status, filters, and links to follow-up work into GitLab; using issues with scanner artifacts leaves that coordination to the team. ↩
-
Basic SAST and its JSON reports, pipeline secret detection reports, and container scanning artifacts are available on all tiers. Integrated vulnerability management and GitLab Advanced SAST are available in Ultimate. Check each scanner's documentation for its supported technologies and remaining tier differences. ↩
-
Integrated security reports in merge requests are available in Ultimate. A report from the proposed change isn't a substitute for the scan after merge. ↩
-
The project vulnerability report's tracked-ref filter is available in Ultimate and requires advanced vulnerability management. It defaults to the default branch; additional security tracking and feature availability determine which other refs are available. ↩
-
Vulnerability management policies are available in Ultimate. They automate established handling rules, including per-branch evaluation and batch limits; they don't revoke exposed credentials or confirm that a fix has been deployed. ↩ ↩2
- Choose and configure security scanning helps you select checks for the application's technology and risks.
- Read security results from jobs, pipelines, and merge requests explains where reports appear and how long findings remain available.
- Prioritize findings using risk assessment data explains signals such as known exploitation and exploit likelihood.
- Track decisions and work in the vulnerability report covers filtering, status changes, and issue links.
- Understand vulnerability status and dismissal reasons helps you distinguish a scan result from the team's decision and check who can change that decision in GitLab.
- Plan remediation helps you decide how to handle a finding and record the outcome.
- Respond to detected secrets introduces the available detection and response options.
- Configure vulnerability management policies explains supported criteria and how to introduce automated handling.