Your Hoster Now Pays for Your Panel: What is*hosting's Coolify Sponsorship Changes — and Where the One-Click VPS Still Stops

"Supporting open source is not charity for us. Coolify users are exactly the audience we built our infrastructure for." That sentence, from is*hosting's Brand & Partnerships Manager Misha Malikin, is the most honest description of a new deal in self-hosting economics: in April 2026, the Estonian VPS provider became an official Coolify sponsor through GitHub Sponsors and shipped a production-ready, pre-installed Coolify image across 40+ locations on five continents. The hoster whose customers are self-hosters is now funding the open-source panel those customers install — and distributing it.

The interesting question is what that pairing actually changes. Who pays whom, what the one-click image is really worth versus installing Coolify yourself, and where the bundle stops: a pre-installed image provisions your first box, not your second. Here are the facts, then the math.

All plans run Xeon processors with KVM virtualization, a 1 Gbps port, and free weekly off-site backups. The Start plan is the minimum that meets Coolify's own requirements (2 CPU, 2 GB RAM, 30 GB storage) — enough, per the release, to run Coolify with a small number of services. At announcement time Coolify had 52,000+ GitHub stars and a 19,000-member Discord; it has since pushed past 60,000 stars.

Who pays for the panel: before and after​

Every self-hosted panel has the same awkward funding question. The software is free, the maintainer still needs to eat, and donations have never reliably covered maintenance. Coolify's answer so far has been a two-legged model: Coolify Cloud at $5/month for a managed dashboard covering two connected servers (plus $3/month per extra server), with a reported 3,400+ cloud customers, and GitHub Sponsors — where Hetzner already sits as a named big sponsor. Your apps always run on your own machines; you pay only for who operates the panel.

is*hosting adds a third leg, and it changes the shape of the table:

That last row is the whole story. A panel living on donations alone is maintained as long as goodwill lasts. A panel whose installs include a hoster's paying VPS customers is maintained because a vendor with 100,000+ managed servers and 50,000+ customers — ishosting's stated scale, operating since 2005 — now has its own support load riding on it. When the image breaks, ishosting's customers file tickets with is*hosting. The sponsorship is the receipt; the support queue is the enforcement.

This is also why the "not charity" framing matters. Every Coolify user is a VPS buyer by construction — the panel follows a bring-your-own-server model and runs nowhere else. Funding the panel is customer-acquisition spending with a maintenance contract attached, routed through the project's own sponsorship channel rather than a marketing invoice. Hetzner figured out the same math earlier from the other direction: sponsor the panel, collect the server rentals. is*hosting just bundled the two moves into one announcement.

What the pre-installed image is actually worth​

Strip the sponsorship away and the image is a time-saving product. Price it honestly: what does one click replace?

The manual path is well documented. Rent a bare VPS, SSH in, run Coolify's install script (curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash), wait, then do the unglamorous remainder the script doesn't do for you — DNS, firewall posture, initial backups, verifying the panel survived its first reboot. Practiced hands report around half an hour for the install itself; the surrounding setup pushes a careful first-timer toward an hour or two.

Two things stand out. First, the image premium on the cheapest tier is roughly $5/month over a bare budget VPS — paid back if it saves you even one hour, once, at any plausible hourly rate. For a solo developer or a small team spinning up its first box, that is an easy trade.

Second, and the part the launch copy won't emphasize: the image saves setup, not operations. You still update Coolify, still manage your apps, still own your backups and your firewall rules. A pre-installed image is a better day one, not a managed service. Anybody comparing $10.19/month against a managed PaaS bill and concluding self-hosting is now effortless is misreading what was purchased. What was purchased is a shorter path to the same ongoing responsibility — which, for the audience that wants full control, is exactly the right product.

Where the bundle stops: box number two​

Now the ceiling, which no launch-day coverage dwells on. The image provisions one machine. Forty-plus countries of one-click availability is geographic breadth, not fleet depth: it means your first box can be anywhere, not that your second box provisions itself.

Coolify can steer more than one server — this matters, so state it fairly. You can attach remote servers to one dashboard over SSH, offload builds to a dedicated remote build server, and even experiment with Docker Swarm. But every one of those servers arrives the same way: you rent it, you harden it, you validate and configure it into the panel by hand. The panel orchestrates what you give it; it provisions nothing. As one comparison put it, Coolify multiserver is multiple instances steered from one dashboard, not true clustering — and Kubernetes support remains the thing it explicitly doesn't do.

Concretely, outgrowing your first box looks like this:

1. Rent VPS number two (another $10–$30/month depending on size).
2. Harden it: SSH keys, firewall, updates — the image gave you a head start on box one, but box two's OS-level posture is still yours to establish.
3. Attach it to Coolify over SSH and validate the connection.
4. Decide what moves: split services across boxes, set up a remote builder, or wire Swarm mode that is still officially experimental.
5. Repeat steps 1–4 for box three, with no declarative record of what your fleet is supposed to look like. The fleet exists as a set of dashboard entries and your own memory.

None of this is a criticism of the panel — it is the boundary of what a panel is. A panel manages workloads on machines; a provisioning system manages the machines themselves. The moment "add capacity" means repeating a manual checklist per server, you have crossed from a panel problem into a fleet problem, and the fix is declarative machine lifecycle: machines described in versioned manifests, reconciled by controllers, added by changing a number rather than repeating a ritual. That is the architectural seam every single-box tool shares, whether it arrived via install script or one-click image.

The verdict: a better first box, and a clearer signal for the second​

So the sponsorship-plus-image pairing changes the economics exactly where the TODO promised and stops exactly where it warned. On the money side, Coolify gains a funder whose business depends on the software working — a strictly stronger maintenance guarantee than donations, and a template other hosters can copy now that two of them (Hetzner first, is*hosting with distribution attached) have shown the shape. On the provisioning side, nothing changed: your fleet still grows one manual server at a time.

For the typical first-box user — a solo developer, a side project, a small team consolidating onto one VPS — this is unambiguously good. Ten dollars and change buys the shortest path from zero to a working panel, on infrastructure whose vendor is now financially invested in the panel staying alive. Take the deal.

For the team already eyeing box two and three, read the announcement as pricing information about your own future ops load instead. Every machine past the first costs the VPS rent plus the manual attach-and-harden cycle, with no manifest describing the fleet you meant to build. At that point the question stops being "which panel" and starts being "which machine lifecycle" — and that is a different product category, one where the servers are cattle described in git, not pets adopted one click at a time.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Star the repo on GitHub or deploy your first app today.