Re-Architecting Monoliths into Kubernetes Microservices, at Million-User Scale
Breaking a million-user monolith into services on Kubernetes — the strangler path, the seams, and what actually broke along the way.
Every talk I tracked at KubeCon + CloudNativeCon India 2026 (Jio World Convention Centre, June 18–19), read slowly and rebuilt deck-by-deck. Day 1 first — platform engineering, policy & identity, agents/GPUs/serving, observability/edge/storage. Then Day 2 — AI serving & gateways, networking & the kernel, DevEx, and core Kubernetes/edge/security. Grounded in the speakers' own slides.
How to run Kubernetes as a product — re-architecting monoliths, multi-tenant platforms, cloud-native data, and the operator/abstraction layer that makes it usable.
Breaking a million-user monolith into services on Kubernetes — the strangler path, the seams, and what actually broke along the way.
Multi-tenancy when the stakes are life-critical — sharing one platform safely without giving up isolation.
Running Kafka the cloud-native way and getting observability that survives real production traffic.
Application-centric delivery with KubeVela / OAM — one interface across many runtimes.
Operator design: which resources to watch, which to leave alone, and why over-watching hurts.
Policy-as-code, safe container root, verifiable supply chain, and federated identity — the controls that make a cluster auditable.
Five Kyverno patterns that take policy-as-code from a commit all the way to enforced runtime.
User namespaces in Kubernetes (KEP-127) — running as root inside a container without the host risk.
Cryptographic commitments over an SBOM — prove integrity without leaking the contents.
Federated client auth with Keycloak — dropping long-lived client secrets for federation.
Production agentic AI on Kubernetes — orchestration, accountability, GPU-free autopilot SRE, and serving LLMs simply.
Putting agentic AI into production on Kubernetes — orchestration, guardrails, and the real failure modes.
Tracing and auditing autonomous agents — answering "what did it actually do?" after the fact.
An autonomous SRE agent (Kagent & Kgateway) that needs no GPU — running the whole self-healing loop on CPU.
A simpler path to serving and scaling LLMs on Kubernetes.
Lean service-mesh telemetry, KubeEdge at the edge, Ceph storage via Rook, and the hidden cost of telemetry format conversions.
Lightweight, native telemetry for a service mesh — observability without the bloat.
How KubeEdge stretches Kubernetes out to edge devices — architecture and the trade-offs.
Ceph storage on Kubernetes via Rook, straight from the maintainers — including the two-node edge problem picked up on Day 2.
The hidden cost of format conversions in telemetry pipelines — and how to stop paying it.
Putting LLMs and autonomous agents into production safely — global GPU queueing, an MCP transport, inference observability, and agent isolation/sandboxing.
Finding and borrowing scarce GPUs across clusters and regions with Kueue + MultiKueue — global queueing and fair sharing.
A gRPC binding for MCP — streaming, typing, and scale beyond stdio/SSE for production.
What observability means for LLM inference — TTFT, TPOT, queue depth, KV-cache, and not flying blind.
Treating an agent as untrusted — identity, least privilege, and network/runtime isolation.
Running model-generated code safely at scale — nsjail in microVMs, gVisor/Kata trade-offs, egress proxies brokering secrets.
Kubernetes networking at real scale — past kube-proxy, into air-gapped service networking, and a zero-trust banking dataplane on Cilium/eBPF.
A browser-farm at 10M sessions/day outgrew kube-proxy — the move to EndpointSlice-driven routing.
Service networking with no internet — registries, DNS, and the things that quietly assume connectivity.
A zero-trust banking network with Cilium — identity-based policy, encryption, Hubble observability, and Tetragon runtime security.
Making the platform invisible and the builds lean — the CNCF TAG DevEx roadmap for 2026 and buildpacks vs hand-written Dockerfiles.
What CNCF TAG App Delivery / DevEx is prioritising for 2026 — the state of cloud-native developer experience.
Cloud Native Buildpacks vs Dockerfiles — smaller images, fewer CVEs, reproducible builds.
The unglamorous resilient layer — two-node edge storage (the Day-1 Rook follow-up) and validating ARM64 edge with QEMU before the hardware exists.
Resilient storage on a two-node edge cluster — the floating mon, Pacemaker fencing, and split-brain. Follows Day 1's Rook talk.
Validating ARM64 edge software (RK3588) before the hardware exists — QEMU + KubeEdge on a cheap x86 box.