Open-source software has become the backbone of modern application development, enabling organizations to build products faster by relying on millions of community-maintained libraries and frameworks. Yet the same ecosystem that fuels innovation has also become one of cybersecurity’s most attractive attack surfaces. Rather than targeting organizations directly, threat actors increasingly compromise the software supply chain, inserting malicious code into trusted dependencies that are later downloaded by thousands of developers and integrated into production environments.
Recognizing that speed has become one of the attackers’ greatest advantages, GitHub and the Python Package Index (PyPI) have introduced new security mechanisms designed to slow the spread of malicious packages and reduce the likelihood that compromised software reaches downstream users before it can be detected.
The coordinated changes focus on a simple but effective principle: creating time for defenders.
GitHub has announced that Dependabot, its automated dependency management service, will now apply a default 72-hour waiting period before recommending newly released package versions. Instead of immediately generating pull requests after a dependency is published, the service will delay update recommendations, allowing the security community, repository maintainers, and automated malware detection systems additional time to identify suspicious releases.
The change addresses a recurring pattern observed in recent software supply chain attacks. Malicious packages frequently remain available for only a short period before researchers discover the threat and repository administrators remove them. However, even a few hours can be enough for automated dependency tools to propagate compromised versions into countless development environments.
By delaying updates for three days, GitHub aims to reduce the risk that organizations unknowingly deploy malicious code simply because their automation trusted a package the moment it appeared.
Importantly, the cooldown period is not intended to slow software development indefinitely. Organizations with stricter release requirements or internal validation processes retain the ability to customize the delay according to their own security policies. For many enterprises, the new default effectively introduces an additional layer of risk management without requiring any changes to existing workflows.
While GitHub’s initiative focuses on slowing the adoption of new releases, PyPI has addressed a different class of supply chain threat: the modification of previously published software versions.
Historically, package maintainers could upload additional distribution files to an existing release after publication. Although this capability served legitimate operational purposes, it also represented a potential opportunity for attackers who successfully compromised a maintainer’s publishing credentials.
Instead of releasing an obviously suspicious new version, an adversary could theoretically inject malicious artifacts into an older release that developers already trusted. Since many production systems intentionally pin dependencies to specific versions, altering an established release could silently distribute malicious code without triggering version upgrades or drawing immediate attention.
Under PyPI’s new policy, maintainers can no longer upload new files to releases that are more than fourteen days old. The restriction effectively closes the opportunity to modify mature package versions while preserving enough flexibility for developers to correct issues shortly after publication.
According to PyPI administrators, the overwhelming majority of legitimate package updates occur within the first two weeks of a release, making the new limitation unlikely to disrupt normal development while substantially reducing the platform’s exposure to release poisoning attacks.
These security enhancements reflect a broader shift in how the software industry approaches supply chain defense. Traditional security measures have largely focused on identifying malicious packages through automated scanning, behavioral analysis, digital signatures, and community reporting. While those capabilities remain essential, they cannot guarantee immediate detection.
Attackers have repeatedly demonstrated that even short-lived malicious packages can achieve significant distribution before they are removed. Credential stealers, cryptocurrency miners, remote access malware, and backdoors disguised as legitimate open-source libraries have all leveraged the speed of automated dependency management to maximize their reach.
By introducing deliberate friction into that process, GitHub and PyPI are acknowledging that time itself can function as an effective security control.
The strategy mirrors approaches increasingly adopted across cybersecurity, where delaying an attacker often proves just as valuable as blocking one outright. Every additional hour creates opportunities for threat intelligence platforms to identify suspicious behavior, for researchers to analyze newly published packages, and for repository maintainers to remove malicious content before automated systems consume it at scale.
The changes also reinforce an important reality for software development teams: automation should not replace trust verification.
Organizations remain responsible for maintaining secure dependency management practices, including using lockfiles, enforcing least-privilege access to publishing credentials, protecting CI/CD pipelines, monitoring software bills of materials (SBOMs), and continuously scanning dependencies for newly disclosed vulnerabilities.
The introduction of time-based defenses does not eliminate software supply chain attacks, nor does it prevent every malicious package from reaching developers. Instead, it shifts the balance slightly in favor of defenders by reducing the speed at which attackers can weaponize trust across one of the world’s largest software ecosystems.
As open-source software continues to underpin everything from enterprise applications to critical infrastructure, these changes represent an evolution in defensive thinking. Rather than relying solely on perfect detection, GitHub and PyPI are redesigning the ecosystem to be more resilient against inevitable compromise—recognizing that sometimes the most effective security improvement is simply giving defenders enough time to respond before malicious code spreads across the global software supply chain.