If you ever find yourself freshly jetlagged in London without melatonin, let me offer a travel tip: the children’s antihistamines are your best friend (emphasis on children’s). Unlike the U.S., where sleep aids are practically an aisle unto themselves, the UK keeps things more…prescription-based. Had I known this earlier in my trip, this wrap-up might have come to you a couple days earlier. But that was only one of many lessons learned during KubeCon + CloudNativeCon Europe 2025—hosted this year in a buzzing, sleepless London that might just give New York a run for its money.
While I navigated crosswalks that kindly told me which way to look (thank you, painted arrows, for saving me from traffic that doesn’t care I’m American), the real disorientation came from trying to make sense of just how fast the cloud-native ecosystem is evolving.
The message at KubeCon EU 2025 was clear: complexity is out, consolidation is in, and modernization isn’t a goal—it’s a perpetual motion machine.
A More Mature Cloud-Native Ecosystem Emerges
Across dozens of analyst briefings, keynotes, and hallway chats, a few themes stood out—and none more than the collective realization that the community has crossed a maturity threshold. Kubernetes is no longer novel. Multicloud isn’t a debate; it’s a reality. And most organizations are no longer trying to “go cloud-native”—they’re trying to survive the side effects of having already done so.
At this KubeCon, the conversation shifted from how to adopt Kubernetes to how to tame it. And that taming is taking a few distinct forms: FinOps to control spend, observability consolidation to reduce tool sprawl, and increasing reliance on secure, simplified platforms that give more power to developers and operators alike.
TL;DR – What We Took Away from KubeCon EU 2025:
- Observability isn’t just about insight—it’s about consolidation and simplification.
- FinOps has evolved into a strategic imperative, not a side quest.
- WebAssembly is no longer fringe tech—it’s now a viable runtime alternative.
- Simplicity is king. Platforms that reduce tool sprawl and abstract away Kubernetes complexity are winning.
- Modernization is perpetual. The goal isn’t a finish line—it’s forward momentum.
- Skill gaps persist, but vendors are stepping in with developer-first experiences that empower citizen developers and seasoned pros alike.
The FinOps Hype – From Cost Control to Strategic Value
Cloud-native teams have long wrestled with cloud sprawl, budget unpredictability, and a dizzying array of services. But at KubeCon EU 2025, FinOps was no longer a niche topic, it was front and center. What’s changed is the framing. It’s not just about shaving costs anymore; it’s about understanding where cloud investments deliver value and where inefficiencies lie hidden.
In a hybrid, containerized world, cost data must be actionable and aligned with engineering priorities. This is where companies like DoIT are stepping up. Their recent acquisition of PerfectScale positions them to offer a more complete FinOps suite, with AI-driven rightsizing and usage optimization tools tailored specifically for Kubernetes workloads. During our briefing, it was clear: this isn’t just about “turning things off.” It’s about making smart tradeoffs that improve performance and reduce waste.
Similarly, Cycloid framed FinOps within the broader context of platform engineering. Their platform isn’t just about enabling self-service for developers, it’s also about surfacing cost metrics in a way that’s digestible and decision-ready. This trend—FinOps as an embedded, developer-friendly experience—was echoed by multiple vendors across the floor.
Even hyperscalers like AWS are taking FinOps more seriously in the Kubernetes space. Their updates showcased efforts to simplify financial visibility in EKS environments, adding tooling to help enterprises better predict and manage cloud spend at scale. For customers running hundreds (or thousands) of clusters, this is critical.
The bottom line? FinOps is no longer a reporting function, it’s a cultural and architectural consideration. And at KubeCon, the vendors that resonated most were the ones that didn’t just show dashboards but showed decisions.
Observability is Facing Consolidation – From Tool Overload to Unified Insight
Observability is supposed to bring clarity, but, ironically, the cloud-native boom has often delivered the opposite. Organizations are drowning in telemetry, collecting metrics, logs, traces, and events from dozens of sources using half a dozen tools (or more). At KubeCon EU 2025, the conversation pivoted from “more visibility” to “more usable visibility.”
One of the strongest signals came from Dynatrace, whose AI-powered approach to observability is actively reducing noise and surfacing insights instead of raw data. Their platform emphasizes automation across incident response, root cause analysis, and anomaly detection, reminding us that insight without action is just overhead.
Vendors like Solo.io are tackling observability from a different angle: the control plane. In our conversation, they emphasized how service mesh and API gateway traffic management is directly tied to monitoring complexity. Their latest release, focused on standardization in the cloud-native AI era, aims to reduce operational entropy by offering tighter integrations between traffic control and observability pipelines.
Meanwhile, Nutanix demonstrated how observability is evolving at the infrastructure layer, particularly in hybrid multicloud deployments. Their integrated monitoring capabilities reduce context-switching between platforms which is something we heard repeatedly as a top pain point in customer conversations.
And observability isn’t just a cloud issue, it’s extending all the way to the edge. ZEDEDA showed off how they’re scaling observability into industrial and edge environments, where traditional agents and monitoring solutions don’t cut it. In sectors like manufacturing and energy, having a clear view of edge infrastructure is becoming mission-critical.
So, what’s the takeaway? Observability in 2025 isn’t just a tooling problem, it’s a strategy. Whether that means platform-native insight (like Nutanix), intelligent automation (Dynatrace), traffic-aware visibility (Solo.io), or edge-native telemetry (ZEDEDA), the vendors gaining traction are those helping customers see less, better.
WebAssembly (Wasm) is No Longer Fringe
Once a niche technology for browser applications, WebAssembly (Wasm) is now being championed as the next foundational runtime for cloud-native development. Especially where portability, performance, and security intersect. At KubeCon EU 2025, Wasm wasn’t just a side conversation; it was a spotlight. And not because it’s shiny and new, but because it’s solving real problems.
As enterprises grapple with the weight of containers, both in terms of size and orchestration overhead, Wasm is emerging as a lightweight, secure alternative that sidesteps many of Kubernetes’ long-standing complexities. For edge deployments, event-driven workloads, and AI inference tasks, Wasm offers a nimble, cold-start-friendly environment that containers simply can’t match.
Few vendors are doing more to move Wasm into the mainstream than Fermyon and Cosmonic. At the event, Cosmonic made the case for Wasm as a “secure-by-default” foundation for modern app architecture. Their platform, built on top of the open-source wasmCloud, focuses on making Wasm accessible, composable, and scalable in real-world deployments. It’s not just about speed, it’s about trust; and Cosmonic is helping prove that Wasm apps can scale and remain secure across environments.
Fermyon also doubled down on the serverless use case, showing how Wasm can radically simplify the developer experience when deploying ephemeral workloads. Their partnership with Akamai demonstrated how the two are enabling portable AI and serverless compute at the edge, a key theme in discussions around how to bring intelligence closer to where data is generated. When every millisecond matters, and every megabyte counts, Wasm’s minimal footprint becomes a strategic asset.
Meanwhile, Synadia positioned their NATS messaging system as a perfect match for Wasm-powered microservices. NATS’ low-latency, lightweight pub/sub architecture aligns beautifully with the Wasm philosophy, proving that the runtime isn’t just a technology shift, it’s a reimagining of what cloud-native messaging and service interaction can look like.
And what’s most notable is that none of these vendors framed Wasm as a “Kubernetes killer.” Instead, they see it as a complement: an escape hatch for workloads that don’t need the full container orchestration model. That hybrid approach—containers and Wasm—is what makes the current moment so exciting.
Wasm is no longer a science project. It’s a production reality for edge-native apps, ephemeral serverless functions, and distributed AI inference. The tooling is catching up, the platforms are maturing, and the community? They’re all in.
Simplicity as a Superpower
If there was one universal truth at KubeCon EU 2025, it was this: we’ve reached peak complexity. Between sprawling Kubernetes clusters, fragmented toolchains, and increasingly layered architectures, developers and platform teams alike are hitting their cognitive limits. And the industry is finally listening.
This year’s event marked a turning point away from “Kubernetes for experts only” toward more accessible, opinionated platforms designed to abstract the undifferentiated heavy lifting. Whether you’re a seasoned SRE or a newly empowered citizen developer, the message was clear: simplicity isn’t a luxury, it’s survival.
Take Northflank, for example. Their multi-cloud developer platform delivers a beautifully streamlined experience that hides Kubernetes’ complexity behind elegant defaults. By offering Git-based workflows, built-in CI/CD, and native autoscaling, Northflank gives developers exactly what they want: the ability to build, deploy, and scale without needing a PhD in YAML. It’s a case study in how developer experience (DevEx) can drive platform adoption.
Coder is tackling the problem from the other end: the development environment itself. Their cloud-based IDE solution ensures developers can work in secure, pre-configured environments without worrying about local setup or infrastructure drift. At a time when teams are increasingly distributed and security is paramount, this kind of abstraction is both convenient and critical.
And while platforms like Northflank and Coder empower individuals, Loft Labs is helping organizations operationalize developer enablement at scale. Their expansion of multi-tenancy capabilities enables teams to safely share Kubernetes infrastructure without stepping on each other’s toes. With features like secure virtualization, self-service namespaces, and deep Rancher integration, Loft is turning complex multi-tenant environments into something even small teams can manage.
Collectively, these solutions represent a larger trend: platforms are doing more so developers can do less. And that’s not about dumbing things down, it’s about elevating the right things. Simplified workflows, intuitive UIs, and platform abstractions are filling in the gaps where skills, time, or headcount are lacking.
The irony, of course, is that it takes real engineering complexity to create this simplicity. But for organizations juggling staff shortages, onboarding struggles, and developer burnout, these platforms can reduce friction and expand possibility.
As one attendee put it in a hallway chat, “We need tools that let our mid-level devs move like seniors.” KubeCon 2025 delivered exactly that.
Modernization Never Ends (And That’s Okay)
For years, “modernization” has been treated as a destination, a milestone to hit, a transformation to complete. But at KubeCon EU 2025, a more grounded narrative emerged: modernization isn’t a project, it’s a process. One that doesn’t end, but evolves. One driven by business needs, emerging technologies, and continuous learning.
Nowhere was that clearer than in the way vendors are framing modernization today. It’s no longer about forklift migrations or flashy platform rebrands. It’s about meeting teams where they are and giving them tools to take the next step, not the final one.
Diagrid is a standout example. Their latest innovation, Dapr Agents, offers a glimpse into the future of app modernization via intelligent, event-driven architectures. By combining Dapr’s building blocks with agentic AI models, Diagrid is enabling developers to shift from reactive to proactive app behavior—without overhauling their existing stack.
Microsoft also leaned hard into forward momentum with its advanced GPU orchestration for Kubernetes. Their vision: resilient, scalable AI pipelines that work across hybrid environments, without forcing teams to rearchitect for every hardware evolution. It’s a strong response to one of the most common refrains we heard: “We want to do AI, but we’re not ready to start over.”
And then there’s Broadcom, whose VCF strategy is turning what was once seen as legacy infrastructure into a springboard for Kubernetes adoption. By deeply integrating vSphere and Kubernetes, Broadcom is showing that modernization doesn’t have to be disruptive, rather, it can be additive. For customers invested in VMware, that’s a major unlock.
Even core infrastructure is getting a modern makeover. Tintri, long known for intelligent storage, highlighted AI-powered data services that anticipate workload needs and dynamically adapt storage performance. It’s a subtle, powerful example of how modernization can happen invisibly, behind the scenes and without a migration plan or executive mandate.
And this theme extended to Open Source as well. Projects like K0rdent continue to expand their ecosystems, showing that modernization is often a matter of integration, not reinvention. By plugging into what teams already use, open-source contributors are enabling incremental progress that feels sustainable.
In short, the most successful vendors weren’t promising a clean slate. They were promising continuity. The ability to modernize at your own pace, with your current people, on your current platforms.
And that, perhaps, is the most encouraging signal of all: in 2025, modernization isn’t just for the disruptors. It’s for the doers.
Final Thoughts: The Real Bridge Was the Community
It’s hard to wrap up KubeCon EU 2025 without reflecting on the experience of being in London itself—my first time in the city, and a fitting backdrop for a conference about navigating complexity.
Here’s what I learned:
- Melatonin is prescription-only, so if you’re jetlagged, don’t bother looking for ZzzQuil—try children’s antihistamines instead.
- Crossing the street is a leap of faith. Thank goodness for the painted arrows telling you where to look, because the parked cars point in every direction.
- London Bridge is… there, but the real gems lie elsewhere (shoutout to the surprisingly stunning Tower Bridge).
- People take real pride in their work, and it shows—in conversations, service, and even the way they talk about tech.
- Hair tools still don’t survive international travel. R.I.P. to my curling iron, but a massive thank-you to Salon Savvy for the rescue mission.
All of this is to say—while the themes of consolidation, simplification, and AI evolution shaped the conference, the people shaped the experience. The Cloud Native Community Foundation’s community, in its global and local forms, continues to be one of the most collaborative, welcoming ecosystems in tech.
We’ll be tracking how these themes evolve over the coming months—from platform updates to open source shifts and AI integration strategies. But for now, KubeCon EU 2025 showed us that the future of cloud-native isn’t just technical—it’s human, too.
And next time? I’m packing a proper UK curling iron.
