Is a self-hosted Netlify alternative with Coolify the right move?
Coolify is the right move when your team wants fixed server costs in place of credit balances, or when site data must stay on servers you control, and you have people who can run those servers. Netlify remains the better fit when your sites depend heavily on its global CDN, Forms, Functions and deploy previews working out of the box with little operational effort. Since September 4, 2025, new Netlify accounts draw production deploys, bandwidth, web requests and compute from one monthly credit balance, so a renewal is a good moment to model your real usage against the credit allowance before deciding.
Netlify fits best when most of your value comes from its managed edge. That includes a CDN with no capacity planning, built-in forms and serverless functions that your team already relies on, and deploy previews that need no DNS or proxy work. Coolify fits best when your sites are mostly static or server-rendered apps that you can build with its Static, Nixpacks or Dockerfile build packs, when you accept that Coolify runs a coolify-proxy container on each server, and when you can replace Forms and Functions with services you host yourself. Coolify's self-hosted edition is licensed under Apache-2.0 and offers all features without restrictions, so the software cost is zero. The servers, storage, backups and patching are yours to pay for and run.
The decision turns on two questions. First, how much of Netlify's edge, forms and functions does your team actually use? Count the forms, serverless endpoints and CDN-dependent traffic, then price a replacement for each. Second, do you have people to run servers, backups and patches on a schedule? Coolify's rollback can redeploy a retained application image, but it does not restore databases or persistent files, so backup testing is your responsibility. If the answers point to heavy use of managed edge features and no operations capacity, staying on Netlify is the sounder choice. Confirm the exact credit allowance for your plan on Netlify's pricing page before you compare.
Which platform fits each scenario
This table matches common buyer situations to the platform that usually fits best and the condition that decides it. Read each row against your own traffic, build frequency, data location and operations staffing, since the right answer depends on those conditions more than on the product category.
| Scenario | Better fit | Deciding condition |
|---|---|---|
| Static marketing site with few builds per month | Netlify | Stay on Netlify if the credit balance covers builds and bandwidth at your traffic, and no one wants to run servers for a brochure site. |
| Static site with heavy traffic and predictable costs | Coolify on your own servers | Compare the monthly server cost with projected credit draw for bandwidth and requests, and confirm a CDN or caching layer meets your geographic needs. |
| Server-rendered app with a PostgreSQL database | Coolify | Coolify deploys PostgreSQL and schedules pg_dump backups, but you own restore testing and off-site storage of those backups. |
| Heavy reliance on Netlify Forms or Functions | Netlify for now, then plan a replacement | Inventory every form and function first, then decide whether your own services or an existing form tool can replace them before you move. |
| Data residency requirement for site content and user data | Coolify on servers in the required region | Confirm where Netlify processes and stores data for your contract, and where your own servers and backups will sit. |
| Team with no server operations skills | Netlify, or a managed Coolify Cloud plan with a clear support scope | Self-hosting shifts patching, backups, proxy certificates and recovery to your team, so confirm who will own those tasks. |
| Team that already runs Docker servers | Coolify | Existing Docker hosts meet the listed minimums (2 CPU cores, 2 GB RAM, 10 GB free disk on supported Linux), and the team can manage SSH access and updates. |
| Next.js app that needs the full feature set | Node.js or container deployment on Coolify, or Netlify's adapter when verified | Next.js documents full support for Node.js server and Docker deployments, while Netlify's verified adapter status should be checked against current Next.js docs. |
What changes in builds, CDN delivery and redirects
On Netlify, the build, the CDN and the redirect rules are one managed service. On Coolify, those three jobs split across a build pack, the proxy on each server and whatever edge layer you add yourself. Start by choosing the build pack for each site. The Static build pack suits prerendered sites, and Coolify's Git build packs also include Nixpacks, Dockerfile and Docker Compose, with a separate Docker Image method that skips the build stage when you already produce an image in CI. Netlify's build settings in netlify.toml do not carry over automatically, so list the build command, publish directory and Node version you actually use before you pick a build pack.
Coolify runs one coolify-proxy container on each server. Traefik is the default and Caddy is the alternative, and both obtain and renew HTTPS certificates automatically once DNS points at the server. The supplied Coolify capabilities do not include a global CDN or edge network. If your audience is spread across regions, confirm with your team which edge layer will cache static assets close to users, whether that is a third-party CDN in front of the server or a second deployment in another region. Netlify's CDN, edge caching and bandwidth metering have no direct equivalent on a single server, so measure your current asset load before you size the server.
Next.js documents full feature support when you deploy it as a Node.js server or a Docker container, while a static export supports a limited set of features. Platform support also depends on adapters, and the Next.js docs list Vercel and Bun as verified adapters while Netlify is still working on one. For a Netlify site built with Next.js, plan a Node.js or Docker build pack rather than a Static export if you rely on server rendering, middleware or image optimization. Confirm the feature list for your Next.js version against the Next.js deployment guide before you move. Redirects and headers from _redirects are a separate task, covered in the sibling page on replacing Netlify redirects and headers.
Capabilities side by side
This table compares what Netlify provides as a managed service with what Coolify provides on servers you operate. Read each row as a question to answer for your own sites, and treat any cell that says to confirm as an open item for your evaluation. Coolify covers build, routing and hosting; edge CDN, forms and functions need separate services.
| Capability | Netlify (managed) | Coolify (your servers) |
|---|---|---|
| Builds | Managed build runs from Git on Netlify's infrastructure, with usage drawn from the credit balance | Git repositories built with Nixpacks, Railpack (beta), Static, Dockerfile or Docker Compose build packs on your server |
| Static hosting | Static sites served by Netlify's hosting after deploy | Static build pack serves the built output through the proxy on your server |
| Server-rendered apps | Managed runtime for web apps and functions, with support depending on the framework | Nixpacks, Dockerfile or Docker Compose builds run the app as a container you operate |
| Preview deployments | Deploy previews and branch deploys built per change | Pull and merge request previews for GitHub, GitLab, Gitea and Bitbucket, needing wildcard DNS and removed on close or merge |
| Redirects and headers | Managed through _redirects and netlify.toml rules | Rules move to the proxy in front of the app (Traefik or Caddy); confirm each rule's behavior during migration |
| CDN and edge caching | Included global CDN serving assets from edge locations | No bundled CDN; confirm whether you need one and plan a separate CDN or caching layer |
| Forms | Built-in form handling and submissions | Not included; replace with your own form service and export existing submissions first |
| Functions | Managed serverless functions | Not included as serverless; run equivalent logic as containers or services you deploy |
| Databases and backups | Netlify does not host general-purpose databases; use an external provider | Deploys PostgreSQL, MySQL, MariaDB, MongoDB, Redis and others, with scheduled backups for some engines (confirm per engine) |
| Multi-server support | Managed by Netlify; not configurable by the customer | Connects to multiple servers over SSH; confirm sizing and topology for your load |
| Licensing and self-hosted edition | Proprietary managed service, billed in credits for new accounts since September 4, 2025 | Apache-2.0 licensed; self-hosted edition offered free with all features per Coolify's pricing page |
Which Coolify build pack replaces which Netlify workflow
Netlify usually builds a static site by running a command such as a static site generator and publishing the output directory to its CDN. In Coolify, the Static build pack serves a prebuilt directory through a web server container, so the same output can run on a server you control. Use this pack when the site has no server-side code and the build output is plain HTML, CSS, JavaScript and assets.
- Build output: Set the publish directory in Coolify to match the folder your generator writes, such as
distorpublic. - Build command: Coolify can run the build step for you, or you can build in CI and deploy only the output.
- Redirects and headers: Netlify's
_redirectsandnetlify.tomlrules must be translated to the proxy or web server configuration. - Previews: Preview URLs depend on wildcard DNS and the Git provider integration you configure.
Confirm with your team which Netlify features the site actually uses, because static sites often depend on forms, redirects or functions that the build pack does not provide.
Netlify detects many frameworks and builds server-rendered or hybrid apps with its own runtime. Coolify's Nixpacks build pack inspects the repository, picks a language and framework, and produces a container image without a hand-written Dockerfile. This suits a Next.js, Node or similar app where the default build and start commands are close to what the project needs.
- Detection: Nixpacks reads the lockfile and project files to choose the build; check the detected commands in the build log.
- Overrides: Set custom install, build and start commands in Coolify when the defaults do not match the project.
- Railpack (beta): Coolify lists Railpack as a beta Git build pack, so treat it as a trial option and pin your choice in production until it is stable for your stack.
- Runtime features: Confirm which framework features run in a Node server container, since the Next.js documentation supports the full feature set on that model.
Ask the team to confirm the Node version, the environment variables and any edge or serverless features that the app assumes.
Some teams already keep a Dockerfile for local development or for other hosts. In Netlify this project would not usually map cleanly, because Netlify builds its own runtime. In Coolify, the Dockerfile build pack builds the image exactly as the file describes, which gives the team full control over the base image, system packages and startup command.
- Control: The team owns the base image, the user, the exposed port and the health check.
- Port mapping: Set the port Coolify routes to in the application settings so the proxy reaches the container.
- Build context: Confirm the Dockerfile path and build context, especially in monorepos.
- Security: Pin base image tags and scan the image, because the team now maintains the runtime patching that Netlify handled.
Confirm who is responsible for rebuilding the image when base images receive security updates.
A Netlify site often calls separate services for functions, storage or a database. Coolify's Docker Compose build pack deploys a multi-service stack from one Compose file, so the web app, worker, cache and database can run together under one application entry. This replaces the mix of Netlify Functions and third-party services with containers the team operates.
- Services: Define each service, network and volume in the Compose file, and keep secrets in Coolify rather than in the repository.
- Routing: Coolify routes domains to the service you expose; other services stay on the internal network.
- Persistence: Volumes hold data, but database backups must be configured separately, because a rollback does not restore persistent files.
- Scale: One server is simpler to operate, but place services on several servers only after checking Coolify's multi-server documentation.
Ask the team which services they must supply, who owns each backup, and how each service recovers after a failed deploy.
Some teams build and test in a CI pipeline and want the server to pull a finished image. In Netlify this workflow has no direct equivalent, since Netlify builds from source on its own infrastructure. Coolify's Docker Image method skips the build stage and pulls an existing image, so the artifact tested in CI is the one that runs in production.
- Immutable artifacts: Tag images by commit so rollbacks redeploy a known version.
- Registry access: Give the server credentials for the registry and keep them in Coolify's secret store.
- Pipeline ownership: The CI system, not Coolify, now runs tests and builds, so the team must maintain that pipeline.
- Rollback limits: A rollback can redeploy a retained image, but it does not restore databases or persistent files.
Confirm the registry, the tagging scheme and who approves promotion from staging to production.
What replaces Netlify Forms and Functions
Netlify Forms and Netlify Functions are managed services, so on Coolify they become software your team deploys and operates. A Netlify form has no equivalent that Coolify provides on its own. The replacement is usually a small form-handling service (an open-source form backend or a few lines of code in your own API) that writes submissions to a database you control, or sends them to your mail or ticketing system. Serverless functions move into a container built from a Dockerfile, or into a service in a Docker Compose stack, deployed as its own application in Coolify and routed through the same proxy as the site. Confirm with your developers which functions run on request, which run on a schedule, and which depend on Netlify-specific APIs, since those need rewriting rather than a straight port.
Export form submissions and Netlify Blobs data before you cut over, and check what the export does not include. Submissions can be exported as CSV or through the API, and any data your functions keep in Netlify Blobs should be pulled with the paginated list method so nothing is missed. Record the count of submissions and blob keys before and after the export so you can compare them. Then plan storage for the new stack. Coolify's scheduled backups cover PostgreSQL, MySQL, MariaDB, MongoDB and ClickHouse, but not Redis, Dragonfly or KeyDB. If a function caches state or queues jobs in Redis-compatible storage, that data needs its own backup method, tested by restoring it to a separate server. Ask your developers which data is authoritative and which can be rebuilt, because that decides how much backup effort each store needs.
Where data lives and who holds the keys
Moving from Netlify to Coolify changes who operates the platform, where source code, build output, logs and visitor data sit, and who can grant or revoke access. Each card below covers one part of that shift, so you can map it to your own data classification and controls before any sites move.
Source, builds and artifacts
On Netlify, your repository connection, build environment and deploy archives sit in Netlify's managed service. With Coolify, Git access and build containers run on servers you choose, and the built images or static files stay in your registry or on your server disk. Confirm which Git provider tokens Coolify holds, where the deploy key is stored, and whether build caches or artifacts are kept after a deploy is removed.
Logs and runtime telemetry
Deploy logs, build output and runtime request logs are retained differently by each platform. Under Coolify, application logs are whatever your containers and proxy write to disk or to a log shipper you run. Decide where those logs go, how long they are kept, who can read them, and whether they contain tokens or personal data before you route production traffic through the proxy.
Visitor data at the edge
Netlify's CDN sees client IP addresses and request paths for every visitor before traffic reaches your site. A Coolify server receives those requests directly, which means your team now owns TLS termination, IP handling and request logging at the Traefik or Caddy proxy. Check whether you need a CDN in front of the server, how client addresses are forwarded, and what your privacy notice says about the new processor chain.
Identity and access control
Netlify team roles and Coolify teams and roles are separate permission models, and a Coolify administrator can reach every server, application and stored secret on the instance. Map each Netlify role to a Coolify role, rotate API tokens created for CI, and require multi-factor sign-in for administrators. Review who can deploy to production and who can open a server shell.
Hosting model and licensing
Coolify is licensed under Apache-2.0, and its self-hosted edition is free with all features. You can run it on servers you control or use Coolify Cloud, which hosts the Coolify instance while you bring your own servers. Netlify is a proprietary managed service, so your recovery path depends on its terms. Confirm which hosting model fits your data residency rules before choosing.
Compliance evidence and ownership
Once Coolify runs your sites, your team owns the controls that a compliance assessment will ask about: access reviews, change records, backup tests, patching of the host and proxy, and secret handling. DeployOpen can prepare those systems, controls and evidence for an assessment. Independent auditors and certification bodies issue any attestation, and the scope of their review should be agreed before work starts.
How credit pricing compares with flat server costs
Netlify now bills in credits, so its cost moves with how much you build and how many visitors you serve. Netlify moved all new accounts to credit-based pricing on September 4, 2025. Production deploys, bandwidth, web requests and compute all draw from one monthly credit balance. A busy month of builds or a traffic spike therefore lands on the same balance as your plan fee, and the total is hard to predict from the plan name alone. Coolify's self-hosted edition is licensed under Apache-2.0 and is free, with all features and no limitations, so its cost does not scale with builds or requests. What you pay instead is the servers, their storage, backups, bandwidth from your provider and the time your team spends operating them.
Coolify Cloud is the middle option. It costs $5 per month for 2 connected servers plus $3 per month for each additional server, with a 20% discount for annual billing, and you still bring your own servers. Those fees are fixed and easy to model, but they cover only the Coolify control plane, not the hosting. For a realistic comparison, add the server bills and the operator time to each path. For an illustrative team with three servers, the Coolify Cloud control fee would be $11 per month before the 20% annual discount, which is a useful anchor for the fixed part of the bill. Ask Netlify for current plan prices and for how credits are consumed by your specific build minutes, bandwidth and function invocations, because the plan figures are not covered here.
Model the credit burn from your own data before you compare totals. Pull the last three months of build counts and durations, bandwidth and request volume from your Netlify usage views, then estimate how many credits each category consumes at your current rates. Repeat the exercise for a peak month, since that is what drives a surprise overage. On the Coolify side, price the servers you would need for peak traffic and add the backup storage for your databases, the cost of an off-site copy and your operator hours. Ask any quote provider to state which costs recur monthly, which are one-time setup and what changes the bill when traffic doubles.
What a move from Netlify to Coolify involves
The sequence turns Netlify's bundled build, CDN, forms and functions into a set of sites your team runs on servers it controls, with each site verified on a staging domain before DNS moves. It ends with a documented backup and rollback plan that covers the data a rollback cannot restore.
Inventory sites, builds and dependencies
List every Netlify site, its repository, branch, build command, publish directory, environment variables and build image settings. Mark which sites are static, which need a Node.js or container runtime, and which depend on Netlify Forms, Functions, Blobs or identity features. The output is a single register that the platform team and site owners both sign off, so no site is migrated from memory.
Map redirects, headers and platform features
Translate each
_redirectsrule and eachnetlify.tomlredirect and header block into the proxy configuration that will sit in front of the site. Coolify runs Traefik by default or Caddy as an alternative, so confirm which one you will use before writing rules. Record every Netlify-specific feature, such as Forms, Functions or Blobs, with a named replacement, because these do not move automatically. The output is a mapping table reviewed against live Netlify traffic.Export sites and form submissions
Download a ZIP of the last successful deploy for each site as a fallback copy, export form submissions as CSV or through the API, and record the Netlify Blobs you need to keep. Confirm with the data owner which submissions must be retained and for how long, since that decision sets the retention policy of the replacement store. The output is a dated export folder with checksums and an inventory of what was not exported.
Prepare servers for Coolify
Provision Linux hosts that meet Coolify's documented minimums of 2 CPU cores, 2 GB RAM and 10 GB of free disk, on a supported distribution and on amd64 or arm64. Install Coolify with its script, then connect each server over SSH. Confirm that firewall rules, outbound access to your Git provider and DNS resolution work from each host. The output is a server list in Coolify that reports healthy on every node.
Build and test each site on a staging domain
Deploy each site from its Git repository using the Static, Nixpacks or Dockerfile build pack that matches its register entry. Point a staging domain at the application, then compare rendered pages, redirects, headers, status codes and asset paths against the live Netlify site. Test any replacement for forms and functions end to end. The output is a signed test record per site listing the checks passed and the known differences.
Configure wildcard DNS and preview deployments
Set up wildcard DNS for the preview hostname pattern, connect the Git provider through a GitHub App, webhook or the GitLab, Gitea or Bitbucket integration, and confirm that a test pull request builds and is removed when it closes. Agree with developers how many previews may run at once and who may open them, since previews are otherwise public URLs. The output is a working preview from a real pull request and a written note of the preview policy.
Set backups and cut over DNS
Configure scheduled backups for every database the sites use, store copies in S3-compatible storage outside the Coolify host, and run one restore test to a separate environment. Lower DNS time-to-live ahead of the change, move each domain in turn, and watch error rates and form delivery during the window. Coolify's guide for teams coming from managed platforms notes that a rollback can redeploy a retained application image but does not restore databases or persistent files, so write that limit into the runbook. The output is a cutover log and a rollback procedure that the operator has rehearsed.
Questions buyers ask before choosing Coolify over Netlify
What does moving from Netlify to Coolify cost in people and time?
The cost is mostly labor, not licenses, because the self-hosted edition of Coolify is free to use. The main drivers are the number of sites, how many use Netlify Functions, Forms or Blobs, how many redirect and header rules must be moved, and how much server and DNS work your team already has in place. Ask any quote to break out the cost of inventorying sites, rebuilding each one on a build pack, moving redirects, replacing Forms and Functions, setting up servers and backups, and cutover testing, with the hours and roles for each. Also ask who pays for ongoing operations after go-live.
Can our team switch from Netlify to Coolify without outside help?
Yes, a team with Linux and Docker experience can do it alone, and the Coolify installation runs from a single script on supported Linux distributions. The harder part is operating what Netlify used to handle for you: patching servers, the proxy, TLS renewal, the CDN decision, backups and recovery. Coolify's own guide for teams coming from managed platforms notes that a rollback can redeploy an application image but does not restore databases or persistent files. Outside help is most useful for scoping, redirect translation and runbooks, and it can be bought as a fixed-scope engagement with a written deliverables list.
What skills and access does the migration need from developers and operators?
Developers need to know how their sites build and which Netlify features they rely on, while operators need SSH access and the ability to run Linux servers. In practice, the work requires:
- Developers to confirm build commands, output directories and environment variables for each site.
- Operators to provision servers that meet Coolify's minimum of 2 CPU cores, 2 GB RAM and 10 GB of free disk, and to manage SSH connections to each server.
- Someone to own DNS, wildcard records and certificates.
Confirm with your team which of these roles already exist before requesting a quote.
How long does a Netlify to Coolify migration take?
The duration depends on the number of sites, their build complexity, how many Netlify-specific features they use, and how much infrastructure is ready. A site that is a plain static build with simple redirects moves faster than one that depends on Functions, Forms and Blobs. No standard duration is fixed by Coolify, so ask the provider for a timeline tied to a written scope, with milestones for site rebuilds, redirect translation, data export, parallel running and cutover. Check whether the plan includes a period where Netlify and Coolify both serve traffic.
Can Netlify Forms and Functions be replaced on Coolify?
Yes, but not with a single built-in feature. Coolify runs the application you deploy, so a form endpoint or serverless-style function becomes a service you build and host, such as a small API container, a form handler or a queue worker. Netlify form submissions can usually be exported as CSV or through the API before you switch, so confirm that the export covers the fields and file uploads you rely on. Ask any provider to list every Forms and Functions use case and assign a replacement for each one.
Is Coolify free to use, and what do I still pay for?
The self-hosted edition of Coolify is licensed under Apache-2.0, and its pricing page describes it as free forever with all features and no limitations or restrictions. You still pay for the servers that run it, the network, backups storage, domain names and the people who operate it. If you prefer not to run the control plane yourself, Coolify Cloud is priced at $5 per month for 2 connected servers plus $3 per month for each additional server, with a 20% discount for annual billing, and you still bring and pay for your own servers. Ask any quote to separate the one-time setup from recurring server, storage and support costs.
How do preview deployments and wildcard DNS work on Coolify?
Coolify builds pull or merge requests from GitHub, GitLab, Gitea and Bitbucket and gives each preview a default URL in the form pr_id.domain, which requires a wildcard DNS record pointing to your server. It deletes the preview when the request is closed or merged. Check the wildcard certificate approach with your DNS provider, and confirm that your Git provider's webhook or GitHub App is configured. Ask the provider to test a preview on a staging domain before cutover, and to document how previews are cleaned up if a webhook fails.
How DeployOpen helps teams evaluate and move off Netlify
DeployOpen plans, implements, hardens, documents and supports self-hosted open-source platforms inside your own cloud accounts, data centers or air-gapped networks. For Netlify vs Coolify, we start with a written scope that tests whether your sites, redirects, forms and previews fit a self-hosted setup before any migration work begins.
How we scope
- Inventory which sites are static, which are server-rendered, and which depend on Netlify Forms, Functions or Blobs
- Map your current credit usage to deploys, bandwidth and compute so cost comparisons use your own numbers
- Agree the scope, deliverables and timeline in writing before work starts, as all engagements are fixed-scope
- Confirm target servers, DNS ownership and wildcard certificate handling for Coolify with your team
How we build
- Set up Coolify on your servers and choose Traefik or Caddy as the proxy based on your routing needs
- Rebuild each site with the Static, Nixpacks or Dockerfile build pack, and document the build settings
- Translate _redirects and netlify.toml rules into proxy configuration, then test every redirect and header
- Run security testing against the migrated sites, APIs and any replacement services for forms or functions
How we hand over
- Deliver written runbooks covering deploys, rollbacks, preview cleanup and DNS changes for your team
- Configure database backups and restore tests, since a rollback does not restore databases or persistent files
- Document controls and evidence for your compliance assessors, while independent auditors issue any formal reports
- Walk your engineers through the handover so they can operate the platform without DeployOpen on call
How we support
- Offer ongoing support, upgrades and continuous security testing as a retainer after handover
- Plan Coolify version upgrades in your environment, including checks before moving between major releases
- Review server capacity, backup retention and monitoring each time traffic or site count changes
- Agree retainer scope and response expectations in writing, with no prices shown on this page

