2026
Two Days at DevOpsCon Amsterdam
What two days at DevOpsCon Amsterdam taught me about where I am in my DevOps journey, the talks that stuck, the tools I had never heard of and the knowledge gaps I am taking home to close.
A few months ago I would not have been able to walk into a DevOps conference and follow what was happening on stage. This week I could. That alone made the two days in Amsterdam worthwhile.
I have been putting serious time into learning everything related to DevOps. Kubernetes, networking, Linux, IaC. It adds up, but it can also get disorienting. When you are deep in the learning phase it is hard to tell whether you are covering the right ground. DevOpsCon gave me a chance to pressure test that.
The short version: the foundation is there. The concepts made sense. I could follow the talks. At the same time, there were sessions that reminded me how much ground is still ahead, which is exactly the kind of motivation I needed.
Day 1
Building Production-Ready Kubernetes Operators: A Practical Guide
This was the first talk I walked into at DevOpsCon. I want to be honest: it was a rough start. The session dove straight into building your own Kubernetes operators, which is a topic I had heard of but never really explored. At points it was hard to keep up with the depth of the content. That said, it was exactly the kind of talk that tells you where your knowledge gaps are. I left knowing that Kubernetes operators need to go on my learning list, which already makes it worthwhile.
Flying High with Observability: Boosting Passenger Satisfaction with Grafana
This one pulled me in. The talk walked through how observability tools are being used in a real production environment and it introduced a bunch of tools I had either only heard of by name or never encountered at all. Faro, Tempo, Beyla, Mimir were just a few. I walked out with a page full of names to research. It was exactly the kind of broad overview that makes you realize how rich the observability space actually is.
Terraform and GitHub: Infrastructure as Code meets GitHub Automation
I had already put in some time with Terraform through KodeKloud, so the fundamentals felt familiar. What I had not yet done was connect Terraform with GitHub in a real workflow. This talk showed what that looks like in practice, with automation, pull requests for infrastructure changes and collaboration baked in. It reinforced how much more time I want to invest in IaC going forward. I have been thinking about how to tie it into my home projects in a way that feels production-like.
Taming your Monstrous CI/CD Pipeline
A lightning talk, but a good one. The core message was about separating bash and Python scripts out of your YAML files into their own dedicated files. It keeps things readable. It keeps things maintainable. What made it satisfying was that I had already started applying this to my own recent projects. Hearing it confirmed out loud from someone on stage was a small but genuine confidence boost.
Around the World with 80 Worker Nodes
This was one of my favorites from the whole conference. The speaker showed how you can spin up a multi-node Kubernetes cluster spread across different parts of the world with only a handful of lines of code, combining Kubernetes with Terraform in a way that felt almost effortless on stage. The concept of multi-cloud is not new to me in theory, but watching it work in a real production context was a different experience entirely. I want to eventually build something like this myself.
Honey, the Audience Broke My App: Reproduce and Fix Live in Kubernetes with mirrord
I will be honest: this one went over my head a bit. It was a deep dive into Kubernetes networking through the lens of the mirrord tool, which mirrors live traffic into a local development environment. The demo was impressive, but the underlying networking concepts moved fast. I wrote down mirrord as something to come back to when my networking foundation is stronger. Next time I want to be the person in the room who can follow every step.
Day 2
The One About Titanic and Metrics, or Why Jack Fit on the Log
This talk was lighter on technical depth but made up for it with clarity. It covered the fundamentals of observability and reliability from a more conceptual angle, using the Titanic as a framing device to make the ideas stick. I had already worked with observability tools in previous projects so a lot of it was familiar ground. It was still a worthwhile session because sometimes hearing ideas you already know framed in a completely different way helps solidify them.
DevOps: Why Do We Keep Messing Up?
DevOps is not exactly a new idea, yet plenty of companies still struggle to make it work properly. What made this talk interesting was that it did not just focus on companies that have not tried. It focused on the ones that thought they had it figured out and still ran into problems: unhappy developers, unexpected costs, slow feedback loops. The message was that DevOps is not something you can install. It is something you have to keep working at, adjusting how teams interact, how pipelines are built, how success is measured. It was a grounding talk that reminded me the human side of DevOps is just as complex as the technical side.
Vibes Don't Scale: Kubernetes Hardening That Forgives Devs, Not Defaults
Another one of my favorites. I have not spent much time in Kubernetes security yet, so most of what was covered was new. The talk managed to explain concepts like pod security admission, seccomp profiles, AppArmor, Falco and Trivy without going so deep that a beginner would be lost. The framing was smart: instead of blaming developers for insecure workloads, focus on hardening the defaults so mistakes are harder to make. I wrote down a long list of tools to explore and I know this will become relevant when I continue building out my own clusters and eventually study for the KCSA.
Context Engineering for DevOps: How Agents Learn Your Infrastructure
This talk explored something I found genuinely thought-provoking. Large language models tend to struggle in real infrastructure environments because they lack the context that makes them useful. Naming conventions are inconsistent, dependencies are undocumented, telemetry is noisy. The speaker introduced a concept called context engineering, which is about shaping how AI agents understand a specific infrastructure over time rather than starting from scratch on every query. The approach they described, called ACE, lets agents learn from their own execution traces without needing labeled ground truth. It was a window into where AI-driven infrastructure tooling is heading and it made me think about how much of DevOps work is essentially context management.
Kubernetes and the Answer Is... 42!
Forty-two practical Kubernetes tips delivered at pace. Some of them I had already come across from my own time building clusters. Others pointed at concepts I had not touched yet, things like service meshes, network policies and various scheduling configurations. I wrote all forty-two down. I figure at some point in a real DevOps role I will be glad I did.
Kubernetes as the Universal Control Plane: From Pods to Multi-Cloud Infrastructure
A strong way to close out the conference. The talk made the case that Kubernetes is not just a container orchestrator. Its declarative API and reconciliation loop pattern can be extended to manage almost anything: databases, virtual networks, even other Kubernetes clusters. Tools like Crossplane and Cluster API were shown as concrete examples of how platform teams are building a true infrastructure-as-code workflow using nothing but kubectl and YAML. The GitOps angle was compelling too. If the control plane can reconcile the state of an entire multi-cloud environment from a Git repository, that changes how you think about platform engineering as a discipline. It left me with a clearer picture of where Kubernetes is going beyond just running pods.
Knowledge gaps to close
I took notes during every session. Whenever something came up that I did not fully understand, I wrote it down. This is the list I walked away with.
What I took away
The biggest thing I took away from DevOpsCon 2026 was the realization that I am building the right foundation. Walking into rooms full of experienced engineers and being able to understand what they were talking about felt significant. Not because I know everything, but because the language started to make sense.
There were also plenty of moments that felt out of reach. Complex networking deep dives. Security tooling I had never heard of. Production setups with a level of scale I have not worked with yet. That is fine. Conferences like this are not supposed to be comfortable. They are supposed to show you what the ceiling looks like so you know what direction to keep moving in.
I also met people. Expanded the network. Those conversations were a reminder that the community around DevOps is genuinely enthusiastic and more approachable than I expected.
Two days well spent. Plenty left to learn.