Platform Engineering Maturity: Where Swiss Companies Actually Stand

The Gap Between Narrative and Reality

Every CTO deck I've seen in Romandy over the past year mentions "platform engineering." It's become table stakes vocabulary. But when you dig into what's actually running — what teams actually use day-to-day — the picture is far less polished.

I've talked to roughly 40 engineering leaders across Geneva, Lausanne, and Zürich in the past six months. Here's what I actually see on the ground.

The Four Stages I Keep Encountering

Stage 1: Shared Scripts and Good Intentions (~35% of companies)

This is where most mid-size Swiss companies sit. Someone on the infrastructure team wrote Terraform modules. There's a shared Helm chart repo. Maybe a CLI tool that three people know how to use.

There's no dedicated platform team. There's no internal developer portal. There's a Slack channel called #devops-help where one senior SRE answers questions between incidents.

This isn't platform engineering. It's tribal knowledge with a Git repo.

Stage 2: Centralized Tooling, No Product Thinking (~40% of companies)

This is the most common stage among larger Swiss enterprises — banks, pharma, insurance. They've invested real money. They have a "platform team." They run Kubernetes. They might even have Backstage deployed.

But the platform was built top-down. Mandated by architecture boards. Developers weren't consulted on what they actually need. The golden paths feel more like golden cages.

One Geneva-based fintech I spoke with had a platform team of eight engineers. They'd built an impressive internal deployment pipeline. Adoption was under 30%. Why? Developers couldn't run anything locally that resembled production, so they routed around the platform entirely. Eight engineers building something most of the org actively avoided.

The missing ingredient: treating the platform as a product with actual users, not as an infrastructure mandate.

Stage 3: Platform as Product (~20% of companies)

A smaller group has figured this out. They have product managers — or at least product-minded engineers — running the platform. They track adoption. They do user research with their own developers. They measure time-to-first-deploy for new services.

A Lausanne-based scale-up I know reduced onboarding time for new engineers from two weeks to less than a day. Not by writing better documentation. By building a self-service flow that provisions a full dev environment, CI pipeline, observability stack, and staging namespace from a single create-service command. New engineer pushes code on day one.

That's the unlock. Not the tooling. The obsession with developer experience as a measurable outcome.

Stage 4: Full Internal Developer Platform (~5% of companies)

Almost nobody in Switzerland is here yet. This is where the platform abstracts away infrastructure entirely. Developers declare intent — "I need a service that handles 10k req/s with a PostgreSQL backend" — and the platform handles provisioning, scaling, security baselines, compliance controls, and observability.

A handful of global companies with Swiss engineering offices are approaching this. Most homegrown Swiss companies aren't close. And honestly? Most don't need to be. Stage 3 delivers 80% of the value.

Why Switzerland Specifically Lags

Three factors slow us down:

Regulatory caution. Financial and health sector companies default to control over autonomy. Platform engineering requires trusting developers with self-service. That's a cultural shift many compliance teams resist.

Small team sizes. A dedicated platform team is a luxury when your entire engineering org is 30 people. The ROI math doesn't work until you hit roughly 50-80 engineers. Many Swiss companies sit below that threshold.

Outsourcing legacy. A surprising number of Swiss enterprises still outsource significant development. Building an internal developer platform when half your developers are contractors rotating every 12 months is a different — and harder — problem.

What Actually Moves the Needle

Stop buying tools and start measuring developer experience. Literally. Survey your engineers quarterly. Track cycle time, deployment frequency, and time-to-first-deploy. If you can't measure it, you can't improve it.

Start with one golden path, not a whole platform. Pick your most common workload — probably a REST API on Kubernetes — and make deploying that stupidly easy. Nail it. Then expand.

Hire (or grow) a product-minded platform lead. Not someone who loves Kubernetes. Someone who loves making other engineers faster.

The Takeaway

Most Swiss companies are stuck between Stage 1 and Stage 2 — they have tooling but not a platform. The jump to Stage 3 isn't primarily a technology problem. It's a product thinking and organizational trust problem. The CTOs who internalize that will ship faster than the ones buying another CNCF tool.