Anass Ez-zouaine — Senior Backend Engineer · Software Architect · AI Engineer — DevOps

The Coolify revolution: why I'm ditching expensive cloud providers for self-hosted SaaS

Sat, 30 May 2026 00:00:00 GMT

Most SaaS founders are quietly getting robbed by their own cloud provider.

I have spent over a decade building and scaling web applications, and if there is one thing I have learned, it is that the "cloud tax" is the most effective way to kill your margins before you even find product-market fit. We have been conditioned to believe that unless our small CRUD app is running on a multi-region, auto-scaling AWS EKS cluster, we are doing it wrong.

That is a lie designed to keep you paying for complexity you do not need.

The architecture of a trap

It starts innocently enough. You sign up for AWS or GCP because they give you $1,000 in credits. You spin up an RDS instance for your database, a few S3 buckets for storage, and maybe a managed Kubernetes service because it feels "professional."

Then the credits run out.

Suddenly, you are paying $200 a month for a database that is 99% idle. You are paying for NAT gateways, provisioned IOPS, and "management fees" for services that could easily run on a $5 VPS. You are stuck in a web of proprietary APIs and IAM roles that require a full-time DevOps engineer just to update an environment variable.

This is the agitation: managed services feel like a superpower at the start, but they become a golden cage as you scale. The complexity overhead alone is enough to slow your development velocity to a crawl. When I look at how AI is changing traditional development, it becomes clear that we need to move faster, not get bogged down in infrastructure molasses.

Enter Coolify: Heroku's open-source soulmate

The solution I have moved my entire stack to is Coolify.

Coolify is an open-source, self-hostable alternative to Vercel, Heroku, and Railway. It gives you that same "git push to deploy" experience we all love, but it runs on your own hardware. Whether you have a $4 VPS on Hetzner or a massive ARM-based instance on Oracle Cloud, Coolify turns it into a private PaaS.

I recently wrote about how Coolify and Docker are changing SaaS hosting, but the shift is deeper than just a tool change. It is a mindset shift toward technical sovereignty.

Here is what makes Coolify a game-changer for a senior engineer:

Zero vendor lock-in — your configurations are stored on your server. If Coolify disappeared tomorrow, your Docker containers would keep running.
Automatic SSL — it handles Let's Encrypt out of the box. No more messing with Nginx configs or certbot.
Database management — you can spin up Postgres, MySQL, Redis, or MongoDB in one click. They run as containers on your server, meaning you pay $0 in additional managed service fees.
Pull request deployments — it creates temporary environments for every PR, just like Vercel, but without the "team seat" tax.

The magic of ARM (Graviton and OCI)

If you want to see a 90% reduction in your infrastructure bill, you need to stop using x86 and start using ARM.

AWS Graviton instances are roughly 20-40% cheaper and more performant than their Intel-based counterparts. But the real "cheat code" right now is Oracle Cloud Infrastructure (OCI). Their "Always Free" tier gives you 4 ARM Ampere A1 cores and 24 GB of RAM for free.

I can run an entire production SaaS — frontend, backend, database, and Redis — on that single free instance using Coolify.

When you pair ARM efficiency with a self-hosted orchestrator, the math changes. A startup that was paying $500/month on AWS can often move that entire workload to a $40/month ARM instance on Hetzner or OCI. That extra $460 goes back into your pocket or your marketing budget.

Docker and Nix: the engine room

Coolify relies heavily on Docker, which is the industry standard for a reason. It ensures that what works on my machine works on the server. But as I move deeper into the "vibe coding" era, I'm also looking at how technologies like Nix can further stabilize our environments.

By using Nix flakes to define our development environment and Docker to package the runtime, we create a bulletproof deployment pipeline. When I use tools like the Model Context Protocol (MCP), I want my AI agents to have a clear, reproducible environment to work within. Self-hosting doesn't mean "unprofessional" — it means having total control over the stack.

Comparison: the hidden cost of "easy"

Let's look at the numbers for a standard Laravel or Node.js app with a database and a background worker.

The managed path (Vercel + Supabase + AWS S3):

Vercel Pro: $20/month per user
Supabase Pro: $25/month
AWS S3 + bandwidth: $15/month
Total: $60+/month (and rising with every user/teammate)

The Coolify path (Hetzner VPS):

4 vCPU ARM / 8GB RAM: $6/month
Backups to S3-compatible storage: $1/month
Coolify: $0 (open source)
Total: $7/month

The "managed" path is nearly 10x more expensive before you even have your first 100 users. For a senior engineer, the 30 minutes it takes to install Coolify on a fresh Linux box is worth the thousands of dollars saved over the life of the project.

Practical steps to join the revolution

If you are tired of the cloud tax, here is my recommended path to freedom:

Grab a VPS — I recommend Hetzner for raw performance/price or OCI for their insane free tier. Pick an ARM-based instance (Ubuntu 24.04).
Install Coolify — run the one-line install command from their documentation. It takes about 5 minutes.
Connect your Git — link your GitHub or GitLab account.
Dockerize your app — if you are using Laravel, it is as simple as adding a Dockerfile. For Vite or Next.js, Coolify has built-in builders that don't even require a Dockerfile.
Move your DB — export your managed DB and import it into a Coolify-managed container. Set up S3 backups immediately.

The bottom line

We are entering a cycle where efficiency is the only thing that matters. The days of "VC-subsidized" infrastructure are over. Whether you are building a small tool or a massive enterprise SaaS, you owe it to your bottom line to look at self-hosting.

Coolify has matured to the point where the developer experience is indistinguishable from the big players. The only difference is who owns the keys to the castle.

I am curious: what is the most "expensive" mistake you have ever made on a cloud bill — a forgotten NAT gateway or a runaway Lambda function? Drop a note via contact. 🤘

Effortless SaaS hosting: the Coolify and Docker deployment guide

Sun, 19 Apr 2026 00:00:00 GMT

Shipping a SaaS is hard enough without the constant anxiety of a "surprise" bill from your hosting provider. I have seen developers start a project on a managed platform only to find that as soon as they add a second team member or cross a certain bandwidth threshold, their costs skyrocket. You are trapped between paying a "convenience tax" that eats your margins or spending your entire weekend fighting with Nginx configurations and manual SSH commands. It feels like you are either overpaying for simplicity or overworking for control.

The agitation grows when you realize that most managed platforms are essentially wrappers around the same open source tools you could run yourself. You are paying for a pretty dashboard and an easy git-push flow. But when you try to leave, you find yourself deep in vendor lock-in. Your databases, your environment variables, and your build pipelines are all tied to a proprietary ecosystem. If the platform goes down or changes its pricing, your business is at the mercy of their support team.

There is a better way. Coolify combined with Docker gives you the exact same developer experience as high-end managed platforms but on your own infrastructure. You get the "one-click" deploy feel and a beautiful dashboard while keeping 100 percent control over your servers. It is the ultimate setup for a modern web application that needs to scale without breaking the bank.

Why the cloud is getting more expensive

In the early days of a startup, a $20-per-month plan feels reasonable. But as you grow, those costs don't just add up — they multiply. Many platforms now charge per seat. If you have a team of five engineers, you might be paying a hundred dollars a month before you even deploy a single line of code. Then come the usage fees. Bandwidth, image optimization, and serverless function execution costs are often opaque and difficult to predict.

I have worked with clients who moved their entire stack from managed services to a self-hosted Coolify setup and saw their monthly infrastructure bill drop by eighty percent. We are talking about moving from $500 a month down to $50 a month while maintaining the same performance and reliability. When you own the server, you own the resources. There are no "hidden" charges for extra build minutes or database connections.

What exactly is Coolify?

Think of Coolify as an open source, self-hosted version of Heroku or Vercel. It is a control plane that sits on your server and manages everything for you. It handles your deployments, your reverse proxies, your SSL certificates, and your databases. It turns a raw Linux VPS into a powerful hosting platform.

One of the best parts about Coolify is that it is built on Docker. Every application you deploy is containerized. This means your environment is consistent across development, staging, and production. No more "it works on my machine" excuses. If it runs in a container on your laptop, it will run exactly the same way on your Coolify server.

The power of Docker containerization

Docker is the silent engine that makes this entire workflow possible. Instead of installing PHP, Node.js, or Python directly on your server, you package them into a container image. This approach has several key benefits for SaaS founders:

Isolation. Each app runs in its own sandbox. A memory leak in one app won't crash your entire server.
Portability. You can move your containers from Hetzner to DigitalOcean to AWS in minutes.
Version control. Your infrastructure is defined as code. You can version your Dockerfile just like your application code.
Scalability. Adding more instances of your app is as simple as spinning up another container.

When I build custom web solutions, I always prioritize Docker. It ensures that the handoff to the client is seamless. They don't need to worry about the underlying server configuration. They just need a Docker-compatible environment.

Setting up your control plane

Getting started is surprisingly simple. You need a fresh VPS with at least two gigabytes of RAM. I typically recommend Ubuntu for the operating system. Once you have your server, you run a single installation command provided by the Coolify documentation.

# the only command you need to bootstrap Coolify
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash

This script takes care of installing Docker, setting up the Traefik reverse proxy, and launching the Coolify dashboard. Within minutes, you can log in to your own private hosting panel. From there, you can connect your GitHub or GitLab account. Coolify will listen for webhooks and automatically trigger a new build whenever you push code to your main branch.

It feels magical. You get the same feedback loop as the big-name platforms. You see the build logs in real time. You get a preview URL for your feature branches. And you do it all on a $5 VPS.

Handling databases and state

One of the biggest pain points of self-hosting is managing databases. Nobody wants to manually configure Postgres clusters or worry about backing up Redis instances. Coolify solves this by offering "one-click" services.

You can spin up a Postgres, MySQL, MongoDB, or Redis instance in seconds. Coolify automatically generates secure credentials and provides you with the connection strings. It also handles persistent volumes. This means that even if your container restarts or you update the image, your data stays safe.

For a SaaS, I usually recommend a dedicated server for your databases if you have high traffic. Coolify makes this easy because it supports multi-server setups. You can have one server acting as your "control plane" and several other servers acting as "worker nodes" where your apps and databases actually live. (I cover that scaling pattern in more depth in Scaling with confidence: advanced Coolify deployment strategies.)

Security and SSL by default

Security shouldn't be an afterthought. In the old days, setting up SSL with Let's Encrypt required cron jobs and manual certificates. With Coolify and Traefik, it is entirely automated.

When you point a domain to your server and add it to your app configuration, Coolify automatically requests and installs an SSL certificate. It also handles the renewal process. Your SaaS is always served over HTTPS without you ever touching a terminal.

Beyond encryption, Coolify helps you manage your environment variables securely. You don't need to hardcode secrets in your git repository. You can define them in the dashboard, and they are injected into your containers at runtime. This is a standard best practice that many developers skip when they are in a rush.

The senior engineer's workflow

If you want to do this the "pro" way, here is how I structure my deployments.

Use a Dockerfile

While Coolify can automatically detect many frameworks like Laravel or Node.js, I always recommend writing your own Dockerfile. It gives you total control over the build process. You can optimize your image size by using multi-stage builds. This makes your deployments faster and saves disk space.

Leverage Nixpacks

If you don't want to write a Dockerfile, Coolify supports Nixpacks. It is a tool developed by Railway that looks at your code and builds an optimized container image automatically. It is incredibly smart and works for almost every major framework.

Set up health checks

Never deploy without a health check. You want to make sure your app is actually responding before the reverse proxy starts sending traffic to it. Coolify allows you to define a health check endpoint. If the check fails, the old container stays running, and the new one isn't promoted. This is the foundation of zero-downtime deployments.

Is self-hosting right for you?

Self-hosting isn't for everyone. If you are a solo developer with zero interest in learning how a server works, then paying the "convenience tax" might be worth it. Your time is valuable, and if a managed platform saves you five hours of frustration a month, it might pay for itself.

However, if you are building a real business, you need to understand your stack. Owning your infrastructure is about more than just saving money. It is about autonomy. It is about knowing that no matter what happens to a specific provider, you can move your business elsewhere in a heartbeat.

At Ansezz, I focus on building robust, scalable systems that empower clients. Whether the work is a complex e-commerce engine on Shopify or a custom Laravel application, the goal is always the same: high performance and long-term stability.

Final takeaways for your deployment strategy

Hosting shouldn't be a source of stress. By moving to a Docker-based workflow with Coolify, you reclaim your time and your budget. You get the professional features of a top-tier PaaS without the enterprise price tag.

Here is your checklist for a successful transition:

Start with a clean VPS and install Coolify using the official script.
Containerize your application using a Dockerfile for maximum control.
Use one-click services for your databases and enable automatic backups.
Set up your domain and let Coolify handle the SSL certificates.
Implement health checks to ensure zero-downtime updates.

When you stop worrying about the "how" of deployment, you can spend more time on the "what" of your product. That is where the real value is created.

What is the one thing stopping you from moving your SaaS to a self-hosted setup today? Tell me about it — happy to share war stories.

Scaling with confidence: advanced Coolify deployment strategies

Sun, 11 Jan 2026 00:00:00 GMT

You've finally moved your apps off that messy manual VPS and into Coolify. It feels great. Everything is in one place. But then the traffic starts to spike. You realize that hosting your production database, three web apps, and a memory-heavy build process on a single $10 DigitalOcean droplet is a recipe for disaster.

The "single server trap" is real. It's fine for a side project or a quick MVP. But when you're building for real customers, you need more than just a dashboard. You need a strategy. You're worried about what happens when that one server hits 100% CPU or when a simple deployment takes your whole site down for five minutes.

I've spent the last decade scaling web applications and building custom solutions at Ansezz. I've seen self-hosted setups crumble under pressure because they lacked the right architecture. The good news is that Coolify is more than capable of handling high-scale workloads. You just need to know how to pull the right levers.

In this guide, I'm going to show you how to move from a basic setup to a production-grade infrastructure using advanced Coolify strategies. We're talking multi-server nodes, zero-downtime deployments, and offloading the heavy lifting so your apps stay snappy.

Moving beyond the single-server monolith

The biggest mistake I see engineers make is keeping everything on one node. When your build process starts, it eats up CPU and RAM. Your web app starts to lag. Your database gets starved for resources.

The solution is to decouple your "control plane" from your "workloads."

In a professional setup, you want one small server dedicated solely to running the Coolify instance itself. This is your mission control. Then, you add separate "app servers" where your actual containers live.

To do this in Coolify, you go to the Servers tab and add a new server via SSH. Once it's connected, you can choose which server a specific resource should be deployed to. This gives you instant horizontal scalability. If one server is getting full, you just spin up another one, add it to Coolify, and point your next app there.

This separation of concerns is a core pillar of what we do when building custom web applications. It prevents a single point of failure from taking down your entire digital presence.

The art of the zero-downtime deploy

Nothing kills user trust faster than a "502 Bad Gateway" every time you push a small CSS fix. By default, many self-hosted setups just kill the old container and start the new one. There's a gap. That gap is where your users get frustrated.

Coolify handles this beautifully with "rolling updates," but it only works if you tell it how to check the health of your app.

If you don't configure health checks, Traefik (the reverse proxy Coolify uses) might start sending traffic to your new container before the app inside it has even finished booting up.

Here is the workflow I use to ensure 100% uptime:

Create a health endpoint. In your Laravel, Vue, or Node app, create a simple route like /healthz. It should return a 200 status code only when the app is ready to serve traffic.
Configure Coolify. In your application settings, go to the Health Check section. Set the path to /healthz and the interval to something like 5 seconds.
The rollout. When you hit deploy, Coolify starts the new container. Traefik waits until that /healthz endpoint returns a success before it switches the traffic over. The old container is only killed after the new one is confirmed live.

This is a non-negotiable step for any SaaS or e-commerce store where every second of downtime equals lost revenue.

Offloading the heavy lifting

If you're building a modern app with Docker, the build process can be incredibly resource-intensive. Compiling assets, installing npm packages, and building images can spike your server usage to the moon.

If you're running that build on the same server that's trying to serve your customers, they're going to feel the slowdown.

Advanced users leverage a dedicated build server.

You can designate a high-performance, high-CPU server in Coolify specifically for builds. When you trigger a deployment, Coolify pushes the code to the build server, creates the image there, and then pushes the finished image to your production app server.

Your production server never feels a thing. It just gets a fresh, ready-to-run image.

What about the database?

While Coolify makes it easy to click "New Database," running your production Postgres or MySQL inside a Docker container on the same server as your app is risky.

For production workloads, I almost always recommend using an external managed database like AWS RDS or Google Cloud SQL. It handles backups, point-in-time recovery, and scaling automatically.

In Coolify, you simply provide the connection string as an environment variable. This keeps your state (the data) separate from your compute (the app). If your app server goes up in flames, your data is safe on a managed platform.

Automation at scale with CI/CD

Manual deployments are for hobbyists. For a professional workflow, you want your code to move from GitHub to production without you touching a single button in the Coolify UI.

I prefer using GitHub Actions for this. While Coolify has a great GitHub App integration, using Actions gives you more control. You can run your test suite, lint your code, and only if everything passes, trigger the Coolify deployment via a webhook.

Here is a snippet of how I usually structure a simple deployment step in a .github/workflows/deploy.yml file:

name: deploy to production
on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: trigger coolify webhook
        run: |
          curl -X GET "${{ secrets.COOLIFY_WEBHOOK_URL }}"

It's simple, direct, and ensures that broken code never reaches your servers. It keeps your development cycle clean and your mental health intact.

Advanced configuration tips

Managing a multi-server setup requires a bit of extra care. Here are a few practical takeaways to keep in your back pocket:

Resource limits. Always set CPU and RAM limits in Coolify for each application. This prevents a single "leaky" container from hogging all the resources and crashing the whole server.
External backups. If you do choose to run databases inside Coolify, use the S3-compatible backup feature. I personally use Backblaze B2 or Cloudflare R2 for this. Never rely on local backups alone.
Docker pruning. Coolify is good at cleaning up, but it's worth checking your disk space regularly. Large images can eat up your SSD fast. Set up a cron job or use Coolify's built-in cleanup settings.
Monitoring. Use a tool like Better Stack or GlitchTip to monitor your endpoints. Coolify tells you if the container is running, but an external monitor tells you if a human can actually use the site.

Scaling is a journey

Scaling isn't about having the most expensive hardware. It's about having a system that is predictable and resilient. Coolify gives us the tools to act like a giant tech company without the massive overhead of a dedicated DevOps team.

By splitting your servers, mastering health checks, and automating your builds, you move from "hoping it works" to "knowing it scales."

I've helped dozens of founders and tech leads navigate these waters. Whether you're building a Shopify app or a complex Laravel SaaS, the principles are the same. Keep your compute separate from your data, and your builds separate from your traffic.

Have you ever had a deployment go sideways because a build process crashed your production server? What's your current "war story" from the world of self-hosting? Drop me a line.