Last Week in Cloud Native (LWCN) is a weekly newsletter dedicated to keeping the Cloud Native community informed about the latest releases, news, and developments in the CNCF ecosystem.

📅 Published: every Monday

🌍 Language: English

💶 Price: free, no paywall

🧑‍💻 Publisher: Mario Fahlandt

We believe staying current with the rapidly evolving Cloud Native landscape shouldn’t require hours of research. LWCN distills the most important updates from across the ecosystem into a concise, actionable weekly digest — written in a neutral, journalistic tone, with no marketing fluff.

LiveData and StateFlow both stream data reactively, but differ in two key ways:

Initialization — LiveData needs no initial value; StateFlow requires one.

Lifecycle — LiveData is lifecycle-aware by default; StateFlow is not, so you need to wrap it in repeatOnLifecycle to avoid memory leaks.

Your query builder vs Eloquent choice isn’t just about syntax — it can make or break your app’s performance.

In this article, I break down what actually happens under the hood when you use Eloquent vs Query Builder, based on real production experience. While both hit the same database, Eloquent adds layers like model hydration, events, and relationships — which feel great for clean code but can become costly at scale.

Through real benchmarks and practical examples, you’ll see why Eloquent can be 4x slower in heavy data scenarios — and why that often doesn’t matter for typical apps. The real problem isn’t Eloquent itself, but how developers misuse it (hello, N+1 queries 👀).

This isn’t a “pick one” debate. The real takeaway: smart developers use both — Eloquent for readability and relationships, Query Builder for performance-critical operations.

If you’ve ever wondered why your Laravel app suddenly slows down in production, this might be the missing piece.

Boring code is an organizational symptom, not an aesthetic failure. Co-change patterns in version control reveal team boundaries before any retrospective does; ownership concentration predicts defects better than code complexity metrics. With agents removing the friction that contained clever code accumulation, the incentive structures that produce boring code have never mattered more.

Karpathy said we should build LLM knowledge bases. 48 hours later made Graphify was made: one command, full semantic knowledge graph.

We applied the idea to incident data turning them into a queryable and interactable semantic graph. This lets us see past fixes, predict failures, cluster services, cut alert noise, and reveal team load in seconds.

If you’re using Rootly, here is a small plugin to explore your incident data.

Check it out: github.com/Rootly-AI-Labs/rootly-graphify-importer

Java 26 (March 2026) is out, and while it’s not a headline-heavy release, it brings meaningful improvements where it counts — performance, networking, and concurrency.

Some notable updates:

🌐 HTTP/3 support (QUIC-based, lower latency, better reliability)

🧵 Structured Concurrency (Preview) for safer multithreading

⚡ JVM & GC optimizations improving startup and runtime performance

🧠 Continued evolution of pattern matching

🧪 Vector API (Incubator) for high-performance workloads

This release is less about flashy features and more about incremental improvements that impact real-world systems.

When to use Prometheus and when to look for other solutions.

Scaling Autonomous Site Reliability Engineering: Architecture, Orchestration, and Validation for a 90,000+ Server Fleet