Skip to content

All posts

KyvernoKubernetesBusiness

How Kinexys by J.P. Morgan Makes the Right Way the Easy Way with Kyverno

Jim Bugwadia

Kyverno: How Kinexys by J.P. Morgan Makes the Right Way the Easy Way with Kyverno

Kinexys by J.P. Morgan runs Kyverno as the policy layer of its EKS-based Kubernetes platform. A small platform team uses it to validate common misconfigurations, set safe defaults, restart workloads when certificates rotate, block risky RBAC and gate Argo CD syncs to approved change windows. Every policy ships through Git and Argo CD and starts in Audit mode.

Justin Munoz, Principal Software Engineer at Kinexys by J.P. Morgan, shared the story with Kyverno maintainer Jim Bugwadia at KubeCon + CloudNativeCon North America 2026 in Salt Lake City, in the maintainer track session “The Next Generation of Kyverno: Unified Policy as Code at Scale”. This post covers the platform, the four use cases, the adoption journey and the move to CEL.

Where the platform team started

Justin’s team is a small cloud platform team running an EKS-based Kubernetes platform. It owns the clusters and their add-ons, platform configuration, networking, security and the Kubernetes-related infrastructure as code. Delivery is Git-driven, and workloads follow standardized patterns, a paved path.

Challenges Consistent security, compliance and resiliency standards across teams and clusters. The biggest risk is disruption when moving from observation to enforcement. Policies must be understandable and maintainable by generalist engineers.
Goals Make the right way the easy way. Enforce what must be enforced, and automate what can be automated. A repeatable, scalable baseline footprint.

“Make the right way the easy way” is the line the rest of the story hangs on. A small team can’t review every manifest by hand, so the platform has to make the compliant choice the default one.

Four use cases at a glance

Use case What Kyverno does Main beneficiary
Namespace baseline and hygiene Catches common misconfigurations, sets safe defaults, and sets a baseline RBAC and network posture Operators
Certificate rotation Triggers a rolling restart when a certificate is renewed Developers
nodes/proxy hardening Denies risky RBAC and verifies existing roles Security
Change management gate Allows Argo CD syncs only inside an approved window Security and operators

The common thread: every use case ships through Git and Argo CD, and starts in Audit.

Mutate in practice: certificate rotation

When a certificate is renewed, the Secret that holds it is updated in place. The pods using it don’t notice until they restart, and a certificate that expires inside a running pod is an outage.

  1. The certificate is renewed, and its Secret is updated in place.
  2. The Secret is opted in: it is annotated for restart and names the workload it belongs to.
  3. Kyverno patches the workload. The background controller updates the pod template’s restartedAt annotation.
  4. A rolling restart picks up the new certificate. No manual restart, and no expired certificate.

Mutation isn’t only for new requests. Kyverno can also patch what’s already running. This excerpt from the talk targets an existing Deployment. It uses the legacy ClusterPolicy syntax, which Kyverno 1.20 no longer processes, so a new version belongs in a CEL MutatingPolicy:

match:
  resources: {kinds: [Secret]}
preconditions:
  all:
  - {key: '{{ request.operation }}', operator: Equals, value: UPDATE}
  - key: '{{ request.object.metadata.annotations."restart-deployment" }}'
    operator: Equals
    value: enabled
mutate:
  targets:                          # an EXISTING Deployment
  - apiVersion: apps/v1
    kind: Deployment
    name: '{{ request.object.metadata.annotations."deployment-name" }}'
    namespace: '{{ request.object.metadata.namespace }}'
  patchStrategicMerge:
    spec:
      template:
        metadata:
          annotations:
            kubectl.kubernetes.io/restartedAt: '{{ time_now() }}'

From finding to guardrail: nodes/proxy

A get permission on nodes/proxy looks read-only, but it reaches further than expected. It isn’t a CVE: the behavior is by design upstream, so there is no patch to wait for. The team turned the hardening gap into a platform-wide guardrail, the same way it ships any other change:

  1. Identify the permission that reaches further than it looks.
  2. Codify it as one validate rule that denies Roles and ClusterRoles granting get on nodes/proxy.
  3. Audit and verify with Audit mode and a background scan of existing roles before enforcing.
  4. Enforce. Future grants are blocked, and the message points to nodes/metrics or nodes/stats.

This one is already a CEL ValidatingPolicy. The risky variable does the work. We added the API group check to the excerpt from the talk, so the policy doesn’t flag read-only rules in other API groups:

validationActions: [Deny]
matchConstraints:
  resourceRules:
  - apiGroups: [rbac.authorization.k8s.io]
    apiVersions: [v1]
    operations: [CREATE, UPDATE]
    resources: [roles, clusterroles]
variables:
- name: risky
  expression: >-
    object.?rules.orValue([]).exists(r,
      r.?apiGroups.orValue([]).exists(g, g in ['', '*']) &&
      r.?resources.orValue([]).exists(x,
        x in ['nodes/proxy', 'nodes/*', '*']) &&
      r.?verbs.orValue([]).exists(v, v in ['get', '*']))
validations:
- expression: '!variables.risky'
  message: Grants get on nodes/proxy; use nodes/metrics or nodes/stats

Kyverno as a change management gate

Some changes should only reach production inside an approved change window. Because every Argo CD sync is an update to an Application resource through the Kubernetes API, Kyverno can check it at admission.

Step What happens
Change system A change record is approved
Change window A time-boxed custom resource opens the window, with a TTL so it closes itself
Kyverno admission check Is there an open, verified window?
Inside the window The Argo CD sync proceeds
Outside the window The sync is denied, with the reason

Force and replace syncs are blocked outright, and that rule is already in CEL. The excerpt below shows the shape of the sync gate: the precondition only matches real syncs, and the context looks up the change window. It is pseudocode, not a working policy. The lookup is left generic, as it was in the talk, so <change-window lookup> stands for whatever call your change-management system exposes, and the invalid value stands for however you map its response to “no open window”. The excerpt also uses the legacy ClusterPolicy syntax that Kyverno 1.20 no longer processes, so write the real gate in the current policy format and test it against your own change data.

match:
  resources:
    kinds: [Application]
    operations: [UPDATE]
preconditions:          # real syncs only
  all:
  - key: >-
      {{ request.object.operation.sync || `{}` }}
    operator: NotEquals
    value: {}
context:                # window lookup
- name: window
  apiCall: {urlPath: <change-window lookup>}   # pseudocode: response is mapped to 'invalid' when no window is open
validate:
  message: No open change window
  deny:
    conditions:
      any:
      - {key: '{{ window }}', operator: Equals, value: invalid}

The adoption journey

The team’s path had four stages:

Stage Focus
1. Pilot Standards turned into policy, in Audit
2. Standardize A policy library, PR reviews and CI tests
3. Scale Enforce by tier, with scoped exceptions
4. Modernize New policies written in CEL

And what Justin would tell another platform team on day one:

  1. Start in Audit. Reports show who would be affected before anything is enforced.
  2. The denial message is the user interface. Developers meet policy through its message, so say what to change and why.
  3. Make the paved path compliant by default. If the common Helm chart already passes every policy, most teams never see a denial.
  4. Ship policies like everything else. The same Git reviews, CI tests and Argo CD sync as any app change.

Next: moving the rest to CEL

The team’s new policies are already in CEL, and the rest need to move. Jim covered why and how in the first half of the session.

Kubernetes adopted the Common Expression Language for its native ValidatingAdmissionPolicy and MutatingAdmissionPolicy. CEL is compiled once and evaluated in-process with a bounded cost, it is sandboxed so it’s safe in the API request path, and it’s the same language Kubernetes uses. Kyverno’s CEL policy types (ValidatingPolicy, ImageValidatingPolicy, MutatingPolicy, GeneratingPolicy and DeletingPolicy) keep Kyverno’s context, generation, image verification, background scans, reports and exceptions on top of it.

Release Legacy ClusterPolicy and ClusterCleanupPolicy
1.17 CEL policy types stable; deprecation begins
1.19 The last release that processes legacy policy types
1.20 CRDs still served, but legacy policies are no longer processed; existing policies aren’t deleted, so rollback stays clean
1.21 CRDs for legacy policy types removed

The Kyverno docs have a migration guide for each rule type, a JMESPath-to-CEL guide and more than 200 sample policies written in CEL. Jim’s tip: use the guides as a skills file in your AI coding tool. The advice from the session’s takeaways is to plan the migration now: shadow, compare, cut over.

Applying the pattern

Two other financial services platforms have told similar stories. Chase UK made Kubernetes audit-ready with Kyverno, and Razorpay automates RBI compliance on 7,000+ nodes. For the rest of the week’s sessions, including AT&T’s attestation-driven admission, see our KubeCon + CloudNativeCon North America 2026 recap. To run Kyverno policies, reports and exceptions across many clusters, see Nirmata Enterprise for Kyverno.

Frequently asked questions

How does Kinexys by J.P. Morgan roll out new Kyverno policies?

Every policy starts in Audit mode. Policy reports show which teams would be affected before anything is enforced, and existing resources are checked with a background scan. Policies ship through the same Git reviews, CI tests and Argo CD sync as any application change, and are enforced by tier with scoped exceptions.

Can Kyverno restart a Deployment when its certificate is renewed?

Yes. Kyverno can mutate existing resources, not only new requests. At Kinexys by J.P. Morgan, a renewed certificate updates its Secret in place. If the Secret is annotated for restart and names its workload, Kyverno's background controller patches the Deployment's pod template restartedAt annotation, which triggers a rolling restart.

Why block get on nodes/proxy in Kubernetes RBAC?

A get permission on nodes/proxy looks read-only but reaches further than expected. It is upstream behavior by design, so there is no CVE or patch to wait for. A Kyverno ValidatingPolicy can deny Roles and ClusterRoles that grant it and point users to nodes/metrics or nodes/stats instead.

Can Kyverno act as a change management gate for Argo CD?

Yes. Every Argo CD sync updates an Application resource through the Kubernetes API, so Kyverno can check it at admission. Kinexys by J.P. Morgan looks up whether an approved, time-boxed change window is open and denies the sync with a reason when it isn't. Force and replace syncs are blocked outright.

Jim Bugwadia, Founder & CEO, Nirmata

Jim Bugwadia is the founder and CEO of Nirmata, the creators of Kyverno. He is an active cloud-native community member who previously held engineering and leadership roles at Cisco, Bell Labs, and Motorola.

LinkedIn

Nirmata Enterprise for KyvernoHardened, enterprise-grade Kyverno.
Share

Stay up-to-date with the latest in AI, governance, and infrastructure

Subscribe to our free monthly newsletter to get industry news, DevOps tips, and articles right to your inbox on Kyverno, containerization, Kubernetes deployment & management and more.