A thread on r/selfhosted recently posed a deceptively simple question: does renting a VPS actually count as self-hosting? The community divided cleanly. One camp argued that controlling the OS, software stack, and data is what defines self-hosting, regardless of who owns the physical machine. The other insisted that true self-hosting means owning the hardware, full stop.
Both positions are defensible. But what makes the debate genuinely interesting is what it reveals underneath: developers are increasingly frustrated with a false binary between full infrastructure ownership and the inflexibility of traditional managed platforms. The real tension is not about hardware ownership. It is about infrastructure control versus operational overhead, and neither VPS hosting nor full self-hosting resolves that tension cleanly.
VPS hosting (Virtual Private Server) means renting a virtualised slice of a physical machine from a cloud provider. You get root access, your own IP address, and complete freedom over your software stack. The provider maintains the physical hardware and network infrastructure. Everything above the hypervisor is yours to manage.
Self-hosting, in its purest sense, means running software on infrastructure you own and physically control. In practice, the term has expanded to cover any setup where you manage your own deployment environment rather than relying on a third-party platform to do it for you. A VPS can absolutely be part of a self-hosted setup, which is why the debate gets circular so quickly.
The distinction matters because the two terms describe different things. VPS hosting is an infrastructure arrangement. Self-hosting is a philosophy about ownership and control. Understanding what you actually need from each clarifies where the real choice lies, and why the popular framing of the debate misses the point entirely.
A VPS gives you flexibility and a low monthly cost. You can run any stack, configure your own firewall rules, install whatever you like, and deploy without asking permission. For many developers, this is the sweet spot: cheap, familiar, and free from the constraints of opinionated platforms.
A basic Node.js deployment on a VPS requires nothing beyond a fresh Ubuntu server, Node installed via nvm, and a reverse proxy like Nginx:
# Basic VPS setup for a Node.js application
ssh root@your-vps-ip
apt update && apt install -y nodejs npm nginx
npm install -g pm2
git clone https://github.com/youruser/yourapp.git
cd yourapp && npm install
pm2 start app.js --name myapp
pm2 startup && pm2 saveYou can have something running in under an hour. The problem appears the moment you need to maintain that deployment over time.
Security patches, kernel updates, SSL certificate renewals, monitoring, and backups all land on you. That is manageable for one application. Across a portfolio of projects, or on a small team where developers need to ship features rather than babysit servers, the overhead compounds quickly.
An unpatched VPS is a liability. An unmonitored service can go down for hours before anyone notices. A misconfigured firewall can expose your application to the public internet. These are not edge cases; they are routine operational concerns that require consistent attention. As we explored in our article on the most expensive DevOps mistakes teams make, the cost of infrastructure neglect rarely shows up on a spreadsheet until something goes wrong, and by then the damage is already done.
True self-hosting, in the hardware-ownership sense, means running servers in your home, office, or a colocation facility. You buy the machines, configure the networking, manage power redundancy, and deal with hardware failures yourself. You own every layer of the stack.
The appeal is genuine. Your data never leaves your physical control. There is no monthly VPS bill. You can repurpose old hardware. For privacy-sensitive use cases or hobbyists who enjoy the operational work, it can absolutely be the right choice.
But the operational reality is demanding. Hardware fails. Home internet connections drop. Power cuts happen. Cooling matters. Disaster recovery and physical security require planning and ongoing investment. For most developers building products, this level of operational commitment is a significant distraction from what actually matters: shipping working software.
The challenge of reliable deployment is not unique to traditional applications either. As we covered in Self-Hosted AI Apps in 2026: Building Is Easy, Deploying Reliably Is Hard, even well-architected applications run into serious operational friction when the infrastructure layer is not solid. Building is the easy part. Keeping it running reliably is where the real work lives, regardless of what you are deploying.
Both VPS hosting and full self-hosting optimise for different things. VPS optimises for flexibility and cost at the expense of operational simplicity. Full self-hosting optimises for data sovereignty at the expense of time and reliability. Neither optimises for what most developers actually want: meaningful deployment control without the ongoing burden of managing infrastructure themselves.
The r/selfhosted thread was really asking a more practical question: how do I get the benefits of controlling my deployment without spending half my week on it? That is a product problem, not a philosophical argument about hardware ownership.
Managed PaaS platforms sit between VPS hosting and full infrastructure management. You define what gets deployed, how it scales, and where the data lives. The platform handles the kernel, the network, the provisioning, and the monitoring. You retain deployment control without the operational overhead of maintaining virtual machines yourself.
This model has sometimes been dismissed as too restrictive. Early PaaS platforms were opinionated to the point of inflexibility, locked developers into proprietary runtimes, and charged significantly more than a comparable VPS. Those criticisms were fair at the time. But the category has matured considerably, and the better platforms today give developers genuine infrastructure control without requiring them to manage servers. For an overview of what the modern landscape looks like, our guide to lesser-known PaaS providers that developers actually choose covers the options worth considering beyond the headline names.
Code Capsules is built for developers who want the deployment flexibility of a VPS without the operational overhead of managing one. You deploy from Git, connect your databases, configure environment variables, and monitor your applications through a transparent interface. The platform handles provisioning, uptime, and infrastructure maintenance. You handle your application.
Several things set Code Capsules apart in the managed PaaS category:
A Node.js deployment on Code Capsules looks like this in practice. Connect your GitHub repository, set your build and start commands, add environment variables, and deploy:
# No server configuration required.
# Set these values in the Code Capsules dashboard:
Build command: npm install
Start command: node app.js
Environment: NODE_ENV=production
PORT=3000That is the entire deployment configuration. No Nginx config, no PM2 setup, no firewall rules, no SSL certificate management. The platform handles all of that. Infrastructure control is still available where you need it: you can set custom domains, adjust compute resources, and configure scaling behaviour. None of it requires you to manage a virtual machine or think about kernel updates.
For teams that have outgrown simpler platforms but do not want to land in the complexity of managing bare EC2 instances, the transition to Code Capsules is straightforward. As we described in You Outgrew Railway. Now You're Drowning in EC2. There's a Middle Ground., this is precisely the gap that Code Capsules is designed to fill, and where the managed PaaS model makes the most practical sense for growing teams.
The r/selfhosted debate about whether a VPS counts as self-hosting is philosophically interesting, but it is the wrong question for most developers. The real question is: how do you maintain meaningful deployment control without spending significant time on infrastructure maintenance?
VPS hosting gives you control but shifts all operational responsibility onto you. Full self-hosting goes further in the same direction. Managed PaaS, done well, offers a genuinely different model: the platform handles the infrastructure layer, and you retain control over what gets deployed, how it runs, and where the data lives. The self-hosting tradeoffs that make VPS management exhausting simply do not apply.
Code Capsules is built for exactly this use case. No vendor lock-in, no opaque infrastructure, no server babysitting. Just a deployment platform that gets out of your way and lets you focus on what you are actually here to build.
Ready to stop managing infrastructure and start deploying? Visit codecapsules.io and deploy your first application in minutes.
