No PaaS Required? The Developers Guide to Kamal vs PaaS

Building web apps is hard, but creating a product is only the beginning. Once you’re ready to take an application to production, you’ll have to figure out how - should you host on your own VM? Should you deploy in the cloud? Should you use a platform?

You’ve probably heard that Rails 8 ships with a new option for deploying your Rails applications - Kamal.

Kamal is a deployment tool built to make shipping Docker-based apps to the web even easier, “No PaaS Required”. While Kamal works for more than just Rails apps, new Rails 8 applications will use Kamal by default, making the process of going to production without a platform like Heroku easier. The Rails core team (or at least DHH) is convinced it’s enough of a leap that they themed this release of Rails “No-PaaS Required”.

But can Kamal really replace a PaaS? Let’s take a look!

Why do people use platforms?

If you’ve ever launched an app, you know the real work doesn’t end at writing code. Taking a web app to production comes with a whole checklist of infrastructure tasks: provisioning servers, managing deployments, handling scaling, and keeping it all updated and secure. Platforms like Heroku, Render, Railway, and Fly.io exist to make this process easier.

At their core, platforms abstract away the not-so-fun parts of infrastructure. Using Heroku or an alternative means you get a streamlined developer experience: push your code, watch it build, and your app is online. Scaling becomes a matter of turning a few knobs, logs are already in place, and crash recovery just works.

Why people like Kamal

Of course, platforms come with a cost. Managed infrastructure is more expensive than running your own servers, and the convenience they provide often feels like a black box. For some teams, that trade-off might be too expensive or restrictive.

That’s where Kamal enters the conversation. Kamal promises to give you the flexibility of managing your own infrastructure while easing the pain of deployment. There’s a couple of obvious (and a few not-so-obvious) reasons why people like Kamal:

Kamal proxy

One of Kamal’s standout features is it Kamal proxy. Kamal proxy lets you run multiple apps on a single server, which reduces the need to provision new virtual machines for every project (i.e. it can save you a ton of money for a bunch of small “hobby” apps). It also takes care of zero-downtime deployments, so you can push updates without dropping requests.

An underrated benefit of the proxy is that it facilitates quick rollbacks that reuse your previous build. If you deploy a bad change, there’s no waiting around to build a fresh Docker container.

Running kamal deploy is close to magic

Once you’ve gone through the initial setup, deploying with Kamal feels refreshingly straightforward. You configure your environment, bootstrap your server, and from there, a simple kamal deploy is all it takes to ship your app. For Heroku fans used to “push to deploy”, Kamal comes surprisingly close.

Kamal can manage accessory services

Another thing Kamal gets right is accessory services. You can manage things like Redis, databases, or background job queues directly in Kamal’s configuration files alongside your app configuration. If you prefer the stability of managed services (like Crunchy Data or TimescaleDB), Kamal can connect your app to those too.

Kamal is cheaper than a platform

This is probably the number one reason someone might consider reaching for Kamal instead of a platform. If the convenience and developer experience of using a PaaS came at no extra expense, Kamal wouldn’t have a reason to exist.

Running your app on a VPS provider like Hetzner or DigitalOcean is undeniably cheaper than using a PaaS at scale. Kamal makes the idea of self-hosting less daunting by handling many of the tricky parts: provisioning, deployments, and rollbacks. It suggests that you’ll get platform-like automation without paying platform-level prices.

At its core, Kamal makes managing your own infrastructure better. It doesn’t remove all the pain, but it smooths out enough of the rough edges to make the trade-off worth considering.

Kamal is not a platform, but it helps you replace one

For all the things Kamal gets right, it’s important to be clear: Kamal is not a platform. It’s a deployment tool. Kamal helps you bridge the gap between “managing everything yourself” and “letting a PaaS handle it all.” It smooths out some of the bumps of self-hosting, but it won’t shield you from all the complexities of infrastructure.

You still have to provision servers

For starters, Kamal doesn’t provision servers for you. That’s still your responsibility. You’ll need to spin up servers with appropriate CPU and RAM for your application and configure SSH access. Most Kamal Tutorials often speed through this step, but it’s where much of the complexity begins. Even after you’ve bootstrapped your server with kamal server bootstrap, there’s additional configuration to worry about—like avoiding the default root user for security reasons.

You need a Docker container

Another key prerequisite is that your app must be containerized. Kamal expects a Docker image, and if your application isn’t already containerized, that itself can be enough of a roadblock. Platforms like Heroku handle this automatically, offering options for containerized and non-containerized apps, but Kamal necessitates you come with a Docker-ready app.

Docker builds have to happen somewhere

Even the builds themselves have some complexity. Kamal uses your local Docker environment to build images for deployment. If you’ve ever had to clean up Docker with a docker system prune, you know how involved this can be. Sure, you can offload builds to a remote server, but now you’re maintaining two machines—one for builds and one for production.

Oh, you’ll also need a container registry

Kamal also assumes you’ve got a container registry ready to go. Docker Hub’s free tier works for a single private repository, but if you need more, you’ll likely incur extra costs. Similarly, You’re responsible for setting up health checks to ensure your app stays online and provides enough info for the proxy.

Kamal won’t configure your load balancer

If you’re running your application across multiple servers, you need to configure and manage a load balancer. Kamal won’t help with this, it’s another piece of infrastructure that you’ll need to contend with. You’ll provide details of your load balancer to Kamal so it knows where to send web traffic, but you’ll need to set up the load balancer yourself.

Kamal doesn’t support autoscaling

Kamal gives you the tools to provision one or many servers, but it’s up to you to figure out how to set up load balancer for those servers. And since Kamal isn’t actually provisioning servers, it certainly can’t dynamically provision them. This removes your ability to autoscale, a huge tool for cost savings while maintaining reliability.

None of this makes Kamal inherently bad. For developers looking to take control of their infrastructure and have an extra hand with deployments, it’s a powerful tool. But it’s important to understand what Kamal is and what it isn’t. Kamal helps you automate deployments and rollbacks, but it doesn’t fully replace the developer experience of a PaaS.

There’s still a place for PaaS

Kamal is a great tool, but it doesn’t make platforms obsolete. The value proposition of a PaaS is still as valid as ever. Platforms abstract away more than just deployments.

With a PaaS, your first deployment takes minutes. Your app doesn’t need to be containerized, configuration is easy, and horizontal scaling comes out of the box. Compare that to Kamal: your first deployment requires server provisioning, Docker container setup, and manual configurations in Kamal-flavored YAML. Once that setup is done, kamal deploy is smooth—but getting there isn’t trivial.

Kamal is “deployment-as-code,” not quite infrastructure-as-code. It’s an excellent deployment tool, and for teams willing to take on the responsibility of managing their own servers, it lowers the barrier significantly. But it doesn’t remove the responsibility. You’ll still need to monitor your infrastructure, handle scaling manually, and understand the complexities platforms automate away.

And that’s where platforms still shine. They give you an experience that’s hard to replicate—push your code, let the platform handle the rest, and scale dynamically when traffic spikes. You can still manage your platform costs by choosing an appropriate dyno size (hint: not Perf-M!) or enabling autoscaling (and tools like Judoscale can help).

Kamal’s a powerful new addition to the deployment landscape. It’s a tool that helps you take control of your infrastructure without building every piece from scratch. But for teams who value simplicity over control, platforms aren’t going anywhere.