Articles

Alert Avalanche to Security Success: GHAS Campaigns Unleashed

This article was written by  Randy Pagels, Christina Weiss, Matt Olson

November 18, 2026
20 minutes
‌

How a Large Financial Services Organization Operationalized GitHub Advanced Security at Enterprise Scale

Introduction

Security tools are good at finding problems. That does not mean teams are good at fixing them.

That gap becomes painfully clear when application security tooling is rolled out across a large software portfolio. Code scanning finds real vulnerabilities. Secret scanning identifies credentials that should never have reached source control. Dependency review gives teams a chance to catch risky package changes before they merge. The signal is valuable, but the volume can quickly overwhelm the people expected to act on it.

This is the story of how Xebia partnered with a large financial services organization to move from security alert overload to a working remediation model using GitHub Advanced Security (GHAS). The organization supported thousands of developers and more than a thousand repositories, with findings spread across many teams, business units, and application stacks.

The customer did not need another dashboard proving there was risk. They needed a repeatable way to reduce it.

Using GHAS campaigns, the teams addressed several thousand security alerts, improved response to newly identified risks by 22%, and increased developer participation by 35%. One focused two-week remediation sprint fully closed its targeted alert set and helped resolve more than 150 related findings outside the original scope. The real win was the shift in how security work got done. Security and engineering teams created a rhythm that made remediation visible, measurable, and achievable without turning every sprint into a fire drill.

GHAS provided the detection layer through code scanning, secret scanning, and dependency review. Security campaigns provided the operating model, helping teams group alerts, assign ownership, and focus remediation around defined goals. Copilot Autofix helped developers understand and repair many code scanning alerts faster, while keeping review and validation where they belong, with the engineering team.

This was not a feature rollout story. It was a security debt reduction story.

‌

Security Debt Does Not Burn Down Itself

Most engineering leaders have seen this pattern. A security platform rolls out with the right intentions. Dashboards light up. Alerts appear across repositories. Security teams can finally see risks that were hidden before. Developers start receiving issues, tickets, notifications, or pull request comments telling them something needs attention.

Then the hard part begins.

Some teams respond quickly. Others are not sure whether the alert applies to their code path. Some findings take a small code change and a test run. Others require deeper refactoring, dependency decisions, or coordination with platform teams. Secrets are harder still. Is the credential active? Who owns it? Was it rotated? Was it used anywhere else? Can the alert be closed, or has the risk only been hidden?

At enterprise scale, detection is not enough. The challenge is turning detection into coordinated action.

That was the situation facing this financial services organization. GHAS gave the customer a strong foundation for finding vulnerabilities, exposed secrets, and dependency risks inside the developer workflow. But finding risk is different from reducing risk.

The customer’s security team faced a common enterprise problem, too many alerts across too many repositories, with inconsistent ownership and competing priorities. Development teams were not ignoring security. They were balancing feature work, production support, existing technical debt, and unfamiliar security findings that did not always come with a clear next step.

Security debt behaves like any other technical debt. It compounds when there is no clear owner, no deadline, and no shared definition of done.

That is how alert backlogs become alert avalanches. Not because the tools failed, but because the organization needs a remediation model.

A scattered approach makes the problem worse. Broad messages asking every team to clean up every alert are easy to defer. Isolated tickets without context are easy to misunderstand. Dashboard totals may show the size of the problem, but they rarely explain which alerts are actionable, which need exception handling, and which require cross-team coordination.

The customer’s goal was not to fix everything everywhere. It was to create a repeatable pattern for reducing risk in focused increments. That meant moving away from ad-hoc alert cleanup and toward structured campaigns with defined scope, clear ownership, and short timelines.

The shift changed the conversation. Security was no longer just reporting a backlog. Engineering was no longer receiving an open-ended list of problems. Both groups had a shared work item, a defined campaign, a measurable goal, and a practical path to closure.

That became the foundation for the larger GHAS remediation effort.

GHAS Was the Signal, Campaigns Were the System

The harder question was how to make security findings actionable across a large engineering organization without creating noise, confusion, or resentment. A vulnerability buried in a dashboard does not reduce risk. A secret scanning alert assigned to the wrong team does not protect production. A code scanning finding without context often becomes one more ticket developers plan to revisit later.

GHAS helped because it brought security signals into the developer-centered workflow, close to the code, close to pull requests, and close to the people who could fix the problem. But visibility was only the starting point.

Campaigns changed the shape of the work. Rather than treating every alert as an isolated item in a growing backlog, campaigns gave the organization a way to group related findings into focused remediation efforts.

A CodeQL campaign could target a specific class of code scanning alerts across selected repositories. A secret scanning campaign could help teams work through exposed credentials with clearer ownership and a defined closure path. Instead of saying, "Please clean up your security alerts," the organization could say, "This is the campaign, this is the scope, this is the remediation window, and this is how we will track progress."

Developers are much more likely to act when the work is specific, time-bound, and tied to code they understand. Managers are much more likely to support remediation when they can see scope, ownership, and progress. Security teams are much more likely to sustain the program when they are not manually chasing every repository owner through spreadsheets and one-off meetings.

Campaigns became the bridge between security findings and engineering execution. GHAS provided the security signal, but campaigns turned that signal into a system the organization could run.

CodeQL Campaigns Turn Static Analysis into Team Action

Code scanning alerts are easiest to ignore when they arrive as a long list, not because developers do not care, but because a long list rarely answers the questions teams need first: Why this alert? Why now? Who owns it? How risky is it? What does "done" look like?

A CodeQL campaign changes that conversation. The security and engineering teams selected a targeted set of findings and placed them into a short remediation sprint with a clear scope, a clear timeline, and a shared view of progress. A strong campaign starts with one specific question: What class of risk are we trying to reduce right now? That keeps the work from becoming too broad. The campaign should be narrow enough that teams understand the ask and broad enough that completion produces a meaningful reduction in risk.

For this organization, once developers understood the vulnerability pattern and saw how similar issues appeared in nearby code, they often fixed more than the campaign required, extending impact well beyond the original alert set.

‌

Here is a screenshot of a CodeQL campaign showing campaign scope, alert grouping by repository, ownership context, and remediation progress.

Copilot Autofix helped reduce friction, especially when developers encountered unfamiliar vulnerability patterns. The most effective teams treated it as a starting point, not an approval stamp, reviewing the suggested change, validating behavior through tests, and merging only after normal pull request review. That made the work faster without lowering the bar.

A practical CodeQL campaign workflow:

  • Here is a screenshot of a CodeQL campaign showing campaign scope, alert grouping by repository, ownership context, and remediation progress.
  • Copilot Autofix helped reduce friction, especially when developers encountered unfamiliar vulnerability patterns. The most effective teams treated it as a starting point, not an approval stamp, reviewing the suggested change, validating behavior through tests, and merging only after normal pull request review. That made the work faster without lowering the bar.
  • A practical CodeQL campaign workflow:

The exception path matters. Not every alert should be fixed the same way. Some findings are false positives, some involve dead code, and some require architectural changes that cannot happen inside the campaign window. The goal is not blind closure, but responsible closure. A resolved alert should mean the risk was addressed, accepted with justification, or moved into a managed path. Without that discipline, teams can make the dashboard look better without actually reducing risk.

The best CodeQL campaigns did more than lower alert counts. They created shared understanding. Security teams learned which findings were easy for developers to fix and which required better guidance. Developers learned how certain vulnerability patterns showed up in their own code. Managers gained a clearer picture of remediation capacity and where teams needed support.

That is how static analysis became team action, not by throwing more alerts at developers, but by organizing the work into a campaign they could understand, complete, and repeat.

Secret Scanning Campaigns Require More Than Cleanup

Code vulnerabilities usually start with a question about code. Secrets start with a different question: What has this credential touched?

A hardcoded token, password, API key, or connection string is not just a bad line in a repository. It may represent access to a system, a deployment pipeline, a cloud service, or a database. Removing the secret from the codebase does not automatically remove the risk.

Someone still has to confirm whether the credential is active, who owns the system it connects to, whether it has been rotated or revoked, and whether the application now retrieves the secret from an approved store.

A secret scanning campaign turned those questions into a process. Instead of leaving each exposed credential as a one-off alert, the campaign gave security and engineering teams a shared workflow. That was critical because secret remediation often crosses team boundaries. The person who committed the secret may not own the system, and the security team may understand the risk but lack access to rotate the credential. Without a campaign model, that work stalls quickly.

For secrets, “fixed” should not mean “deleted from the file.” It should mean the credential can no longer be used, the application has been updated safely, and the team understands how to avoid repeating the mistake.

A practical secret scanning campaign workflow:

  • Review the detected secret and determine whether it is active.
  • Identify the system, service, or account tied to the credential and find the correct owner.
  • Rotate or revoke the exposed secret and move the replacement into an approved secret store.
  • Validate that the application, workflow, or service still works.
  • Close the alert with enough context to show the risk was addressed.

This workflow also helped leaders see where the organization had process gaps. If secrets came from local development files, the team could improve templates. If secrets came from pipelines, the team could review how credentials were passed into builds. If ownership was unclear, that became a governance issue rather than simply a developer mistake.

The campaign also helped avoid a common trap: blaming developers for systemic problems. Most exposed secrets come from unclear setup steps, rushed testing, inconsistent pipeline patterns, or teams carrying old configuration approaches forward because that is how the application has always worked.

A cleanup mindset says, “Remove the secret.”
A risk reduction mindset says, “Rotate it, validate the system, close the exposure, and change the workflow so it is less likely to happen again.”

Secret scanning gave the signal. Campaigns gave the structure.

The Two-Week Sprint Made Security Work Real

Security remediation often fails when it is treated as background work. Everyone agrees it matters. Everyone assumes someone will get to it. Then feature work, production issues, and release deadlines take over. The alert remains open. The backlog grows.

The two-week remediation sprint gave the work a beginning, middle, and end. It was short enough to create urgency, long enough for teams to investigate alerts, make code changes, review pull requests, run tests, and handle exceptions responsibly. It also made the ask easier for managers to support, this was a defined campaign with a defined window, not an endless cleanup effort.

Before the sprint, the campaign scope had to be clear: Which alert category was included? Which repositories were in scope? Who owned the work? What counted as closure? Those questions forced the organization to be practical. The first goal was not to prove how large the backlog was. The first goal was to prove that the organization could reduce risk through a repeatable process.

During the sprint, teams had a clear target. Developers could work through assigned findings, use Copilot Autofix where appropriate, open pull requests, and validate changes through normal engineering practices. Security teams could watch progress without manually chasing every alert. Managers could see whether teams were blocked, moving, or done.

The campaign also created a natural checkpoint for decisions that should not be rushed. Some alerts could be fixed quickly. Others required more analysis. A few needed exception handling, follow-up work, or a larger design change. The sprint did not force every issue into the same path. It forced every issue into a decision.

That is a healthier model than letting alerts sit untouched.

The sprint closed its targeted alert set and helped resolve more than 150 related findings outside the original scope. Once teams understood the pattern, they did not stop at the minimum, they recognized related issues, fixed nearby problems, and carried the campaign mindset into the surrounding codebase. That is how security work starts to scale: not by asking developers to fix everything at once, but by giving them a focused pattern they can repeat.

A practical campaign sprint rhythm looked like this:

  • Before the sprint, define the alert category, repositories, owners, timeline, and closure rules.
  • At kickoff, explain the risk in plain language and show developers what a good fix looks like.
  • During the sprint, track progress often enough to remove blockers, not often enough to create noise.
  • Near the end, review unresolved alerts and separate true blockers from work that simply needs a decision.
  • After the sprint, capture what slowed teams down and apply those lessons to the next campaign.

Every campaign teaches the organization something, ownership data was weak, developers needed better examples, tests were missing in older repositories, the same secret handling mistake appeared across many teams. Those lessons are valuable because they improve the next campaign.

What Changed When the Work Became Visible

The better result was that security work became visible in a way engineering teams could act on. Alerts were no longer scattered signals waiting for someone to notice them. They were grouped into focused campaigns, assigned to owners, worked through in short cycles, and measured against clear goals.

Response to newly identified risks improved by 22%, and developer participation increased by 35%. More than alert closure, those numbers show that the process changed how teams responded. Developers were not only completing assigned items, they were recognizing the same patterns elsewhere and fixing them before being asked.

The organization also gained a clearer view of what was slowing remediation. Some teams needed better ownership data. Some repositories lacked tests that made changes safe to validate quickly. Some secrets revealed gaps in credential handling practices. Before the campaign model, those issues were buried inside the backlog. After it, they became visible improvement areas that leaders could address directly.

The campaign model also helped build trust between security and development. Developers saw that security was not simply dropping a large backlog into their lap. Security teams saw that developers would respond when the work was scoped and explained clearly. Managers saw that remediation could be planned without derailing every sprint.

In many enterprises, security debt persists because no single team feels fully able to move it. Security can find the risk but cannot always fix the code. Developers can fix the code but may not understand the risk or own the credential. Managers can allocate time but need confidence the work is specific and worth the disruption. Campaigns gave each group a clearer role, security defined the risk and scope, engineering handled remediation, managers protected the time and watched for blockers.

Alert reduction at enterprise scale requires more than detection and more than dashboards. It requires a working agreement between security and engineering about how risk gets reduced. For this customer, GHAS campaigns provided that agreement in a form teams could use.

Lessons from Running GHAS at Enterprise Scale

The biggest lesson was also the simplest: do not start by trying to fix everything. Once security teams can see thousands of alerts, the natural instinct is to push the entire backlog toward development. The intention is understandable. The result is usually frustration.

A better approach is to pick a focused slice of risk and prove the model works. Focus creates movement. Movement builds trust.

Developers need context, not just assignments. A ticket that says "fix this vulnerability" is rarely enough. Teams need to understand why the finding matters, what safe remediation looks like, how to validate the fix, and when dismissal is appropriate. Showing one good remediation pattern gave teams a reference point. Copilot Autofix also helped by providing a starting point for many code scanning alerts, but the best results came when teams treated those suggestions as draft remediation, not automatic approval.

Secrets require a different mindset than code vulnerabilities. A CodeQL alert often ends with a pull request. A secret scanning alert may require rotation, revocation, application changes, pipeline updates, and coordination with a system owner. Teams needed a clear definition of done: the credential confirmed, rotated or revoked, replaced safely, and validated. Closing the alert before all of that is complete creates a false sense of safety, especially in large enterprises where the person who committed a secret may not own the system it connects to.

Campaign planning matters just as much as detection. The customer succeeded because the campaign had scope, ownership, timing, and follow-up. The work was visible enough for leaders, specific enough for developers, and structured enough for security teams to manage without becoming a bottleneck.

Finally, behavior change matters more than metrics. The deeper value was that teams started to understand the remediation pattern, they knew what was expected, how to act, and how to repeat the process. That is how security programs become durable: not by measuring everything, but by creating habits that keep working after the first campaign ends.

One lesson is easy for leadership to overlook: security remediation needs protected time. If campaign work is always squeezed between product delivery and production support, it will lose. A time-boxed campaign gives managers a concrete reason to make room for the work, and gives developers permission to treat security debt like real engineering work.

How to Start Your Own GHAS Remediation Program

Knowing what works is different from knowing how to start. The easiest mistake is to treat GHAS as a switch, turn it on, watch alerts appear, tell teams to fix them, hope the numbers improve. That may work for a small repository set, but it does not hold up at enterprise scale. Remediation needs a plan before the first campaign begins: What risk are we reducing? Who owns the work? How long will the campaign run? What does closure mean?

Start with coverage. Confirm that code scanning, secret scanning, dependency review, and related GHAS capabilities are enabled where they matter most. Do not assume every repository needs the same starting point. Production systems, customer-facing applications, regulated workloads, and shared libraries may deserve priority. The goal is not instant perfection. The goal is to know where security signal exists and where blind spots remain.

Next, choose one focused campaign. Resist the urge to make the first campaign too broad. Pick a CodeQL alert category, a high-priority application area, a known secret pattern, or a set of repositories where the owners are ready to engage. A good first campaign should be important enough to matter and small enough to finish.

Before launch, define the rules. Teams should know which alerts are included, which repositories are in scope, who owns remediation, how long the campaign will run, and how exceptions will be handled. Prepare examples so developers see what a good fix looks like before they are asked to complete the work.

A simple campaign plan might look like this:

  • Campaign name: SQL Injection Cleanup Sprint
  • Scope: selected CodeQL alerts across priority production repositories
  • Duration: two weeks
  • Owners: security lead, engineering manager, repository maintainers
  • Success criteria: each alert is fixed, dismissed with documented justification, or moved into an approved exception path
  • Validation: pull request review, tests passing, and alert status updated in GHAS
  • Retrospective: document what slowed remediation and what should improve before the next campaign

That structure keeps the work concrete and prevents a common enterprise failure mode, where everyone agrees security matters but no one knows exactly what to do next.

During the campaign, track progress often enough to remove blockers. Daily status meetings are not always necessary, and too much reporting can irritate teams that are trying to fix real issues. What leaders need is a clear view of movement. Are alerts being assigned? Are pull requests opening? Are teams blocked on ownership, testing, or rotation? Are exceptions being documented instead of quietly ignored?

The campaign should also make room for judgment. Some alerts will be straightforward. Some will require deeper refactoring or coordination with platform and operations teams. A healthy program does not force every alert through the same path, it forces every alert into a clear decision. Copilot Autofix can help with code scanning alerts where a suggested remediation gives developers a useful starting point; use it where it fits, but keep normal engineering discipline in place.

After the campaign closes, do the retrospective while the work is fresh. If several teams struggled with the same issue, create better guidance. If secrets appeared in local configuration files, improve templates. If tests were missing, note that as engineering debt tied directly to remediation speed. Then run the next campaign.

That repetition is where the value compounds. The first campaign proves the model. The second improves it. Over time, teams stop seeing GHAS as a wall of alerts and start seeing it as part of how secure software gets built.

Security Success Is an Operating Rhythm

Large enterprises do not reduce security debt by hoping developers find time between releases. They reduce it by making the work visible, focused, and repeatable. GHAS exposed the work, but the breakthrough came when those signals were organized into campaigns teams could act on.

That is the difference between alert management and security debt reduction.

Alert management asks, “How many findings do we have?”
Security debt reduction asks, “Which risks are we reducing, who owns them, and how will we know they are truly resolved?”

The operating model is transferable. Start with a focused risk area. Define the campaign clearly. Give developers context. Protect time for remediation. Use automation where it helps. Validate the fix. Capture the lesson. Repeat.

Security debt does not go down because a dashboard gets better. It goes down when teams change how the work gets done. For organizations already using GHAS, campaigns offer a practical path forward—turning scattered findings into focused work, and focused work into measurable progress.

Tools can find the avalanche. Campaigns help teams climb out of it.

---

This article first appeared in XPRT. Magazine #22: Commit to the Unknown. Download the full edition.

Every edition of XPRT. Magazine in one place. Browse all editions

Written by

Randy Pagels

I am a DevOps Architect and Trainer at Xebia USA. I lead and educate customers in designing and implementing solutions that adhere to industry standards and DevOps best practices.

Contact

Let’s discuss how we can support your journey.

‌
‌
‌
‌
‌
‌
‌
‌
‌