The first thing you need to know is this: I’m learning AKS right now, and I refused to do it the polite way.

I didn’t want the “click here, run that, deploy hello-world, take screenshot, declare victory” experience. That’s not learning, that’s tourism. You’re basically taking a guided bus tour through Kubernetes, waving at the cluster as it passes by, and then going home with a souvenir mug that says “I ❤️ YAML” while secretly hoping nobody asks you what you actually built.

I wanted the real thing. The messy thing. The thing that makes your brain sweat a little.

So I built a lab that feels like a platform story, not a tutorial page. A lab where you don’t just deploy something and disappear into the mist like a wizard who refuses to explain his spells. A lab where you build a foundation, connect the right pieces, and then actually operate it. Because that’s where AKS becomes AKS. Not at “cluster created.” At “cluster is alive and now the world starts testing you.”

That’s how this project was born: AKS Landing Zone Lanlives here: https://github.com/Jamonygr/aks-landing-zone-lab

And yes, it looks dramatic. Because if I’m going to suffer through learning something hard, I want it to be in style. If my mistakes are going to be legendary, they should be neon-lit and accompanied by synth bass.

When you open the repo, the first thing you see is the big “movie poster” energy. It’s not shy. It’s not whispering “maybe we’ll build a cluster.” It’s basically yelling: “We’re building the whole environment, and we’re going to do it properly.”

That README screenshot has the vibe of an 80s action film intro where the title slams onto the screen, the grid stretches into infinity, and a narrator says something like: “In a world where permissions don’t make sense… one engineer dares to deploy anyway.”

And honestly? Accurate.

Because learning AKS isn’t just learning a product. It’s learning how a bunch of invisible systems argue with each other until you give them the exact set of permissions and settings they want. AKS is like a nightclub bouncer that demands three forms of ID, a wristband, a secret handshake, and a note from your mother before it lets your workload into the building.

That’s why I didn’t want a tiny lab. I wanted something that gives me the whole picture. A setup that forces me to face the things real platform teams deal with, while still being safe enough to break without ruining my life.

Then the architecture diagram enters the scene like the calm, wise mentor in a karate movie.

This diagram is basically the “map of the city” before the main character steps out into the neon rain. It shows the environment in a way that makes your brain relax. There’s a shared foundation area. There’s the AKS area. There’s a set of supporting services that make AKS feel like a real platform instead of a lonely island. And there’s a clear path from “the internet” to “the thing you actually access,” which is the moment where reality shows up and asks, “So… does this work outside of your imagination?”

The reason I like this hub-and-spoke design for learning is simple: it gives my brain boundaries. When you’re learning, boundaries are oxygen. Without them, you become the guy who throws everything into one place and then spends three nights asking why the thing can’t reach the other thing, while the other thing silently laughs behind a firewall.

So in this lab, there is a clear sense of “shared foundation” versus “where the AKS action happens.” It feels like a real environment, not a random collection of resources that accidentally formed a cluster.

And now comes the part that made me grin like a kid who just discovered cheat codes.

Because the lab doesn’t just build infrastructure and then abandon you like a mysterious mentor who disappears at the end of episode two.

It deploys a web app.

A full web app. Not a placeholder. Not a static page. An actual “learning hub” experience you can open in the browser and use while you run the lab. When I say “I’m learning AKS right now,” this is my way of making learning less chaotic and more structured. It’s like turning the lab into a game that tracks your progress instead of leaving you alone with notes and regret.

And the UI looks like it was designed inside a synthwave dream.

When I open the dashboard, I’m not just looking at a pretty screen. I’m looking at a story: what’s done, what’s next, what’s blocked, and how far I’ve progressed. It’s basically a “platform team” view of your lab, which is incredibly helpful when your brain is juggling ten concepts at once and you can’t remember whether you already solved the DNS thing or if you only thought about solving the DNS thing.

It also helps that the app speaks in a way that matches how my brain works when I’m learning. It shows modules and progress like a checklist, but in a way that feels like you’re moving through a structured path rather than wandering through the Kubernetes wilderness hoping to stumble upon knowledge like a lost explorer.

Then there’s the tracker view, which is the part that feels like the “mission board” in an arcade game.

This is where the lab becomes honest. Because it’s easy to pretend you’re making progress when you’re just reading docs. It’s harder to pretend when your tracker is staring at you like a disappointed coach. The tracker turns the lab into a real sequence of checkpoints. You can see what’s completed, what’s in progress, and what’s blocked. That last one is painfully realistic. Because when you’re learning AKS, something is always blocked. If nothing is blocked, you’re either a genius or you haven’t tried anything yet.

And then there’s the runbook / wiki area — the part that feels like the giant instruction manual in the glove compartment of a spaceship.

This is where the learning becomes less scattered. Instead of five browser tabs, three half-written notes, and one YouTube video playing at 1.5x speed, the runbook gives you a single structured place to move through the lab like a guided journey. It feels like a proper “learning path,” but with the vibe of a platform engineer’s internal guide: practical, sequential, and focused on doing.

The reason I’m obsessed with this approach is because it solves the most common problem in AKS learning: forgetting where you are.

When you learn something difficult, you don’t need more information. You need a path. You need something that says, “You’re here, and the next thing that matters is this.” That’s what the Learning Hub does. It’s not just a UI, it’s a sanity tool.

At some point, I realized that the lab was becoming less about “deploying AKS” and more about “learning to operate a system.” And that’s exactly what I wanted.

Because in real work, nobody cares that you can deploy AKS. They care if you can run it. They care if you can troubleshoot it. They care if you can keep it stable, secure, observable, and predictable. They care if you can build something that doesn’t collapse the moment someone clicks refresh.

This lab forces me to think in that direction.

It also forces me to accept that AKS learning is a long game. You don’t learn it in a weekend. You learn it through repetition, failure, and rebuilding. That’s why the deployment flow in the project matters so much. It’s not a “one and done.” It’s a cycle. Build it, connect, deploy workloads, operate, tear it down, and do it again — like an 80s training montage where the hero keeps getting knocked down but eventually starts catching punches like it’s nothing.

And that’s the entire reason this project exists. It’s my training montage. It’s my neon gym. It’s the place where I can practice AKS the way it’s actually used, without pretending that real-world complexity doesn’t exist.

Now, one of my favorite screenshots isn’t even glamorous. It’s the repo file structure.

Because that structure is the difference between chaos and confidence. When you’re learning, you need a home for everything. You need the feeling that the project is organized, that there’s a place for the app, a place for the lab environments, a place for the scripts, a place for the runbook, and a clear “front door” for how you actually use the thing.

If a learning repo looks like someone dumped random files onto the floor, your brain mirrors that disorder. If the repo is structured, your brain starts thinking in structure too. That’s a hidden benefit of building your own labs: you don’t just learn AKS, you learn how to organize AKS work.

So what is this lab, in one sentence?

It’s my attempt to learn AKS like a platform team would — with structure, with repeatability, and with an operational mindset — but wrapped in a retro neon aesthetic so the suffering feels heroic.

And it’s also a reminder of something important: learning isn’t about being flawless. It’s about showing up, building, breaking, fixing, and doing it again. The web app helps me see that progress. The architecture diagram keeps me oriented. The repo structure keeps me sane. And the whole thing makes AKS feel less like an intimidating monster and more like a system I can actually understand.

That’s me learning AKS.

— ChriZ