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.
| Signal | Old silo | New silo |
| Language | “That is not my job” | “We can handle this ourselves” |
| Presence | Nobody shows up | The team shows up, does not ask |
| Failure mode | Work never starts | Work starts, then stalls at the missing piece |
| Cost | Late, visibly | Late, 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:
- Deadlines reward visible progress. A deployed DaemonSet and a dashboard are easy to show. Agreeing on expected behaviour, exception handling and verification is less visible, but it decides whether the deployment means anything.
- Security looks like an approval queue. If every question to a security team turns into a review and a long wait, a well-run engineering team will reasonably try to work around it. That is a design problem for security teams, not a character flaw in platform teams.
- Prevention is hard to measure. Shipping independently is easy to demonstrate. An early conversation that prevents rework produces a problem that never happens.
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:
- A runtime detection engine such as Falco ships with general-purpose rules. Turning its output into signal requires knowing what each workload is expected to do, and that knowledge lives with the teams that build and run those workloads.
- An admission controller such as Kyverno or OPA Gatekeeper can block or only report. Choosing between those modes is a risk decision, not a configuration detail.
- Kubernetes audit logging produces evidence only if someone has decided what to record, how long to keep it and who reads it.
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 question | Where it lives in the cluster | Who has to agree |
| Which workloads may run, and with which security context? | Pod Security Standards via Pod Security Admission, or equivalent admission policies | Platform 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 audit | Security defines, platform operates |
| What does normal runtime behaviour look like? | Falco rules, lists, macros and rule exceptions tuned per workload | Application teams, with security |
| Who can approve an exception, and when does it expire? | Kyverno PolicyException resources, Gatekeeper constraint exclusions, Falco rule exceptions | A 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 retention | Security 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:
- Keep policies in a repository, alongside the admission policies, Falco rules and audit policy that implement them.
- Make ownership explicit with code owners. A CODEOWNERS file can require review from security for the paths that define block-or-report decisions, and from application teams for the runtime rules that describe their workloads. Ownership stops being implicit knowledge.
- Turn exceptions into pull requests. Each exception records the policy it bypasses, the workload it applies to, who approved it and when it expires. Expiry needs enforcement too, such as a scheduled CI check that fails when an exception has passed its date. An exception with no expiry is a permanent policy change nobody reviewed.
- Start in report mode on purpose. Running new policies in Audit or warn first is a good practice, as long as there is an agreed date and owner for the move to enforcement. Otherwise report mode becomes the permanent state.
- Publish a clear contact and response expectation for each owning team. A code owner who takes three weeks to review is an approval queue with better tooling.
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:
| Decision | Who should hold it | How it usually fails |
| Define the expected outcome | Security, risk or architecture | A policy statement nobody can test |
| Implement and operate it | The team that owns the platform or service | Security ends up doing it, or it is done once and never maintained |
| Accept the residual risk | A role with authority over the service and the budget to remediate | Whoever understands the technical detail, or security by default |
| Verify it stays effective | Security or another independent function | Implementation 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
- Kubernetes, Pod Security Standards and Auditing
- Falco documentation
- Kyverno documentation
- OPA Gatekeeper documentation
- Sigstore documentation
- NIST Cybersecurity Framework 2.0 (CSWP 29): GV.RR-02, GV.RR-03, ID.RA-07
- Directive (EU) 2022/2555 (NIS2), Article 20
- Regulation (EU) 2022/2554 (DORA), Article 5
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.