Ever felt like getting a self-hosted Kubernetes cluster up and running requires a Ph.D. in distributed systems and six months of dedicated study? You’re not alone. The promise of Kubernetes is immense: scalable, resilient application hosting. The reality of implementing it yourself, especially outside of a managed cloud service, often feels like staring at a firehose of technical documentation, leaving you pulling your hair out. All you really want to do is host an application, serve an endpoint to the internet, and save data to a persistent volume. Simple, right? Yet, these “basics” are surprisingly complex to achieve without leaning heavily on one of the big three cloud providers.
For many, cloud-managed Kubernetes isn’t an option. Maybe privacy and security concerns prohibit it, or perhaps the cost of a managed service is simply too much for a small business or startup that only needs minimal, essential infrastructure to get going. This is precisely where Minimal Viable Kubernetes (MVK) steps in. It’s designed to cut through the noise, reduce decision paralysis, and offer a refreshingly simple, template-driven approach to self-hosting a hyper-converged Kubernetes cluster.
The Kubernetes Conundrum: Why Self-Hosting Feels Like Climbing Everest (Without a Guide)
The traditional path to self-hosted Kubernetes is, frankly, daunting. You’re immediately confronted with choices for CNI, CSI, ingress controllers, load balancers, and a myriad of other components that are often seamlessly integrated and abstracted away in managed cloud offerings. When you’re trying to do it yourself, each of these becomes a separate, complex project. This often leads to analysis paralysis, where the sheer volume of options and the steep learning curve make starting feel impossible.
The core issue is that “vanilla” Kubernetes, out of the box, is designed to be a highly flexible orchestration engine, not a complete, production-ready platform with all the bells and whistles. Those bells and whistles – persistent storage, easily exposed services, load balancing, networking – are usually provided by the cloud provider’s infrastructure. Without that, you’re left to piece together your own solutions, which can quickly turn into a full-time job.
This challenge is particularly acute for those who value data sovereignty, need to keep costs tightly controlled, or simply want a deeper understanding and control over their infrastructure without sacrificing resilience. It’s a valid desire, but until now, the path to fulfilling it has been largely obscured by complexity.
Minimal Viable Kubernetes (MVK): Your Self-Hosted North Star
MVK is a breath of fresh air for anyone who’s ever dreamed of a self-contained, highly portable Kubernetes implementation. It’s engineered to run on self-hosted virtual machines, ideally on three nodes for resilience against single-node failure, though it can even start on a single host. The beauty of MVK lies in its intent: to be simple enough to maintain without a dedicated platform team, while still mirroring the structural patterns you’d find in traditional managed cloud environments.
Think of it as a carefully curated, opinionated toolkit that provides just enough Kubernetes to be genuinely useful, without the overwhelming overhead. It’s built to scale beyond its initial three hosts, transforming into a robust reference architecture for deploying real business-critical workloads. Crucially, MVK focuses on fulfilling dependencies typically provided by cloud services directly within the cluster itself. This hyper-converged approach integrates compute, storage, and networking resources, dramatically boosting portability and reducing your reliance on cloud-specific infrastructure.
Your journey with MVK begins with comprehensive documentation, designed with microlearning in mind. You’ll start with practical steps for local development environments, creating a local `k3s` environment using `k3d`, and executing initial `infctl` pipeline runs. Before you know it, you’ll be implementing resilient, production-like multi-node Kubernetes, complete with self-hosted ingress, storage, and load balancing – all components you control and understand, not opaque third-party services.
infctl: Your Command-Line Companion for MVK
At the heart of the Minimal Viable Kubernetes stack lies `infctl`, a command-line utility built for rapid and reliable deployment. We designed `infctl` with a few core principles that reflect the MVK philosophy:
- Simplicity and Transparency: `infctl` is intentionally small. Its source code is concise, making it reviewable and understandable, often in a single session. It doesn’t hide underlying Kubernetes manifests, scripts, or `kubectl` commands. This transparency empowers curious minds to learn from and extend MVK, offering a clear window into its operations.
- Empowering User Understanding: Ultimately, `infctl` aims to get out of your way. Once you’ve gained an understanding of MVK, you could conceivably replace `infctl` with your own preferred tools or methods. It’s intended to be a stepping stone, not a permanent dependency. But if it works for you, by all means, keep using it!
- Flexible Workflow Orchestration: Beyond initial deployment, `infctl` is designed for extension. It can serve as a lightweight pipeline for orchestrating workflows in diverse environments—be it your local development setup, a cloud-based CI/CD pipeline, or a remote host. Its flexibility and minimal footprint make it a valuable tool in any of these scenarios.
MVK’s Foundations: Making Smart Choices for Simplicity and Resilience
Our journey to MVK began in February 2025, driven by the primary goal of reducing the prohibitive cost of managed Kubernetes by self-hosting on virtual machines. Initially, like many, the thought of a single virtual machine as a starting point for infrastructure was tempting. Vertical scaling is straightforward for smaller applications, but it inevitably creates a single point of failure. This led us to the crucial decision: a cluster of three or more VMs for Kubernetes, offering crucial resilience and enabling horizontal scaling.
Discussing this endeavor with fellow tech enthusiasts revealed a common yearning: a practical, guided path into Kubernetes without the overwhelming complexity. Having worked with Kubernetes since 2018, starting with self-managed setups, I saw an opportunity. This led to the initial commit of `infctl` in July 2025, quickly followed by MVK as the guiding documentation for the project.
MVK takes an opinionated approach, which is necessary to provide a clear, minimal, and viable path. We chose K3s and K3d as the foundational tools. They are well-established, known in the industry, and offer significant efficiencies over traditional `kubeadm`-based Kubernetes distributions. This decision wasn’t arbitrary; it came after years of comparing various approaches – from lightweight options like Talos and Docker Swarm to full-fat Kubeadm setups. K3s offered the best balance of Kubernetes API compatibility, a minimal footprint, and ease of management for the MVK vision.
While MVK currently leverages K3s, the underlying principles are robust. We envision users being empowered to extend and even switch Kubernetes distributions, building upon the solid foundation MVK provides. Our aim is to demystify the choices, not to lock you into a single technology forever.
The Tangible Benefits: Why MVK Matters for You
So, what does MVK truly deliver, and what’s in it for you and your organization? Colloquially, we’d heard that self-managing Kubernetes could shave around 30% off the average $100/month cost of managed services. Through our own implementation, we’ve found this figure to be closer to 50% for an initial hyper-converged three-node cluster. Imagine halving your infrastructure costs right from the start!
Beyond the immediate financial savings, MVK provides a powerful template for building your own production infrastructure. Our MVK templates streamline the process into just three steps:
- Prerequisite tooling checks: Ensuring your environment is ready.
- Initial configuration: Tailoring MVK to your specific needs.
- Pipeline run: Executing the deployment, which is idempotent, meaning you can run it multiple times without issues, ensuring consistency and state.
This infrastructure-as-code approach means your infrastructure is reproducible, version-controlled, and can be built, destroyed, and re-deployed as required, from development through to pre-production and even production environments. This isn’t just about convenience; it’s about resilience and business continuity.
Disaster recovery rehearsals, often the preserve of larger enterprises, become accessible even to small teams and companies. In the event of real-life disasters, you can quickly and nimbly move from one infrastructure to an entirely new one, even across different cloud providers. This makes your operations genuinely cloud-agnostic – a goal for many enterprises, now attainable for startups and smaller operators, all at a fraction of the cost of managed Kubernetes.
MVK isn’t just a set of tools; it’s a philosophy of empowering you with control, clarity, and cost-efficiency over your containerized applications. It demystifies the path to a robust, self-hosted Kubernetes, allowing you to focus on building your products, not wrestling with complex infrastructure. The future of controlled, cost-effective, and resilient application hosting is here, and it’s simpler than you think.
Whether you’re ready to build and deploy your own self-hosted MVK or want to explore how it can fit into your organization’s next venture, we’re here to help you get on stream. We look forward to sharing the power of MVK with you.
