Your Software Hasn’t Changed in a Year. Have Its Security Risks Stood Still Too?
Every company has at least one system like this. It was built a few years ago, it works well, and nobody complains. The last code change happened more than a year ago. The team that built it has moved on to other projects — or left the company.
The conclusion seems logical: if nothing changed, nothing got worse.
Unfortunately, that is not how security works.
The code may be frozen. The world around it is not. New vulnerabilities are discovered every day in libraries, frameworks, operating systems, and components that system relies on. Software that was reasonably secure when it shipped can be exposed today — without a single line having changed.
My position: operational stability is not the same as security. A critical system that no longer evolves still needs an inventory, monitoring, and maintenance proportional to the risk it represents.
Why a “frozen” system becomes more vulnerable
Dependencies age
Modern applications are largely made of third-party code: authentication libraries, document generators, database drivers, file parsers, cryptography. The code a company writes itself is often a small fraction of what actually runs in production.
When a vulnerability is disclosed in one of those libraries, every system using it becomes a potential target. Attackers tend to exploit precisely the known, already-patched vulnerabilities — because they know many companies never applied the fix.
Runtimes and platforms reach end of support
Languages, frameworks, and operating systems have life cycles. When a version loses support, it stops receiving security fixes. I discussed this scenario in the article on .NET 8 and 9 end of support: the system keeps running, but every newly discovered vulnerability stays open indefinitely.
The environment shifts around the system
Certificates expire. Partners retire old protocols. Cloud providers change default settings. Password policies, regulatory requirements, and customer expectations evolve. A system that does not keep up silently accumulates risk.
Knowledge disperses
The longer a system goes without maintenance, the fewer people know how to update it safely. When a critical vulnerability demands an urgent fix, the company discovers that nobody remembers how to build the project, where the deployment credentials are, or which tests guarantee nothing breaks.
This is the most underestimated risk: not the vulnerability itself, but the inability to fix it quickly.
The alerting tools stop looking too
Many companies assume that if something serious happens, some tool will warn them. But those tools also prioritize what is active.
In November 2026, GitHub announced in its changelog that, starting December 8, 2026, Dependabot alerts will be disabled on most repositories with no activity for a year, except where organizational security policies define otherwise.
The change makes sense from the platform’s perspective: it reduces noise from abandoned projects. But it exposes a delicate situation for businesses. An inactive repository is not necessarily an abandoned system. It may be exactly that stable, critical system nobody touches because it simply works.
If nobody configures an exception, and there is no other tracking mechanism, alerts about that system stop arriving. The risk remains; it just becomes invisible.
How to tell if you have this problem
A few questions help size the exposure:
- Is there an inventory of production systems, with an owner, technology stack, and last update date?
- For each critical system, do we know which libraries and versions it uses?
- Does anyone receive — and read — vulnerability alerts for those components?
- Could we build, test, and deploy a fix in less than a week?
- Do the runtimes and operating systems behind these systems still receive security updates?
- Do we know which of these systems are internet-facing or process personal and financial data?
If the answer to several of these is “I don’t know,” the problem probably exists — it just has not been measured.
A maintenance strategy proportional to risk
Not every system deserves the same attention. An internal utility with no internet access does not require the same care as a customer portal that processes payments. The goal is not to maintain everything at the same pace, but to consciously decide how much each system deserves.
1. Inventory
List production systems, their owners, technology, the data they process, and their external exposure. Without an inventory there is no risk management — only hope.
2. Classification
Classify each system by business criticality, exposure, data sensitivity, and platform support status. A simple three-tier model is often enough:
| Tier | Characteristics | Suggested minimum maintenance |
|---|---|---|
| High | Internet-facing, sensitive data, or critical processes | Continuous vulnerability monitoring, regular updates, and a tested response plan |
| Medium | Internal use with relevant operational impact | Periodic dependency reviews and planned update cycles |
| Low | Restricted use, no sensitive data | Annual review and evaluation for retirement |
Illustrative classification. Each company should adjust criteria and frequency to its obligations and risk appetite.
3. Active monitoring
Make sure high- and medium-tier systems keep being scanned even without new commits. That may mean configuring exceptions in existing tools, scheduling periodic scans, or centralizing dependency tracking.
4. Ability to fix
Preserving the ability to fix is as important as detection. That includes a working build pipeline, a minimal automated test suite, deployment documentation, and at least two people able to run the process.
A useful practice is to update periodically even without functional need — for example, every quarter. Small, frequent updates are far safer than a large version jump made in a hurry during an incident.
5. A deliberate life-cycle decision
Sometimes the best decision is to retire the system, replace it, or fold it into another. If that is the case, Modernize or replace a legacy system? offers criteria for that choice.
Prevention in engineering versus responsibility in operations
In Security isn’t about pentesting, I argued that security begins before the first commit, with sound engineering practices.
This article covers the other end of the life cycle: what happens after the last commit. A system still running in production is still the company’s responsibility, even if nobody writes code for it anymore.
Frequently asked questions
If the system isn’t internet-facing, should I still worry?
Yes, though with lower priority. Attacks often begin at any available entry point and then move laterally. Vulnerable internal systems make that movement easier.
Can’t updating dependencies break the system?
It can — which is precisely why updates should be frequent and tested. Large version jumps concentrate incompatibilities; small, regular updates spread out and reduce that risk.
How much does it cost to keep a stable system up to date?
It depends on size, technology, and risk level. In general, a periodic update routine costs far less than an emergency fix after an incident — or a forced migration because the platform went out of support.
Do automated scanning tools solve the problem?
They help a lot, but not on their own. They must be configured for the right systems, someone must triage the alerts, and the team must be able to apply fixes.
Conclusion
A system that hasn’t changed in a year can be a source of pride: it does its job without causing trouble. It can also be a blind spot.
The question leadership should ask is not “when was it last changed?” but “when did someone last verify it is still secure — and how long would it take us to fix it?”
If you run a critical system that rarely evolves, I can help assess its dependencies and define a maintenance strategy proportional to its risk.
Get in touch through the contact page or learn more about my architecture and security assessment services. Commercial engagements are delivered by IVATEC.
legacy system security application security dependencies legacy systems technology leadership software modernization
1253 Words
2026-11-16 22:00