CI/CD has changed a lot, but the problem it solves hasn’t.

We moved from manual deployments to shell scripts, then Jenkins and other CI servers, containers, Kubernetes and now increasingly declarative GitOps workflows. The tools keep evolving, but the goal remains the same: make the path from code to production repeatable, testable and reliable.

Pablo’s “Majestic Pipeline” article looks back at that evolution and at the principles that still matter in 2026.

Read the full story: https://mkdev.me/posts/majestic-pipeline-a-ci-cd-love-story

Your data lake shouldn't be a swamp.

Messy pipelines, scattered data, and AI projects going nowhere? Sounds like your data infrastructure needs some attention.

Let's clean up the mess together: https://mkdev.me/b/consulting/data-engineering

GenAI has changed how quickly data and AI teams can prototype, explore ideas and work with internal knowledge. It hasn’t changed the need to prove that an AI system actually creates value.

That distinction is becoming increasingly important. The model is only one part of the equation. Evaluation, governance, data quality, business context and expert oversight still determine whether an experiment becomes a useful production system.

Last year, we spoke with data and AI leaders from Allianz, Thoughtworks and Outbrain about what GenAI has—and hasn’t—changed about leading their teams.

Read the full article: https://mkdev.me/posts/how-genai-has-and-hasn-t-changed-the-way-allianz-thoughtworks-and-outbrain-lead-data-and-ai-teams

AI can write shell commands for you. That doesn’t make understanding the terminal less useful.

Knowing your way around cd, grep, ls, ssh, curl and a handful of other basics makes it much easier to understand what a generated command will actually do, debug problems, and work confidently on remote systems.

Kirill built his beginner list from almost 30,000 lines of real shell history rather than choosing commands arbitrarily.

The result is a good reminder that foundational skills tend to age remarkably well.

Read the article for the full top 10: https://mkdev.me/posts/top-10-linux-commands-beginners-should-know-as-analysed-from-my-bash-history-of-30-thousand-lines

In 101st mkdev dispatch, Kirill explores the emerging world of AI decision models, why they could become an essential part of future LLMs, and how they can make AI applications faster and more efficient. From improving search results and routing requests between models to building real-time game AI, he shares some early experiments and explains why this technology is worth paying attention to: https://mkdev.me/posts/decision-models-like-jev-and-clef-are-a-game-changer-101

The best time to figure out whether your Kubernetes backups work is not during an incident.

With Backup for GKE, you can create scheduled backup plans, protect selected namespaces or workloads, include persistent volume data, and prepare restore plans before you actually need them.

And testing the restore matters just as much as creating the backup.

In this walkthrough, we deliberately remove workloads from a GKE cluster and bring them back using a backup and restore plan.

Take a look at the full guide: https://mkdev.me/posts/how-to-back-up-gke-clusters

Your Kubernetes cluster may be running perfectly and still have serious security gaps.

We dig into permissions, network policies, images, secrets, runtime environments and more—then tell you what to fix and why.

Explore our Kubernetes Security Audit: https://mkdev.me/b/audits/kubernetes-security-audit

What if you could keep your Compose files and lose Docker?

That’s essentially the idea behind running Compose workloads with Podman.

The developer experience can remain surprisingly familiar, while Podman provides a daemonless, largely rootless container engine underneath. Today, podman compose can hand the workload to a Compose provider and connect it transparently to Podman.

Same Compose concept. Different engine.

Our article takes a hands-on look at how Dockerless Compose works. Give it a read: https://mkdev.me/posts/podman-3-and-docker-compose-how-does-the-dockerless-compose-work

A lot has changed since we recorded this Terraform vs. Pulumi video: IBM now owns HashiCorp, OpenTofu exists, and Pulumi can tap directly into Terraform providers.

So how well did our original take age?

Watch the video, then tell us what you’d choose today: https://www.youtube.com/watch?v=Vo5a-If9Ftg

Your OpenShift cluster is running. 🎉

Now someone has to operate it.

Learn what’s behind the magic: CoreOS, CRI-O, MachineSets, MachineConfig, Cluster Operators — and what to do when the cluster breaks.

OpenShift 4 Cluster Operations 101 is free as a series of articles or videos!
Articles: https://mkdev.me/posts/production-openshift-cluster-in-35-minutes-first-look-at-okd-4-and-the-new-openshift-installer
Videos: https://www.youtube.com/playlist?list=PLozcbFx8FoPGM-Dk1jVBu58pwUGP9WGIX

What actually happens when your browser connects to a website over HTTPS?

Certificate verification, a chain of trust, secure key establishment, and encrypted communication—all before the page loads.

Our guide explains how TLS works and introduces useful tools for troubleshooting it.

Read it here: https://mkdev.me/posts/how-tls-and-https-work-plus-a-handful-of-useful-tools

Your CI/CD pipeline deserves better than being a haunted collection of YAML files nobody wants to touch.

Build it fast. Make it reliable. Give every PR its own environment. Let security checks join the party.

Make your pipeline majestic:
https://mkdev.me/b/consulting/majestic-pipeline

Your company doesn’t need to be building AI to have obligations under the EU AI Act.

If employees use ChatGPT, Gemini, Claude or similar tools for everyday work, your organisation is already deploying AI systems.

That means AI literacy matters.

The good news: this doesn’t mean turning everyone into an AI expert. It means taking reasonable measures so people understand the tools they use, their limitations, and risks such as hallucinations or inappropriate use of data.

We looked at what this actually means for businesses — starting with a very simple question:

Does using ChatGPT at work put you in scope of the AI Act?

Read the article 👇

https://mkdev.me/posts/my-company-is-using-chatgpt-does-the-ai-act-literacy-requirement-apply-to-us

When learning a new technology, memorizing configuration is rarely the best use of your time.

Take Prometheus.

Understanding what service discovery does, how scraping works, what exporters are, and how metrics and labels fit together matters far more than remembering the exact YAML syntax.

The details can be looked up. The mental model needs to live in your head.

Our rule for learning new technology:

Understand the principles first. Go deep into the details when the project actually requires it. And don’t confuse understanding with real production experience.

We used Prometheus to explain the approach:

👉 Read the article: https://mkdev.me/posts/how-to-learn-new-technologies-prometheus-example

Your inbox probably doesn’t need another newsletter.

But maybe it needs one with Cloud, DevOps, AI, things we learned, things worth reading—and something completely random at the end.

That’s mkdev dispatch.

Subscribe and see what turns up ✉️ https://mkdev.me/categories/newsletter

If you're still running workloads on AWS App Runner, there's a new reason to think about your exit strategy.

AWS has stopped accepting new App Runner customers and says no new features are planned. Existing services will keep running, but AWS recommends migrating toward ECS Express Mode.

That makes some of the original App Runner trade-offs even more relevant:

→ It simplified the load balancer and public endpoint
→ It didn't eliminate the need to understand IAM, VPCs and secrets
→ Its autoscaling abstraction still required understanding your application's behavior
→ ECS + Fargate offered more control with a mature underlying platform

App Runner was an interesting attempt to make AWS containers feel genuinely serverless.

The bigger lesson might be about choosing abstractions you expect to survive.

Read our experience with App Runner 👇

https://mkdev.me/posts/is-aws-apprunner-the-worst-way-to-run-containers

Cloud Run everywhere? GKE for everything? “We’ll fix the bill later”?

That’s not a cloud strategy. That’s a collection of future incidents.

mkdev’s GCP Audit finds what to keep, replace, secure, and optimize.

Get an expert review: https://mkdev.me/b/audits/google-cloud-platform

Not everything in Kubernetes needs to run 24/7.

Sometimes you just need:

“Run this script every 10 minutes.”

That’s exactly what CronJobs are for.

And once you combine them with Helm, the schedule, image and other configuration can become part of a reusable chart instead of another pile of copied YAML.

Add Google Cloud Build, and you can make deployment part of the same pipeline that reacts to changes in your repository.

This mkdev article shows the setup step by step — without turning a simple scheduled job into an unnecessarily complicated platform.

👇
https://mkdev.me/posts/deploying-kubernetes-cronjobs-with-helm-and-google-cloud-build

A lot changes in cloud infrastructure in four years.

Surprisingly, a lot doesn’t.

This older walkthrough of installing OKD/OpenShift on Google Cloud is still a useful look at IPI, cluster configuration, networking and the installation workflow.

Just don’t copy every credential step verbatim 😉

Watch the video 👇

https://www.youtube.com/watch?v=MPKhfrWzEKc

How much of your AWS bill is actually necessary?

In our work with KIWI, a few quick wins reduced monthly AWS costs by 8%. A deeper look at the architecture revealed potential savings of up to 50%.

It's a great example of why cloud cost optimization goes beyond simply cutting expenses.

👉 Revisit the case study: https://mkdev.me/b/cases/kiwi-case-study