How a Global Bank Reclaims Off-Hours Trading Compute Without Breaking Attestation
)
Summarize with AI
Monetize GPU Infrastructure with Mirantis k0rdent AI
15 years of infrastructure expertise, now in a GPU PaaS that makes your AI hardware productive the day it lands.
PUT YOUR GPUS TO WORK
Trading firms typically maintain a vast compute footprint sized to handle extreme demand: peak order flow, full risk recalculation, and every machine under load. However, the equity trading session this fleet supports runs about six and a half hours, which leaves the hardware out of service for most of the day and all weekend. Meanwhile, a firm's research and platform teams queue for capacity on entirely separate fleets. Reclaiming that capacity isn't so simple, though. The big obstacle is the audit. Regulated trading hardware is attested, and must demonstrably hold no residue of any workloads it ran out of hours.
One of the world's biggest banks runs about 10,000 such attested systems, according to the talk this post is based on, and has turned its off-hours hardware into usable capacity without breaking attestation. This blog gives an overview of the deployment patterns the bank implemented to make this possible.
Based on a talk by Mirantis Field CTO William Rizzo at KubeCon EU 2026
Trading Nodes Cannot Hold Cluster State
This is a control-plane / data-plane separation problem, not a cluster-lifecycle one. The trading nodes can hold transient workloads but cannot hold cluster state, because state is residue that will cause an audit to fail.k0rdent, Mirantis's open-source multi-cluster Kubernetes control plane, treats the hosted control plane as first-class through itsk0smotron control plane provider. A child cluster's control plane always runs as pods inside the management cluster, never on the trading nodes. When markets open in the morning, the cluster shrinks back to control-plane-only, leaving no state on the reclaimed hardware. When markets close, the cluster expands back into the pool without a rebuild, so there is no configuration drift or lost state to deal with.
k0rdent bundles the engine for this, built from the following components: Cluster API for cluster automation, Flux for GitOps, Kyverno for governance, MetalLB for on-premises load balancing, andk0s, Mirantis's minimal upstream Kubernetes distribution. The value that k0rdent brings is not the components, which are all open source projects. It is that the operator can declare a composable template, rather than re-establishing it per cluster class: the MetalLB pool a child control plane will claim is defined before that cluster exists.
Every Workload Runs Inside a Micro-VM
Kata Containers (kata-cc), an open source container runtime, wraps each pod on the reclaimed hardware in a QEMU micro-VM, so the pod's state stays off the host. The CNCFConfidential Containers project builds on Kata to add TEE-backed attestation. However, the bank's current hardware generation doesn't include a trusted-execution-environment (TEE) chip, so that silicon-rooted layer is not possible today. Thus, what enforces isolation here instead is Kata's VM boundary itself, not confidential computing in the encrypted-memory sense.
Crucially, no developer needs to opt into this. A mutating admission webhook rewrites every deployment's runtimeClass to kata-cc before the pod is scheduled. The developer doesn't select the confidential runtime or even know that it was applied: the workload simply runs inside it. Compliance becomes a property of the platform, rather than a manual step the application team can forget.
Safe Failure Mode Decides the Design
There are two ways to implement that mutation, and the real difference lies in the level of risk that results when the mechanism breaks:
Kyverno mutating policy: This approach is declarative, upstream, and the natural long-term successor. But if it is misconfigured or unavailable, the mutation silently stops, and workloads are scheduled without the confidential runtime. The audit signal breaks invisibly, and non-compliant pods can start to run, with nothing flagging them.
Custom mutating admission webhook: With this method, there is more code to own and maintain. But if it is unavailable, scheduling stops entirely. For a compliance gate, a hard stop is the correct way to fail.
The custom webhook is the best choice, because a hard stop is recoverable and silent non-compliance is precisely the contamination the audit is designed to catch. Kyverno stays in the architecture for validation, specifically for asserting the runtimeClass, restricting image pulls to the internal Artifactory registry, and enforcing resource limits and naming.
The Lifecycle Is Bounded by the Trading Day
When the trading day ends, claim windows open, and teams donate machines from their staging and dev pools into the ephemeral cluster. A time-based scheduler accepts each donation with an explicit start and end window and a graceful drain contract. An emergency kill switch sits behind both. The drain finishes before the morning's pre-open integrity checks begin, with every machine back in its audited state, so the checks pass exactly as they would have on a fleet that ran nothing overnight.
The scheduler,5-Spot, was created by the bank's platform engineering team and is now an incubatingFINOS project. It owns only this time-bounded lifecycle: when a machine enters the pool and when it must leave. The reusable artifact here is not the scheduler, though. It is the pattern, which combines hosted control planes with confidential-runtime mutation and then bounds the whole loop with time-based claim windows.
The Trust Boundary Will Move Below Kubernetes
The runtime boundary is today's enforcement layer. In the future, attestation will move down the stack, so that what runs is provable from the OS up. Four layers are under construction:
Kairos: a CNCF framework for immutable, OCI-built Linux distributions, producing golden OS images that cannot drift between boots.
TPM (Trusted Platform Module) measured boot: attesting the booted OS to a remote attestation server before any workload runs.
SPIFFE/SPIRE: CNCF workload identity, giving each pod a cryptographic identity rather than relying on network position.
Confidential-runtime attestation: binding workloads to the runtime boundary itself, so the isolation can be verified, not assumed.
Two gaps are important to note. First, the bank's current hardware generation has no TEE chips, so silicon-rooted isolation is not yet available. Second, confidential GPU execution is still maturing across the ecosystem, so GPU-accelerated confidential workloads are not yet part of this pattern. Both are on the bank's roadmap for this pattern.
What Holds the Pattern Together
Take any of these principles away, and the implementation stops paying for itself:
Compliance costs developers nothing. The webhook applies the confidential runtime and the platform carries the audit's guarantees, so the application team writes ordinary Kubernetes manifests and the compliance posture is handled beneath them.
Off-hours hardware does real work. Most of every weekday, plus weekends, across roughly 10,000 attested machines gives the research and platform teams that were previously queuing on separate fleets a substantial amount of capacity. That work gets done sooner, on machines that are already running.
The control plane is not optional. Without k0rdent, or something shaped like it, the operator has to hand-wire Cluster API, GitOps, policy, load balancing, and bootstrap for each cluster class, indefinitely, and work out the safe failure mode again each time.
If your organization operates expensive hardware that an audit keeps out of service on a schedule, you can adapt this loop to your own attestation requirements rather than rebuild it from parts.Request a k0rdent briefing to learn how to build an ephemeral-Kubernetes pattern for your own environment. The pattern is not specific to trading floors. It can apply to any fleet an organization owns that compliance or operations keep on a fixed schedule.
)
)
)
)
)
)
