A deadline creates pressure, and a team decides to solve its part of the problem directly.

I once saw this play out in a Kubernetes security initiative. The team had capable engineers, a clear objective and a reasonable concern that asking for help might slow them down. They picked a runtime detection tool, deployed it across the clusters and had a dashboard full of events within a week.

The missing piece was not the tool. It was the baseline: the shared definition of what normal looks like for those workloads and what should be blocked rather than just reported. Without it, every alert raised the same question: is this expected? The people who could answer that sat in another team, and nobody had asked them early enough.

The decision made sense from where the team stood. They had a task, a tool and a plan. What they lacked was the cross-team agreement that makes the tool useful, and confidence that asking for it would get a timely answer.

In cloud native engineering, “we can handle this ourselves” sounds like healthy ownership, and often it is. This post is about the cases where it isn’t, and about the artifact that usually exposes the difference: the security baseline.

The new version of the silo

The old silo was a wall. The new one can be a door that closes without anyone noticing: the team keeps moving and reports progress, but a key conversation never happens.

SignalOld siloNew silo
Language“That is not my job”“We can handle this ourselves”
PresenceNobody shows upThe team shows up, does not ask
Failure modeWork never startsWork starts, then stalls at the missing piece
CostLate, visiblyLate, after looking like progress

Autonomy is not automatically a silo. A team that owns its platform and makes its own decisions is what good engineering looks like. The silo appears when autonomy turns into self-sufficiency: the team stops checking who else holds part of the answer and rebuilds knowledge that already exists elsewhere in the organisation.

Renaming a team does not fix this either. Platform security, cloud native security and DevSecOps are labels; collaboration still depends on how people work together.

Three things make the new silo likely:

A tool working as configured is not a control

The risk is rarely that a tool fails. It is that a tool works exactly as configured, without a shared understanding of what it is supposed to achieve.

The pattern repeats across the cloud native security stack:

None of these are shortcomings of the projects. They are design dependencies: the tool provides the mechanism, and the organisation has to provide the intent.

The baseline is a cross-team artifact

A baseline is not a policy document. It is a short, testable set of answers, and every answer maps to something you can configure and verify in a cluster. The question that matters is who has to agree on each one.

Baseline questionWhere it lives in the clusterWho has to agree
Which workloads may run, and with which security context?Pod Security Standards via Pod Security Admission, or equivalent admission policiesPlatform and security
Which registries and image provenance are accepted?Signature verification with Sigstore enforced at admission (for example Kyverno verifyImages or the Sigstore policy-controller)Security and application teams
What is blocked, and what is only reported?Kyverno Enforce or Audit; Gatekeeper deny, warn or dryrun; Pod Security Admission enforce, warn or auditSecurity defines, platform operates
What does normal runtime behaviour look like?Falco rules, lists, macros and rule exceptions tuned per workloadApplication teams, with security
Who can approve an exception, and when does it expire?Kyverno PolicyException resources, Gatekeeper constraint exclusions, Falco rule exceptionsA risk owner with authority over the service
Which events are retained, for how long, and who reads them?Kubernetes audit policy levels and the log backend’s retentionSecurity operations and platform

A note on naming: Pod Security Standards define a profile called baseline. That profile is one useful input, but the baseline in this post is the wider organisational agreement that includes it.

Looking at the table, no single team owns every row. A platform team that deploys all of these tools alone has implemented the mechanisms and guessed at the intent. That is the new silo in its most concrete form.

Make the baseline cheap to ask about

The answer is not to send platform teams back to a security approval queue. It is to make the cross-team parts of the baseline easy to reach. Treating the baseline as code is a practical way to do that, because it uses workflows engineering teams already know:

Security teams carry half of this. When guidance is hard to find or exceptions are slow, teams have every incentive to work around the process. Autonomy is not the problem. Expensive help is.

Four decisions that rarely belong to the same person

Once a team acts, four decisions have to be made explicit:

DecisionWho should hold itHow it usually fails
Define the expected outcomeSecurity, risk or architectureA policy statement nobody can test
Implement and operate itThe team that owns the platform or serviceSecurity ends up doing it, or it is done once and never maintained
Accept the residual riskA role with authority over the service and the budget to remediateWhoever understands the technical detail, or security by default
Verify it stays effectiveSecurity or another independent functionImplementation is treated as proof, and drift goes unnoticed

The third row is where most programmes quietly break. The person who approves an exception must be able to fund its remediation or carry the consequence if it never happens. Someone who can sign but cannot fund is not accepting a risk. They are witnessing it.

Frameworks describe the same split. In NIST CSF 2.0, GV.RR-02 asks for roles, responsibilities and authorities to be established, communicated, understood and enforced. GV.RR-03 expects resources to match the risk strategy, and ID.RA-07 asks for exceptions to be assessed, recorded and tracked. In the EU, NIS2 Article 20 and DORA Article 5 place accountability on the management body rather than on a security team. None of these require a team to go it alone. They require that authority, funding and the exception path are explicit.

Takeaway

A silo is not a team that stopped asking permission. It is a team that stopped asking for help.

Deploying a runtime security tool, an admission controller or an audit pipeline is the easy part, and a platform team can do it independently. Defining what those tools should enforce is a cross-team decision, and pretending otherwise is how the new silo forms.

A simple habit at kick-off: for each row of the baseline, ask who owns the answer, when it is needed and how to reach them. When work stalls, ask what made going alone seem like the best option before assigning blame. Was guidance easy to find? Could the right people respond in time? Was the exception path clear?

Autonomy works best when a team can act, knows where the rest of the answer lives and can reach the people who have it without friction. Trust and collaboration are not the opposite of ownership. They are what make it sustainable.

References

This post describes an engineering operating model, not a legal interpretation or a universal assignment of responsibilities. Adapt it to your organization’s structure and risk management process.