Half the Kubernetes predictions I’ve seen for 2020 are recycled 2019 predictions that never materialized. Service mesh everywhere. Databases on k8s. Serverless killing containers. None of that happened at scale, and most of it won’t this year either.
Here’s what I think actually matters.
The adoption argument is finished
Nobody is debating whether to use Kubernetes anymore. That conversation ended sometime mid-2019. Every enterprise I’ve worked with has clusters in production. The question now is whether they’re running it well. Spoiler: most aren’t.
The real work in 2020 is day-two operations: upgrades, multi-tenant governance, cost control, and not breaking things on Friday afternoon. Boring stuff. Important stuff.
At Decloud we’ve been living this reality since we started building cloud infrastructure tooling after EF. The gap between “we have Kubernetes” and “we operate Kubernetes well” is enormous. That gap is where most of the pain lives.
Managed control planes win. Stop fighting it.
If you’re still self-managing your control plane without a very specific reason, I genuinely don’t understand what you’re doing. Cloud providers handle patching, availability, and scaling. The operational cost of doing it yourself is absurd for most teams.
Yes, there are exceptions. Air-gapped environments. Weird regulatory constraints. Hybrid topologies that managed services can’t reach. But these are exceptions, not defaults. The default in 2020 should be managed.
GitOps becomes the normal way to deploy
This is probably my highest-confidence prediction. GitOps moves from “cool thing the early adopters do” to just how you deploy. Argo CD and Flux are solid. The model is proven.
Pull-based delivery, audit trails in git, rollbacks that don’t require someone SSHing into a bastion host at 2 a.m. It works. Multi-cluster GitOps is still rough, but single-cluster is basically solved.
If you’re starting fresh in 2020 and not using GitOps, you’re choosing to have a worse time later.
Security shifts from checkboxes to enforcement
RBAC and network policies should already be in place. If they’re not, that’s a different conversation (and you should be worried). The 2020 shift is toward policy as code: admission control that actually prevents bad configurations from reaching the cluster.
OPA Gatekeeper is the one to watch here:
apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sRequiredLabels
metadata:
name: require-team-label
spec:
match:
kinds:
- apiGroups: [""]
kinds: ["Namespace"]
parameters:
labels: ["team", "cost-center"]
Simple example, but the idea matters. Don’t just document policies. Enforce them automatically so humans can’t skip them when they’re in a rush.
Service mesh is overrated (for now)
Hot take that shouldn’t be a hot take: most teams don’t need a service mesh in 2020. The mTLS and traffic shaping benefits are real, but the operational overhead is significant. I’ve watched teams spend weeks debugging Istio sidecars instead of shipping features.
For critical services with strict security requirements? Sure, use a mesh. For your internal CRUD APIs and batch jobs? You’re adding complexity for conference talk credibility.
eBPF-based approaches like Cilium are genuinely interesting as sidecar alternatives, but they’re still too early. Check back in 2021.
Running databases on k8s: still mostly don’t
The operator ecosystem is improving. Zalando’s Postgres operator, Strimzi for Kafka: these are credible projects. CSI is maturing. But “technically possible” and “good idea for your team” are very different things.
From my time at the fintech startup handling strict data requirements, I learned that stateful workloads need operational confidence you only get through battle-testing. Most teams haven’t battle-tested their k8s storage layer enough to bet production data on it. Give it another year or two before it goes mainstream.
Platform engineering is the underrated trend
This is the one nobody’s hyping enough. Kubernetes is powerful and terrible as a developer interface. The teams that win in 2020 will build internal platforms that hide the complexity. Opinionated templates. Self-service environments. Clear boundaries between app teams and platform teams.
The goal isn’t to protect developers from Kubernetes. It’s to let them ship faster without accidentally creating cost or security problems.
What I actually expect this year
Managed Kubernetes becomes the default. GitOps becomes normal. Policy enforcement goes from “nice to have” to required. Platform engineering starts getting the attention it deserves.
What won’t happen: service mesh everywhere, databases migrating wholesale to k8s, or the mythical “NoOps” future some people keep promising.
Kubernetes in 2020 is about operating it well. Teams that treat operations, security, and developer experience as actual product work, not afterthoughts, will be fine. Everyone else will keep filing the same incident reports they filed last year.