Security | Threat Detection | Cyberattacks | DevSecOps | Compliance

Some of the most dangerous vulnerabilities in modern web apps are the default features left switched on where they were never meant to be reachable. The first entry in our Findings from the AP series looks at an exposed actuator endpoint. On paper, this finding started the same way most do: an HTTP endpoint returned a 200. Nothing about that response looks unusual by itself. It’s the kind of line that gets logged, categorized, and moved past in most automated scans.

On 26/05/2026, a security researcher at Astra Security found a critical Remote Code Execution (RCE) vulnerability in UpSnap, a web-based wake-on-LAN(WoL). The root cause is an OS Command Injection vulnerability(CWE-78) that exists in UpSnap’s device management functionality due to unsafe template interpolation of the IP and MAC fields.

You ship to production every day while your last pentest happened 11 months ago. Just say that sentence out loud, and we ought to rest our entire case of autonomous pentesting for SaaS companies right there. Everything below is just the supporting evidence. The mismatch isn’t subtle. Your engineers deploy continuously, your infrastructure reshapes itself weekly, and your security validation still runs on a calendar designed for software that shipped twice a year.

Ask any security engineer what they actually think about their vulnerability scanner, and you will get a version of the same answer. They trust maybe 20% of what shows up in the patching queue. The rest gets a suspicious glance, and a slow death in a backlog. That is the real cost of a false positive. It is quiet, it compounds, and it hollows the tool out from the inside. It is also the reason autonomous pentesting came to replace hypotheses with confirmed exploits.

Most engineering teams believe they solved secret scanning the day they flipped on GitHub’s default toggle, but the game doesn’t stop there. In many cases, an overlooked leak can spiral into a severe data breach, especially when an LLM is connected to sensitive data, internal APIs, or production infrastructure. Exposed credentials are hot and always in demand, and there’s plenty left online for bad actors to hunt.

Have you ever tried to answer “Is this container safe to run?” If yes, then you know how tricky that question is. Securing containers is one of the toughest jobs in security, and hunting vulnerabilities across an estate of them gives security folks the same vibe as hunting in the fifth domain. Container vulnerabilities can live almost anywhere, from the image layers down to the kernel, and every week, a new base image, a new dependency, or a new manifest change opens a fresh gap.

Ever wonder why a codebase that passes every test in CI still shows up in a breach report six months later? Simply put, tests check whether code works. They rarely check whether code can be abused. Say you build a house with a solid lock on the front door but leave a window unlatched around back. The house still works as a house. It just isn’t secure, and nobody notices until someone climbs through that window. That’s the gap a code security review is built to close.

Somewhere right now, someone is spinning up a fresh Kubernetes cluster, feeling pretty good with a basic firewall, skimmed a hardening guide, and maybe even applied a few CIS benchmarks. What could possibly go wrong? Roughly 18 minutes. That’s the average time before a newly exposed Kubernetes cluster receives its first malicious probe or attack attempt. So there’s zero room for error when it comes to securing Kubernetes.

The shift to cloud-native infra has broken the traditional perimeter security model. Modern cloud environments are dynamic, heavily distributed, and identity-driven, creating security challenges that conventional security tools were never built to address. Traditional SIEM and vulnerability management tools lack native capabilities to detect issues in IAM policies, S3 bucket ACLs, or the blast radius of a misconfigured Kubernetes node pool.

Run any mature scanner against a container image you built yesterday, and you will likely see dozens — sometimes hundreds — of CVEs. Most of them sit in code you never wrote. That is the uncomfortable reality container image scanning exists to deal with: modern images are assembled from layers of inherited software, and every layer carries someone else’s vulnerabilities into your production environment.