Application security is shifting toward a continuous, layered approach. Developers need support that protects application design, validates AI-generated and third-party code, and integrates directly into build pipelines. Such solutions must be suitable for deployed software and provide strong runtime defenses.
In this guide, we explore emerging application security trends, their risks, and how to respond effectively.
| Trend | Primary Risk | Recommended Action |
| AI-generated code | Code may contain insecure patterns. | Do a thorough review of generated code before deploying it into a codebase. |
| Software supply chain security | Third-party dependencies may have unknown security vulnerabilities. | Maintain a log of an application’s dependencies, libraries, and other third-party components. Update components as necessary and remove them when a third party stops providing support. |
| Secure by Design | Failure to implement security measures throughout the build process may lead to vulnerabilities. | Define application security requirements from the beginning and implement them into the development process. |
| Runtime application protection | Attackers reverse engineer or tamper with apps for their own benefit. | Use runtime security tools that detect and block tampering, as well as debugging tools. |
| Faster vulnerability exploitation | Bad actors discover exploits before software teams do, leading to a data breach. | Have a multi-layered security strategy that includes risk modeling, automated testing, and steps to address threats quickly. |
| API, mobile, and client-side security | Attackers exploit API, mobile, or client-side vulnerabilities to attack an application. | Track API use and employ proper authorization controls to prevent attacks. |
| Security consolidation and automation | Alert fatigue causes teams to overlook critical security alerts. | Use a single platform to combine security alerts from multiple sources. Prioritize alerts based on potential risk and assign them for prompt remediation. |
According to a 2026 report on AI Coding Assistants and New Security Challenges from Salt Security, 67% of respondents say that AI coding assistants are widely deployed among development teams. These assistants can generate code in seconds, enabling teams to accelerate development. However, there are several worrisome downsides.
Not all AI-generated code is secure by design. There’s a risk that generated code may contain insecure, outdated, or inappropriate patterns. To protect against flaws, AI-generated code security is ensured by thoroughly reviewing and testing the code before it is submitted to production.
Of the leaders surveyed in the Salt Security report, 90% cited concerns about the security of AI-generated code. They worry that testing isn’t complete, or that it doesn’t align with internal security policies. To combat this risk, organizations must implement strong governance, including a list of approved tools, review and testing requirements, and accountability when AI-generated code goes wrong. A manual review process must be part of the development process, especially in scenarios involving sensitive logic.
Supply chain security vulnerabilities exist wherever there’s a dependency on a third-party vendor, open-source package, or tool. As many software applications rely on third-party components to extend features and enhance usability, vulnerabilities pose a considerable risk. The Open Worldwide Application Security Project (OWASP) lists software supply chain failures as A03 in the OWASP Top 10:2025, a list of web application security risks.
Checking libraries for known vulnerabilities isn’t enough to curtail the dangers of a supply chain breakdown. Instead, organizations must take a comprehensive approach to managing third-party dependencies. Application security best practices include:
Apply a clear change management process across the supply chain that tracks changes to the code repository, infrastructure, container images, and artifacts. Integrating artifact signing can help verify that changes are authentic and retain their integrity.
Instead of treating security as the final step before product deployment, teams are integrating it throughout the build process. This approach follows recommendations by the National Institute of Standards and Technology (NIST) and the Cybersecurity and Infrastructure Security Agency (CISA).
Under CISA guidelines, Secure by Design requires investing resources at each stage of the development process, rather than “bolting” them on later. Under this policy, security is prioritized as a must-have, even if its features aren’t obvious to customers.
NIST includes several techniques in its Secure Software Development Framework (SSDF) Version 1.1 that teams can implement for a Secure by Design approach. They include:
A Secure by Design approach can’t protect against every cyber threat, but it does reduce the likelihood of a successful attack.
Applications that pass security testing still face risks, particularly when they’re run in environments outside a software provider’s control. Potential threats include:
Avoiding these risks requires layered application hardening, which includes:
Application-hardening tools may offer protection for desktop and server applications. For example, PreEmptive provides support for .NET, JavaScript, and Java applications with its portfolio of tools.
Keep in mind that application hardening complements other security measures, including vulnerability scanning, access controls, secure coding practices, and patching. It’s still critical to apply these practices throughout the software development life cycle.
The 2026 Verizon Data Breach Investigations Report found that the exploitation of vulnerabilities is now the leading access vector for data breaches, accounting for 31% of attacks. Hackers are exploiting application security vulnerabilities to steal user information and sensitive business data.
The rise in vulnerability exploitation makes it critical for teams to identify security flaws, prioritize fixes, and implement patches before bad actors can exploit them. Methods that can assist in this process include:
Application hardening acts as a single layer in a comprehensive security strategy. It won’t eliminate the need to patch vulnerabilities or fix vulnerable source code. However, it serves as a key deterrent to hackers seeking to inspect or tamper with a deployed application.
APIs are integral to many mobile and web apps. They extend an application’s functionality and deliver features that users want. However, they’re also a frequent target among bad actors seeking to compromise them for their own benefit.
The most recent OWASP API Security Top 10 lists several mobile application security risks that APIs carry:
Rate limiting is another concern. Without proper controls on API requests, bad actors may take an application offline by hijacking its infrastructure. This can lead to significant expenses and downtime.
In mobile and client-side applications, attackers may access deployed code using special tools. Exposed JavaScript, .NET, Java, and MAUI applications can reveal sensitive information, including proprietary logic, security mechanisms, sensitive strings, API endpoints, credentials, and application workflows.
PreEmptive tools are not API security products, but they help protect the client-side and distributed application code that communicates with APIs. They should be used alongside API testing, access controls, API gateways, server-side authorization, and monitoring.
Security teams receive a barrage of daily security alerts. This can lead to alert fatigue, in which alerts go uninvestigated due to team burnout or an inability to respond.
To combat this risk, organizations are adapting new ways to interpret alerts and prioritize them effectively, such as:
Clear insight into each security alert’s overall risk profile helps teams define a relevant action plan without overwhelm.
Secure software development starts with a plan. Implement this checklist to enhance application security before and after deployment.
PreEmptive provides application-hardening tools that add build-time and runtime protection to deployed software, making it harder for attackers to reverse engineer, tamper with, or debug applications after release.
Our tools add build-time and runtime protections to deployed software, making it harder for attackers to reverse-engineer, tamper with, or debug the applications your team works so hard to build.
We offer a range of products for different platforms. They include:
Each of our products uses a layered defense to protect your codebase from attacks. Code obfuscation renders codebases unreadable, while string and resource protection can make embedded strings and resources harder to extract or interpret, reducing the value of static inspection.
PreEmptive products include runtime environment checks that identify when a user is operating your application in an unauthorized environment. Also included are anti-tampering and anti-debugging tools that detect and block attacks according to your settings. Our tools integrate with standard CI/CD workflows, making them easy to implement into your software development process.
To explore PreEmptive’s application protection options, start your free trial today.
Rising DevSecOps trends include the safe use of AI-generated code, minimizing software supply chain risks, and applying Secure by Design guidelines recommended by NIST and CISA. Protecting against vulnerability exploitation, safeguarding API and mobile security, and implementing runtime protection and risk-based automation are other notable trends.
AI enables teams to code faster, thereby supporting shorter development cycles. It’s also useful for analyzing attacks, triaging open vulnerabilities, and applying remediation. However, there’s another side to the coin: AI increases attack speed, leaving applications open to threats if not properly protected. Organizations must implement AI governance policies to ensure AI-generated code is properly reviewed before implementation.
Runtime application protection helps applications detect and respond to post-deployment threats, such as tampering, debugging, hooking, emulator use, or unsafe runtime environments.
Application hardening uses code obfuscation, control-flow transformation, and string encryption to make software more resistant to reverse engineering and runtime manipulation. Vulnerability scanning reviews source code, dependencies, configurations, or deployed assets for known weaknesses. Application hardening makes shipped software harder to inspect, modify, or abuse. The two approaches complement each other.
Modern applications use various third-party components, including packages, build systems, and dependencies, to enhance their functionality. These third-party components introduce new risks to the final application because they’re not under the development team’s control.