Platform Engineer / Architect — Kubernetes & OpenShift Virtualization

Job Description

Platform Engineer / Architect — Kubernetes and OpenShift Virtualization

Where a workload runs should be a decision about the workload. Nothing else. We've just moved our container workloads off VMware onto upstream Kubernetes, and OpenShift Virtualization is next. We're hiring two platform engineers/architects — one for each platform — to build what developers actually touch, and to set the technical direction while doing it.

DCT
Are you ready to be at the forefront of digital innovation? Join our dynamic team at Tele2, where Digital Capabilities & Technology (DCT) is the engine behind our products and services. As the essential enabler of our commercial
ambitions, DCT brings automation and simplicity to the telecommunications industry, revolutionizing the way we connect and communicate.
Within our organization, you’ll find everything from the backbone infrastructure of technology and IT systems, serving both our external & internal customers, to advanced analytics, AI creation, and frontend development. Our team plays a vital role in ensuring reliable and premium services through delivering exceptional experiences to our end customers, both Consumer and Enterprises, all the while supporting our colleagues within Tele2.

ABOUT THE ROLE
We run workloads on-premises and in Azure and AWS, and we treat all of it as one ecosystem — somewhere a team can put a workload wherever it genuinely fits. We're not there yet; that's the work. On-premises we're building two platforms the same way — one for containers, one for VMs — sharing a GitOps approach and a single self-service front door in Backstage. The managed parts of the wider estate join the same road as we go.

We've just moved our container workloads off VMware onto upstream Kubernetes, built from open-source components we choose and integrate ourselves. Moving our virtualisation estate onto OpenShift Virtualization is the next phase, built the same way, behind the same front door.

We're hiring one person for each platform. They're two jobs rather than two versions of the same job — but they're built alongside each other, on a shared design, by people who sit together.

We treat our platforms as products: users we talk to, feedback that changes what we build, and a hand in shaping what using them feels like.

The title has both words on purpose: you set the technical direction, then you implement it. Call yourself whichever you like — how you approach the problem tells us more than the word on your CV does.

The two roles

Container platform - Kubernetes

Upstream Kubernetes and open-source components we choose and integrate ourselves, from how a cluster comes into existence to what a developer sees when they want one. At the bottom, declarative cluster lifecycle - clusters provisioned, upgraded and replaced as code. In the middle, the platform layer we assemble and run ourselves. At the top, the part developers actually touch: golden paths in Backstage and a self-service API where committing a claim to Git gets you working infrastructure, with policy gates in CI keeping it safe as it scales.

• Own cluster lifecycle: Cluster API, immutable node OS, provisioning, upgrades and fleet management

• Assemble and run the platform layer, choosing and integrating open-source components end to end

• Build what developers actually touch: Backstage templates, golden paths, and a Crossplane-backed self-service API that makes infrastructure a Kubernetes object

• Build the policy guardrails - Kyverno gates enforced in CI, automated repository provisioning and merge automation

• Write Go controllers when the platform needs behaviour nothing off the shelf provides

VM platform - OpenShift Virtualization

We already run OpenShift Virtualization - the work now is everything around it. A multi-cluster platform, with hub clusters managing workload clusters across sites, and a self-service API on top that turns a developer's request for a machine into a provisioned, networked, registered, backed-up VM without a ticket. Behind that API sits a Crossplane composition layer and a Go operator we wrote ourselves.

• Design and build the OpenShift Virtualization platform across hubs, workload clusters and hosted control planes

• Design how we move our existing virtualisation estate onto it, alongside the teams who run those workloads today

• Own fleet configuration as code - Argo CD and Kustomize, with policy-driven configuration distributed across every cluster

• Extend the self-service API and the Go operator that drives VM lifecycle end to end, connecting Kubernetes to the enterprise systems VMs still have to live inside

• Select, integrate and run the substrate underneath - storage, networking, load balancing, logging, network observability, compliance and backup

Both roles

• Own platform security in practice - RBAC, Pod Security Standards, network policy, image and supply-chain scanning - as part of the design, not a review gate at the end

• Keep your platform aligned with the other one and with our public cloud environments, so developers meet one way of working rather than three, keeping developer experience in mind

• Work closely with your counterpart on the other platform, with our platform, SRE and developer teams, and with our end-to-end architects

One application covers both roles. Tell us which platform interests you more, or say you're open to either - both are useful answers.

What we're looking for

We don't count years in this stack. Much of it is new enough that everyone here is still learning it, including us. So we're looking for real depth somewhere in infrastructure, and the drive to build that same depth again in the parts you haven't met yet.

What you'll need:

• Linux and Kubernetes in production, enough that you've hit the sharp edges

• Comfort reading and writing code — ours is mostly Go

• A habit of learning in the open: asking early, sharing what you find, changing your mind when the evidence does

What we're hoping for:

• You've been responsible for clusters in production, not only for what runs on them

• For the VM platform: OpenShift experience, and virtualisation somewhere in your background — with curiosity about what changes when it moves onto Kubernetes

• You work GitOps-first

• You care about Kubernetes security and want to get it right rather than get it signed off

• You like knowing who uses what you build

• You document as you go — security reviews, audits and the people using this platform all need to understand it without asking you

Our stack

• Across both: Argo CD · Kustomize · Crossplane · Go / controller-runtime · Backstage · Kyverno · MetalLB · GitLab CI — alongside Azure and AWS

• Container platform: Upstream Kubernetes · Cluster API · Talos · Harbor · Gateway API and Contour · Multus · cert-manager and trust-manager · External Secrets · CloudNativePG · KubeVirt

• VM platform: OpenShift · OpenShift Virtualization · Red Hat ACM · hosted control planes · Tekton · SR-IOV and NMState · CSI storage · Loki and network observability

Recognising some of this is useful. Recognising all of it isn't expected. If you've contributed to open-source infrastructure projects, we'd like to hear about it.