Blog

Fixed it again? How to find the root cause of recurring security issues

Same security issue keep coming back? Use the change records you already have to fix it at the source.

7 min

Nikki Wilson

Blog

Fixed it again? How to find the root cause of recurring security issues

Same security issue keep coming back? Use the change records you already have to fix it at the source.

7 min

Nikki Wilson

Blog

Fixed it again? How to find the root cause of recurring security issues

Same security issue keep coming back? Use the change records you already have to fix it at the source.

7 min

Nikki Wilson

In this article

No headings found on page
No headings found on page

Join our newsletter

Receive the latest advancements, playbooks, and industry insights in software change security understanding.

We'll store and process this information in line with our privacy policy to provide you our products and services. You may opt out of this at any time.

Why do the same security issues keep coming back?

Your car's warning light comes on, so you take it to the garage. They clear it and send you on your way. A month later it's back. A different garage clears it again, and nobody thinks to look at the service history. Anyone who's owned an older car knows the answer is to find the mechanic who reads that history first, because the pattern's usually sitting right there.

Recurring security issues work in a very similar way. Say a missing authorisation check turns up on a new export endpoint in March. It gets fixed, retested and closed. Then in June the same kind of issue appears on a different endpoint, in a different service, written by a different team. That gets fixed too.

Each fix is right. The trouble is that fixing a finding where it shows up doesn't tell you why it keeps getting introduced, so it keeps coming back.

The good news is your team already keeps a service history of sorts. It's in your change records, the tickets, pull requests, review notes and test results behind each change. In this guide we'll show you how to use them to work out what recurring issues have in common, so you can fix the cause once. You'll get a list of what's worth recording, five steps for comparing records, a worked example and the usual suspects to check first. And you won't need any new tools to get started.

Download our free template

Our recurring issue review sheet helps you lay change records side by side, so the common thread is easier to spot.

Why recurring issues are so hard to pin down

Most security findings land with developers without the change attached. A pentest report lists everything found across an application at one point in time, and a scanner flags a line of code. Either way, the finding often turns up weeks or months after the change that introduced it, and it's quite often fixed by someone who didn't write the original code.

So each finding gets treated as a one-off. It's triaged, fixed and closed, and the story of why it happened ends up spread across a ticket, a PR, a report and somebody's memory. Spotting that three findings share a cause means piecing all of that back together by hand, and when there's a backlog to clear, who's got time for that?

For developers, it means the same rework landing in the backlog every few months, usually with a deadline attached. None of this is anyone doing their job badly. The process just doesn't keep the finding and the change together.

What goes into a useful change record

Think of a change record as the service history for one change. It covers why the change was made, what it touched, how it was checked and what happened next. You've almost certainly got most of this already. It's just spread across different tools.


What to capture

Why it helps with recurring issues

Where it usually lives

What changed and why, and in which service

Groups occurrences by kind of change and by place

Ticket, PR description, repository

What it touches from a security point of view, such as authentication, permissions, sensitive data or external input

Shows whether the same area keeps causing problems

PR description, threat model, design doc

How risky it looked at the time

Shows whether some kinds of change keep getting underestimated

Ticket labels, review checklist

What review it got, and any decisions or accepted risks

Shows whether the scrutiny matched the risk

PR approvals, review comments, risk register

What testing found, how it was fixed and whether the fix was retested

Shows whether fixes were local or shared, and whether they held

CI results, scanner or pentest reports, the fix PR


If you only pick up one habit from this guide, make it the last row. Whenever a security finding is fixed, note the PR or release it came from, and tag the weakness type with its CWE category (the standard way of classifying software weaknesses). That one link is what makes everything else possible.

Five steps to find the common denominator

You can start as soon as you notice the same kind of issue more than once, whether that's the same weakness type, the same part of the application or the same fix being applied again.

Gather the records

For each occurrence, track down the change that introduced it and pull together its ticket, PR, review notes and test results. Two occurrences are enough to get going, and with three or more you can trust the pattern a bit more.

Compare what changed

Were they the same kind of change, like a new endpoint or a dependency upgrade? Were they in the same service? And looking back, did each one seem as risky at the time as it turned out to be? A change that looked routine but still produced a finding is worth a closer look.

Compare what they touched

Did they all affect the same security area, such as permissions or sensitive data? If someone flagged that area at the time, the risk was spotted and the gap is further down the line. If nobody did, the change probably looked safer than it really was.

Compare the decisions

How was each change reviewed, and were any risks accepted along the way? If the same risk keeps getting accepted and the same finding keeps following it, that's worth a conversation.

Compare the fixes

Was each fix limited to one endpoint, or did it change something shared? A local fix can pass retest and still leave the cause in place for the next change.

Anything that shows up in more than one record is your common thread, and it's usually your diagnosis too.

A worked example

Here's how that might play out. (This one's illustrative.)

Say a team notices that broken object level authorisation has come up three times in a quarter. That's where a user can get at someone else's data just by changing an ID in a request. When they compare the three change records, this is what they find.

  • What changed. All three were new API endpoints, in three services owned by three different teams.

  • What they touched. Each one returned customer data, and each PR description said so.

  • Decisions. Each went through normal code review and was approved, and the review checklist didn't mention authorisation on new routes.

  • Fixes. Each fix added an ownership check inside that one endpoint's handler.

So what do they have in common? There's no shared authorisation check for new routes. Each team writes its own, which means every new endpoint starts life without one.

That points the fix at the source. The team adds a shared authorisation layer that new routes use by default, plus a review checklist question asking which check protects any new route. Now the next export endpoint starts with the check already in place.

Common causes worth checking first

Every codebase has its own quirks, but these usual suspects come up often enough that they're worth checking first.

  • The same kind of change. New endpoints, permission changes and dependency upgrades are frequent repeat offenders.

  • The same service or component. One part of the codebase keeps producing the same weakness, often because it's older or nobody clearly owns it.

  • The same security area. If authentication, permissions or sensitive data keep coming up, there's usually a gap in the design. Access control and business logic flaws are common examples.

  • Changes that looked routine. If one kind of change keeps looking low risk right up until something's found, it's worth rethinking how that kind of change gets assessed.

  • Repeated risk acceptance. The same risk gets accepted again and again, and the same finding keeps following it.

  • Fixes that only ever change one place. Every fix passes retest, but nothing shared changes, so the next change brings the issue straight back.

Turning a diagnosis into a fix

Once you know what the occurrences share, pick the lightest guardrail that would have caught all of them. That could be a shared library or middleware, a secure default in your framework, a question on the review checklist, a test that runs on every change of that kind, or simply clearer code ownership.

It's what the standards ask for too. NIST's Secure Software Development Framework asks development teams to analyse the root causes of vulnerabilities over time, look for similar weaknesses elsewhere in the software and update the development process to match.

After that, keep an eye on new changes of that kind. If the issue stops turning up, your guardrail's doing its job. If it doesn't, compare the new record with the old ones and you'll see where it's slipping through.

Getting started this week

You don't need a project plan or a budget for any of this. These four small habits will make the next recurring issue much easier to get to the bottom of.

Add two questions to your PR template

Something like 'What does this change touch from a security point of view?' and 'How risky does it look, and why?' A few words for each is plenty.

Link every security fix back to where it came from

In the fix PR, reference the PR or release that introduced the issue, and add its CWE category as a label.

Agree on labels across teams

Use one set of labels for change type and security area, so records from different services can be compared.

Book in a 30-minute review each quarter

Pick any issue that's turned up more than once, lay its records side by side using the template, and choose one guardrail to put in place.

Making it easier as you scale

Everything above works with the tools you've already got. The tricky part is keeping it going. PR template answers get shorter over time, findings arrive without a link to their change, and the quarterly review slips when there's a release to get out.

That's the gap Cytix is built to close. For every change it assesses, Cytix keeps a connected audit trail covering the trigger and risk tier, the threat model and security impact analysis, the decision and why it was made, and the tests, findings and retest confirmations. It works inside your existing ticketing and workflow systems, so your team carries on working the way it does now, and the record's already complete when you sit down to compare.

If you think your security team would find that useful, send them our overview of change-driven testing.

Frequently Asked Questions

Do I need any special tools to start?

Not at all. Your ticketing system, Git history and test reports hold most of what you need, and a spreadsheet is enough for a first review. The template gives you a ready-made layout if you'd like one.

How is this different from a postmortem or root cause analysis?

Root cause analysis in software development usually digs into one issue in depth. Comparing change records looks across several occurrences to find what they share, so the two work really well together. Your postmortems and fix PRs supply the records, and the comparison spots the pattern.

How many occurrences make a pattern?

Two is enough to start asking questions, and with three or more you can be more confident. Issues caught in code review count too, so include them if you track them.

Start with your next recurring issue

Recurring security issues are rarely bad luck. Just like that warning light, the pattern's usually sitting in the history, as long as each finding is linked to the change that caused it. Find it, and you can fix whatever keeps bringing the issue back.

Run your first review with our free template.

Lay the records behind a recurring issue side by side and work through the five steps.


Join our newsletter

Receive the latest advancements, playbooks, and industry insights in software change security understanding.

Join our newsletter

Receive the latest advancements, playbooks, and industry insights in software change security understanding.

We'll store and process this information in line with our privacy policy to provide you our products and services. You may opt out of this at any time.

Legal

101 Princess Street, Manchester, United Kingdom M1 6DD

ยฉ 2026 Cytix Ltd. All rights reserved.

Join our newsletter

Receive the latest advancements, playbooks, and industry insights in software change security understanding.

We'll store and process this information in line with our privacy policy to provide you our products and services. You may opt out of this at any time.

Legal

101 Princess Street, Manchester, United Kingdom M1 6DD

ยฉ 2026 Cytix Ltd. All rights reserved.

Join our newsletter

Receive the latest advancements, playbooks, and industry insights in software change security understanding.

We'll store and process this information in line with our privacy policy to provide you our products and services. You may opt out of this at any time.

Legal

101 Princess Street, Manchester, United Kingdom M1 6DD

ยฉ 2026 Cytix Ltd. All rights reserved.