A researcher on a shared cluster hits a wall that anyone who has run a multi-user Kubernetes cluster knows well.
Say they need a new AI agent and a web IDE for a project. In a standard Kubernetes environment, you write the deployment manifest for that. You spell out the container image, resource requests, storage class, PVC definition, service, ingress, and Nginx configuration. For a single workload with GPU access and shared storage, you are looking at several hundred lines of YAML before anything runs. Then you do it all again for the IDE.
That researcher is not a Kubernetes engineer and should not have to be. The cluster exists to run their work.
We had already built the cluster and already fixed the storage permissions problem. The gap left was between “the infrastructure works” and “the researcher can use it without knowing anything about Kubernetes.” That gap is where most research computing infrastructure lets down the people it is supposed to serve.
A lot of people build products that make managing Kubernetes easier. Almost nobody builds the part that makes it easy for the end user to get at what Kubernetes is running. That is the part we cared about.
We heard the same thing over and over at PEARC this summer. Research computing people would stop by the booth, hear the word Kubernetes, and get cautious. A lot of them already run Slurm and know it well. They want what Kubernetes can do without taking on another system to babysit. Once we told them the Kubernetes side is handled automatically, people were a lot more open to the rest of it.
What self-service has to get right
Self-service compute sounds easy until you list what has to go right every single time a researcher clicks a button.
The workload has to land on the right hardware. A GPU environment has to schedule on a node with a GPU. A web IDE can land anywhere with free CPU. The scheduler handles placement, but only if the nodes are labeled correctly and the resource requests are accurate, so the templates have to encode those requirements correctly.
The storage has to attach with the right permissions. As the post on shared storage permissions explains, that means the researcher’s POSIX identity gets injected before the container starts. The template has to point at the right storage and the mount has to use the right path. None of it can ask the researcher to configure anything.
The network has to route correctly. The workload needs an ingress route so the researcher can reach it in a browser. That route has to be generated, never hand-configured. For apps that sit behind Nginx, its config has to match the app.
And all of that has to happen in about sixty seconds, because a researcher who clicks a button and waits five minutes goes back to filing tickets.
How the pipeline works
When a researcher clicks a template card in Orion Workspace, the launch request goes to kuiper, the Orion Workspace service that launches workloads.
First, kuiper looks up the template the researcher picked. It asks titan, the Orion Admin identity service, for that researcher’s UID, GID and groups, and it works out which storage mounts those groups are allowed to see.
Every template is a Helm chart under the hood. So the next step is that kuiper fills the chart in with the researcher’s identity and mounts, renders it, and applies the result to the cluster. It also saves the values it used in a ConfigMap named after the workload, called the kuiper-config. That ConfigMap is the record of exactly what was launched and for whom.
What the chart produces depends on the app. The web IDE template, for example, renders a StatefulSet with an Nginx sidecar in front of the editor, a Service, a PersistentVolumeClaim, an Ingress route and a network policy. The researcher’s UID and GID go into the workload as it is rendered, which is how files they write to shared storage end up owned by them.
The researcher writes zero lines of configuration for any of that. They watch progress update live over a WebSocket, and about sixty seconds later their environment opens in Orion Workspace’s full-screen viewer.
The template itself was written once, by an IT administrator in Orion Admin. They set the resource limits, storage class, GPU requirements, and access controls. The template form fills its options from live cluster state, so the storage classes, priority classes, service accounts, and storage volumes it offers are the ones that actually exist for the project. Template authors pick from real cluster resources instead of typing names that may or may not exist, so nobody gets a deploy-time error from a mistyped storage class.
Think of it as a restaurant. The administrators are the kitchen and decide what is on the menu. The researchers order off the menu and never have to walk into the kitchen.
What the catalog looks like today
The official Orion Apps store has over 50 plugins covering most standard research workloads. That includes Jupyter notebooks, a VS Code web IDE, a web terminal, AI coding agents, n8n workflow automation, local LLM inference through vLLM and Ollama, KubeVirt virtual machines, Helios VFX workstations, and infrastructure plugins like GPU Operator, Prometheus, and cert-manager.
Every plugin is a Helm chart, so the catalog is open to any Helm chart you package for it. If you go looking in the repos or the Helm values, the Orion Apps service is called terra, which is why you will see plugins described as terra-compatible. For workloads that are not in the official catalog, someone who knows Helm packages the chart as a plugin in their own Git repository and adds that repository to Orion Apps as a source. The researcher still sees a card and still clicks it. The packaging is a one-time job. Every deployment after that is automatic.
IT teams sometimes push back on self-service, and their reasons are fair. If anyone can launch any workload, IT loses control over resource use, storage and security posture. So the template system is the control point. Administrators decide what resources each template can use, which storage it can reach, and which users can deploy it. Researchers deploy inside those limits without ever seeing them. The IT team writes templates once and stops provisioning individual environments.
What this changes for research institutions
The ticket queue in research computing comes from the access model, and more staff will not fix it. When the only way to get an environment is to ask IT to build one, IT is the bottleneck no matter how many people are on the team.
When researchers can launch their own environments from pre-approved templates in about sixty seconds, the ticket queue for new environments mostly disappears. IT’s job moves from provisioning one environment at a time to maintaining the template catalog. One template covers every researcher who would have filed a ticket for that environment. The IT team does the same amount of work, and now that work scales.
It also changes what the hardware does. Enterprise on-premises GPU utilization typically sits at 10 to 15% (sources). The GPUs are there. The path from “I need a GPU environment” to “I am using one” has enough friction that work either waits behind a ticket or runs on whatever the researcher could get. The hardware stays the same and the access model changes.
For institutions that have struggled to justify Kubernetes to non-technical stakeholders, this is the interface. Kubernetes tooling assumes the person running the cluster is the same person doing the work. In research computing, those are two different people. Some of them should learn Kubernetes and some never need to, as long as the people who need compute are not blocked by the people who operate it. Orion is built for both of them.
Orion does not make Kubernetes go away. It cannot run without a cluster underneath, and Kubernetes is still there doing its job. The researcher just never has to look at it.
Windows-only tools can run on the same cluster too, in KubeVirt VMs. VMs on Orion shows how.
See how Orion handles self-service research computing. Book a demo
WRITTEN BY
Alex Hatfield
Alex co-founded Juno to fix how enterprise compute gets done. He leads product vision and customer strategy, and spends most of his time working directly with infrastructure and research teams pushing the limits of what their hardware can do.
