Container Virtualization DevOps

Kubernetes runtime security needs a shared baseline, not just tools

A runtime detection system can be deployed across Kubernetes clusters quickly, yet still leave teams unsure which alerts matter. In a post published November 16, 2026, Matteo Bisi of Reevo argues that the gap is often a missing security baseline: a shared, testable understanding of expected workload behavior, enforcement decisions and exception ownership.

Bisi describes a pattern in which a team installs a runtime tool and sees events in a dashboard, but has not agreed with application, platform and security colleagues on what normal activity looks like. Without that agreement, alerts prompt basic questions that the tool cannot answer. The people with the relevant workload knowledge may sit elsewhere in the organization, and the team may not have established how to reach them in time.

The argument is not that teams should surrender autonomy or wait for a central security group to approve every change. Rather, Bisi distinguishes ownership from self-sufficiency. A team can make independent technical decisions while still identifying which decisions depend on expertise or authority held by others. When it stops seeking that input, work may appear to progress while an important organizational dependency remains unresolved.

Tools provide mechanisms, not intent

The post applies this distinction across several Kubernetes security controls. Falco can detect runtime activity using rules, but useful signal depends on understanding the behavior expected from individual workloads. That context generally comes from the application teams that build and operate them, with security helping shape the rules and exceptions.

Admission controls also require explicit choices. Kyverno and OPA Gatekeeper can be configured to report or deny policy violations, while Pod Security Admission supports enforcement, warning and audit modes. Deciding which behavior is appropriate is a risk decision, Bisi says, rather than a routine configuration choice. Similarly, Kubernetes audit logging requires decisions about which events to capture, how long to retain them and who will review them.

Image provenance and workload permissions add further cross-team questions. The post points to Pod Security Standards, including the profile named baseline, as one possible input to an organization’s broader agreement. It also cites Sigstore-based signature verification at admission, including Kyverno’s verifyImages functionality and the Sigstore policy-controller. Bisi emphasizes that the organizational baseline is wider than the Kubernetes profile with the same name.

In this framing, the baseline is not simply a policy document. It is a set of answers that can be translated into cluster configuration and checked. The answers span platform operations, application behavior, security policy, risk ownership and audit-log handling. A platform team that deploys controls without those agreements may have installed the mechanisms while making assumptions about the intended outcome.

Make ownership and exceptions visible

Bisi recommends keeping policies and their implementation in a repository, alongside items such as admission policies, Falco rules and audit policies. Code ownership can identify who must review different changes: security for decisions about blocking versus reporting, for example, and application teams for runtime rules that describe their services.

Exceptions can also be managed as reviewed changes rather than informal, indefinite carve-outs. The post suggests recording the affected policy and workload, the approver and an expiry date. A scheduled continuous-integration check can flag exceptions that have passed their expiry. The point is to make the risk decision traceable and ensure that temporary deviations do not silently become permanent.

Starting policies in audit or warning mode can help teams understand their impact before enforcement, but Bisi cautions that report-only operation needs an owner and an agreed transition date. Otherwise, a preparatory phase can become the lasting state. Clear contacts and response expectations matter as well: a named reviewer who cannot respond promptly may leave teams with the same practical bottleneck as a traditional approval queue.

The post separates four responsibilities that can otherwise be blurred: defining the desired outcome, implementing and operating the control, accepting residual risk, and independently verifying that the control remains effective. These responsibilities need not belong to one person or team. In particular, approving an exception should rest with someone able to accept its consequences and, where necessary, fund remediation—not merely someone familiar with the technical details.

Governance depends on workable collaboration

Bisi connects the division of responsibilities to NIST Cybersecurity Framework 2.0 provisions GV.RR-02, GV.RR-03 and ID.RA-07, concerning assigned responsibilities, resources aligned with risk strategy and tracked exceptions. The post also references NIS2 Article 20 and DORA Article 5 in describing management-body accountability. It presents these as governance context, not as a universal assignment of duties or legal interpretation.

The practical kickoff question is straightforward: for every baseline decision, identify who owns the answer, when it is needed and how the team can reach that person. If teams repeatedly work around security processes, the organization should examine whether guidance, response times and exception paths are accessible. The central point is that deploying a Kubernetes security tool is not, by itself, evidence that an organization has defined or verified the control it intends to achieve.