Shared Responsibility
OLIVE's overall security depends on controls owned by five distinct roles. An unclear boundary between them is itself a security weakness, so the roles are named before the controls are assigned.
The five roles
OLIVE Platform Team — builds the software: the microservices, the shared libraries, the Helm charts, the container images, the security defaults and the release pipeline. Everything this team owns is delivered as an artefact; it operates nothing in production.
Cluster Operator — provides and runs the Kubernetes environment OLIVE is deployed into: the cluster and its nodes, the CNI, ingress and TLS termination, the service mesh platform, storage classes and encryption at rest, the log and metrics platform, backup infrastructure, the GitOps deployment system, and the identity infrastructure used by operator-level administrators. The role is defined by function rather than by team.
Platform Administrator — runs the OLIVE installation on top of that cluster: onboards and offboards tenants, sets the deployment values that switch security controls on or off, creates each tenant's Keycloak realm and sets platform-wide authentication policy, manages tenant lifecycle in Vault, states the log retention and access requirements, and holds the operator-level administrative accounts. This is the role that turns a delivered artefact into a running service.
Tenant Administrator — administers one tenant inside the realm the platform administrator created: its users and their credentials, role assignment within the tenant, MFA enforcement and password policy on that realm, session revocation, and access review. They have no cluster access, no Helm access and no visibility of any other tenant. See the Tenant Administrator guide. Customizer — writes the code that runs inside OLIVE's trust boundary: connectivity definitions, connectors and datapoints, and microfrontend components. This role matters disproportionately: its code executes with the platform's privileges and inside the user's browser session, so a Customizer mistake is not contained the way ordinary application input is.
The end customer as a commercial party is deliberately not a role here. A customer organisation may staff the Platform Administrator, Tenant Administrator or Customizer roles, but "customer" by itself owns no control.
Responsibility matrix
| Area | OLIVE Platform Team | Cluster Operator | Platform Administrator | Tenant Administrator | Customizer |
|---|---|---|---|---|---|
| Application code security | Owns | — | — | — | Owns their own code |
| Helm charts and workload security context | Owns | Validates in cluster | Sets deployment values | — | — |
| Container image build and signing | Owns | Registry operation, verification credentials | — | — | Owns images for own components |
| Dependency and image scanning | Owns (gates release) | — | — | — | Owns for own dependencies |
| SBOM generation | Owns | — | Retains per deployed version | — | — |
| Network policy definitions | Owns | CNI capability, enforcement | Enables in deployment values | — | Uses the documented service label |
| Service mesh mTLS support | Owns (chart support) | Provides and operates the mesh | Enables in deployment values | — | — |
| Kyverno baseline and example policies | Owns | Installs engine, sets enforcement mode | Selects mode, applies namespace labels | — | — |
| Additional organisation-specific policies | — | May own cluster-wide | Owns OLIVE-namespace policies | — | — |
| Keycloak configuration and MFA | Ships hardened example | MFA for operator-level admin identities | Realm creation and platform-wide authentication policy | Owns inside their own realm — user lifecycle, MFA enforcement, password policy | — |
| Role assignment (user / editor / admin) | Provides separation | — | Defines the segregation policy | Owns assignment inside their own tenant | — |
| Vault role and policy design | Owns | Operates instance, seal/unseal, key custody | Applies during tenant onboarding | — | — |
| Secret rotation for infrastructure credentials | Provides mechanism | Owns process for cluster-level secrets | Owns process for OLIVE-level secrets | Rotates the two Keycloak-only client secrets; raises the two mirrored in Vault | — |
| Tenant onboarding and offboarding | Provides tooling | Storage reclaim behaviour | Owns — executes and verifies | — | — |
| Tenant data deletion on termination | Provides mechanism | Backup deletion timelines | Owns execution and evidence | — | — |
| Security event emission | Owns | — | — | — | — |
| Log collection, retention, access control | Defines streams and requirements | Operates the platform; owns retention and access enforcement | States the retention and access requirement per stream | — (cannot reach the log platform) | — |
| Alerting, detection, incident response | — | Owns tooling and platform alerts | Owns OLIVE-level alert rules and first-line triage | — | — |
| Cluster and node hardening | — | Owns | — | — | — |
| Encryption at rest, key ownership | Defines requirements | Owns | — | — | — |
| Backup, restore, disaster recovery | Defines what must be preserved | Owns infrastructure and execution | Verifies OLIVE-level restore correctness | Owns OCB exports of their own connectivity content | — |
| Ingress, TLS certificates, perimeter | States configuration requirements | Owns | Domain and route configuration | — | — |
| Reaching an internal destination (registration) | Provides mechanism; advises via support | Network-level egress controls | Raises the case, applies the advised approach | Raises the case for their tenant | Reports the use case |
| Deployment approval and promotion | Release process and versioning | Operates Argo CD | Owns promotion decisions | — | — |
| Connectivity and microfrontend code security | Provides guidance and guardrails | — | Reviews before enabling | Decides what is enabled in their tenant | Owns |
| Uploaded content and file safety | Provides validation and limits | — | Policy and monitoring | Owns what their users publish | Owns content they publish |
| Risk management, incident reporting, governance | — | Owns for cluster scope | Owns for service scope | Owns for tenant scope | — |
Four notes on the model
Customizer code is inside the trust boundary. Connectors execute with the platform's outbound reach and can be invoked by privileged users; microfrontend components run in the authenticated user's browser. The platform side is addressed — role separation, egress guards, file access controls, CSP — and the rest is documented as Customizer responsibility. That documentation is a control, and it only works if the Platform Administrator reviews Customizer code before enabling it. See the connectivity handbook's security chapter for what Customizers are asked to do.
Connectivity runs as whoever executes it. A connector containing a privileged datapoint does nothing for an ordinary user and succeeds for an administrator, so an administrator who uses their admin account for everyday work becomes a way to perform administrative actions without holding the role. The platform cannot prevent this: keeping admin accounts out of daily use, and out of connectivity execution, is an organisational rule the Platform Administrator has to set and hold. See Security Configuration → Identity and Secrets.
The Platform Administrator holds most of the switches, but not the ones inside a tenant. Network policies, mesh mTLS, Kyverno enforcement mode and the deployment values are all decided there — not by the platform team and not by the cluster operator. What happens inside a tenant's realm is not: user lifecycle, role assignment, MFA enforcement and password policy belong to that tenant's administrator, and the platform administrator sets the policy they work within rather than making each decision.
Several rows are split rather than owned. Backup — infrastructure and execution on one side, verifying that an OLIVE-level restore is correct on the other. Alerting — the tooling and the cluster's own alerts on one side, OLIVE-level rules and first-line triage on the other. Secret rotation, and the monitor objects, divide the same way. These are the rows where an assumption that the other side has it covered goes unnoticed longest, so they are the ones worth reading together.