Coolify vs Dokploy: Why I decided to use one over the other Transcript, AI Summary & Key Points

00:00 For the past few months now, I've been deploying the majority of my production services to a VPS through the use of Dock Ploy. I originally did an entire video talking about how it had become my favorite way to deploy to a VPS in 2025. Uh taking over from my original setup of using Docker Stack. In that video, I mentioned that I looked at a few different options when it came to finding a new platform for me to deploy on with one of the main contenders being Coolify.

00:25 Ultimately, I decided to pass on Coolify and chose Doc Ploy for a few different reasons. I intentionally decided to not share those reasons on that original video as I wanted it to focus more on setting up Dock Ploy and deploying an application through it rather than comparing different options to one another. However, as it turns out, a lot of you were really interested in why I didn't go with Calify.

00:47 In fact, it was perhaps the most common question that I got asked in that video's comments. Therefore, I decided to do an entire video talking about not only why I chose Dockploy over Coolify, but also doing a more in-depth comparison between the two, looking at what they have in common, as well as some of the key differences in order to help you decide which one might be right for you.

01:08 Before I begin comparing both Docloy and Koolifi to one another, let's take a little bit of time to quickly give an overview of each of these projects and what they share in common. Both Docloy and Kulifi are known as platforms as a service which are services that enable developers to deploy, manage and scale applications without having to worry about the underlying infrastructure complexities.

01:31 Some of the more popular platforms as a service include Versel, Netlefi and Railway. [clears throat] However, these are proprietary platforms whereas both Coolify and Docy make use of open-source technologies and are self-hostable. This provides a few key benefits such as enabling you to have full control of your infrastructure and data whilst also allowing you to deploy your application on either VPS instances or even hardware that you own.

01:56 This typically means that you have more predictable long-term pricing with no unexpected bills, which can often happen when using a serverless platform such as Versel. Additionally, there's no platform specific limitations on languages or frameworks, and you have complete freedom to be able to migrate your applications to another service without being tied to a particular vendor's ecosystem or pricing structure.

02:20 As for these specifics about each platform, well, let's begin with Coolify. Coolify was first created by Andras Bachai, who started the project back in 2022 and has been working on it full-time since middle of 2023. The application itself is built using PHP with the most recent version at the time of recording being Laravel. Under the hoods, it makes use of Docker in order to both build and deploy applications.

02:44 Uh, similar to what I was doing when it came to Docker Stack. If we take a look at the GitHub stats for Coolify, we can see that since February of 2022, the project has gained over 12,000 commits with a good number of those taking place recently, which means that the project is being actively developed. In addition to this, however, the project is also well-loved, having gained over 44,000 stars and also being well regarded on both YouTube and Twitter/X.

03:08 If we now go ahead and take a look at the GitHub page for Doc, we can see that it's a much newer project being started just over a year ago in April of 2024 by the developer Mauricio Su. Despite being relatively new, however, Doc Ploy has managed to absolutely crush it when it comes to developer cadence with just over 4,000 commits and 24,000 stars.

03:28 As for Doc Po's techstack, similar to Coolify, it makes use of Docker technologies in order to both build and deploy applications. When it comes to the web app, however, this is where it differs as rather than being built using PHP and Laravel, it's instead built using Next.js and some common Typescript packages such as better or sonner, etc., etc. Whilst the tech stack of a platform might feel like an implementation detail, for myself, it absolutely plays a role when choosing one platform over the other, as by

03:59 choosing one with a tech stack I have a better understanding of, it means I'm more likely to be able to contribute to the project if I ever need to, which does happen from time to time. In any case, that covers the basic overview of each of the two platforms, as well as some of the similarities that they share. Now, let's take a look at some of the differences by comparing them against one another to see which one I not only prefer, but which one might also be best for you.

04:22 For this comparison, I've gone ahead and drafted out a number of different categories in order to review and compare each platform against, which I'll then assign a winner to on each category, as well as sharing some of my own personal opinions. In order to do this, however, I'm going to need to have both an instance of Coolify and Docky deployed in order to review.

04:41 This means I'm going to need to have not one but two VPS instances in order to compare both at the same time without there being any resource contention. Fortunately, that's where the sponsor of today's video comes in. Hostinger, who not only provide long-term high resource VPS instances, but they also happen to sponsor both the Coolify and Dog Boy projects, which in my opinion is honestly great to see.

05:04 When it comes to the VPS instances that I'm going to use throughout this comparison, uh to keep things as consistent as possible, I'm going to go ahead and use a KVM2 instance for each one. The KVM2 comes with two vCPUs, 100 GB of SSD storage, a massive 8 gigs of memory, and a huge 8 TB of monthly bandwidth, which is going to be more than enough for one's self-hosting needs.

05:25 Being able to use high resource VPS instances is one of the main benefits of using either coreify or docloy over something such as Vel or Railway, which if you ended up sending 8 terabytes of data through, uh, might end up costing you a kidney. When it comes to hosting, however, the KVM2 only costs you $6.99 a month when you purchase a 24-month term.

05:44 If that wasn't [clears throat] affordable enough, you can actually save even more money on this VPS instance by using my link in the description down below and using the coupon code dreams of code to get an additional 10% off. So to get your own VPS instance to host either Coolify or DOC ploy uh whichever platform is right for you, then visit hostinger.com/dreams of code or use the link in the description down below.

06:06 And make sure to use my coupon code dreams of code to get an additional 10% off. A big thank you to Hostinger for not only sponsoring this video, but also for sponsoring great projects like Coolify and Doc Ploy. Okay, with both my VPS instances acquired, let's go about installing both Coolify and Doc Ploy to their own respectively. The easiest way to achieve this when using Hostinger is to select either the Coolify or Docy pre-built image when setting up the VPS.

06:31 However, because one of the categories I have for comparison is the ease of installation, then I'm going to go ahead and set up these VPS instances from scratch, which means I'm instead going to go ahead and use the latest YUbuntu LTS as the base operating system. With my operating system selected, the next thing I'm going to do is quickly speedrun through the VPS setup, mainly because I've done it a few times already on this channel.

06:55 However, if you want a quick overview, basically I'm just going to go ahead and set up the SSH keys and root password followed by SSH in installing and registering tail scale and then adding in a firewall to disable SSH access over the public internet. Pretty simple. Additionally, I'm also going to go ahead and set up a couple of DNS records for both Coolify and Doc Ploy pointing at the IP of their respective VPS instance.

07:17 Here I'm doing it within the hosting a dashboard as I already have a domain name set up to use throughout this video. Okay, with that, the VPS instances are now set up and configured. So, let's go ahead and begin comparing the installation process for each one to see which one is easier. Both Coolify and Docky provide a single command you can use to install the application, which takes a few minutes in each case.

07:40 When it comes to the installation, Coolify does provide more information about what's happening at each step, which I think is a nicer user experience. It also provides some light entertainment through the form of terrible dad jokes. Once the installation is complete, both Coolify and Doc Ploy produce an IP port combination you can use to access the next setup step, which is to create your first admin account.

08:01 Both of these are done over HTTP, which isn't great, but it is understandable. I do wish that either of these had the ability to be able to set up HTTPS during the installation uh so that you could set up your admin accounts securely. In my case, however, I mitigate this by using the Tailscale machine host name, so connecting via Tailscale instead, which means the credentials will be transmitted securely as they'll be encrypted by WireGuard.

08:23 One thing that I do really like about Coolifi's install script is that it also displays your nodes private IP options as well that you can connect to in order to set up, which makes it easier to access your instance over your Telnet. After creating the admin account, this is when the two platforms start to diverge when it comes to the setup process.

08:42 This is because Coolify prompts you to set up through on boarding, which I think is a great user experience for beginners. Unfortunately, however, in my own personal setup, I kept running into an issue where Coolify couldn't actually set up the local server for deployments, with the main issue being that it couldn't connect to itself via SSH. This was caused by the fact I had set up my firewall to deny public SSH access, only allowing it over my tail scale interface.

09:08 However, resolving this wasn't actually that simple. I initially tried to add a few allow options into my UFW firewall, such as allowing SSH on the Docker interface as well as any of the bridge networks, but for some reason, I couldn't get SSH from the Coolify container to work without disabling my firewall. In the end, I managed to resolve this by setting up a rule to only deny SSH on the ETH0 interface, whilst also enabling it for the 10.0.0.0/8 subnet, uh, which would cover all of the Docker networks.

09:39 Upon doing so, I was then able to set up the local server on Coolifi successfully. Whilst this wasn't too challenging to resolve, it did require a little bit of networking knowledge. And because the solutions I expected to work didn't, it left me with a slightly negative experience of the setup process, especially as denying SSH is a common security practice.

09:58 Now, this isn't entirely Coolifi's fault. However, because as I mentioned, this is a common security practice, then again, it just didn't feel like it perfectly suited my needs. This became even more pronounced when comparing the setup experience of Doc Ploy, which just worked straight away out of the box. And whilst Doc doesn't have an onboarding step like Qualify does, I honestly found it didn't really need one, especially as I ended up deleting the initial resource that Coolify created.

10:25 Anyway, as for the other setup steps, which included things like setting up a domain name and HTTPS, this was a pretty similar experience between the two with most of the major differences coming down to the UI UX of each platform, which is a category I'll cover later on. As for which platform had the best overall ease of setup, well, whilst Coolify had the edge when it came to the installation process, for myself, I think that Docboy is the winner when it comes to the overall experience.

10:53 This is due to it working seamlessly with my own personal security configuration and firewall. Uh but also because I found that qualifiers onboarding didn't really add much value. Now to be fair, installation and setup is typically a one-off process. Therefore, let's instead take a look at the next category, which is something that affects the entirety of the platform's life cycle, resource usage.

11:16 In order to compare this effectively, I decided to check the resource usage of each platform a number of different times throughout the life cycle of using them. The first time that I did so was a few hours after installation without any other services running in order to establish a baseline. To do so, I made use of the hosting a dashboard which provides a number of metrics related to server usage.

11:37 Here you can see that the memory usage of each platform was pretty similar, hovering around 1 GBTE each, give or take a few megabytes. This is actually quite high in my opinion, but makes sense when you consider the technologies that each platform is using tend to be on the higher end of memory consumption, especially when you compare it to compiled languages such as Rust or Go.

11:59 If you're deploying these platforms on a provider like Hostinger, then this memory usage isn't too much of an issue. But if you were using an instance with less memory, then it's definitely something to be aware of. Whilst the memory usage was roughly equal for both platforms, the same couldn't be said when it came to CPU usage. For Docy, this was a very small amount on average between 0.8 and 1.5%.

12:22 Which is extremely efficient. Coolify, on the other hand, kept hovering between 6 and 7% even though there were no services running, which to me felt kind of high. Of course, this was just the baseline, but it unfortunately didn't get any better after deploying the same services on each instance. Whilst memory usage did increase for each platform, when it came to Coolify, this number was a lot higher.

12:44 This was also true when it came to CPU usage, which for Coolify increased even further once services were running and got even higher when I enabled metrics for the platform, which I'll talk more about later on. In order to make sure that this wasn't an issue with my VPS instance or that I just hadn't configured something weird, I decided to redeploy Coolify across a number of different VPS instances in order to see if I got the same numbers, which unfortunately I did, leading me to the conclusion that Calify just uses

13:13 more CPU cycles when idle. Now, whilst it's not a huge amount, it's definitely enough to be considerate of, especially if you're running on a single node. And whilst both dock ploy and cruify make it incredibly easy to deploy applications across multiple servers, I imagine most people will start with a single node setup until they need to scale. [snorts] Therefore, when it comes to this category, it's going to be another win for dog ploy.

13:35 The next category I want to compare is how each platform handles structuring of their resources. So things like teams, projects, and services. If we start at the top, the highest level of grouping is teams on qualify and organizations. when it comes to doc ploy uh both of which are pretty much the same thing allowing you to group users and projects together.

13:55 Uh one thing to note is that teams on qualify also have servers segmented between them whereas on dock ploy any team has access to any server. Next we then have the concept of projects on each platform which is used for grouping related services and applications together. The next step down is when things start to differ between the two platforms as Coolify allows you to have different environments inside of a project with production being default.

14:23 Doc Ploy on the other hand doesn't really have a concept of different environments. Instead, it goes straight down into the final form of resource which is the actual running applications which in dock ploy are called services and in coolify are called resources. Basically the main difference between the two platforms is that when it comes to docloy services belong to a project and in codify resources belong to an environment which in turn belongs to a project.

14:47 This is kind of a small detail but it does provide an additional dimension when it comes to codify especially for things such as shared variables which in codify you can define for either project or environment scopes whereas when it comes to doc ploy you can only define these for projects. Now to be fair, you can achieve environments using dog ploy.

15:06 For example, you could just define a project as either being dev or prod. But I do think that Coolify having this by default is perhaps a little bit more intuitive. Even though it does mean you have to drill down another layer in order to access your services. Of course, whether or not you're going to want or need environments is totally going to be subjective.

15:22 However, thinking about this objectively, I personally think that Coolify having environments is a good thing, even if you don't use them. So this category is going to be a win for Calify. Okay, so the next category I want to compare is the user interface and user experience of each platform. This is a really subjective category, so it's going to come down to what your own personal preferences and tolerances are.

15:46 In my case, however, I personally find Docky a lot easier to navigate, which is one of the main reasons I decided to go with it. Because Docy uses Nex.js, then I find that it has more of a single page application feel, which personally I think just makes it feel a little more responsive. Although again that's going to be really subjective. In addition to this however I find that docloy has a much more consistent user interface design which again for me feels intuitive.

16:10 Whereas when it comes to Coolify some of the UI design decisions tend to be a little bit more obscure. When it came to Coolify for example, one such gripe I consistently ran into was when it came to saving changes which just felt rather inconsistent across the entire platform. For starters, if there was a save button, it was often located by a section header, which for some reason I just couldn't get used to.

16:34 Additionally, some fields would automatically save, while others required the save button to be manually pressed. In the most egregious of cases, uh, clicking the save button performed a validation on other fields that weren't located in the same section, which to me was incredibly frustrating to be able to solve. Whilst there is a toast notification that appears letting you know when a change has been saved, in my opinion, it ended up becoming more distracting than informative and didn't really solve the issues I had

17:00 when it came to the inconsistent behavior. A doc ploy, on the other hand, is and was a much more consistent experience when it came to modifying values with the save button for fields being in a more intuitive location at the bottom of a section and thanks to making good use of contrast was also much more visible. Not only this, but the save button accounts for any of the changes that you make in a section rather than affecting some of the fields on a form.

17:24 Another source of frustration I kept running into on Calify was anytime that there was a password field on a page. If so, every time that I navigated away from that page, my browser would prompt me to save that password, which got really old really fast. In addition to the password pop-up, another issue that I kept running into when it came to the Cortify UI was its pop-up banner asking you to consider supporting the project.

17:48 Whilst supporting open source is a really good thing and should be encouraged, for me, this pop-up banner became a sort of nemesis as it not only popped up every time I performed a page navigation, but would also block any interaction with the bottom half of the page whenever it was showing. Now, to be fair, resolving this was easily achieved by just dismissing the pop-up, although this only resolves it temporarily as it will again be shown to you a month later.

18:15 Therefore, in order to fully turn this off, you have to do so inside of the Callify settings. Whilst this banner isn't the biggest issue in the world, for me, it just compounded with all of the other UI issues that I had, which I just didn't when it came to using Doc Ploy. Ultimately, for me, I just find that Doc Ploy has a much better UI UX overall.

18:34 And whilst function is more important than form, I do think that software should be intuitive to use. Therefore, when it comes to UIUX, Docloy, in my opinion, is the winner here by a considerable amount. Next up, let's compare the main reason why you would want to use either of these platforms in the first place. Application deployment and configuration.

18:53 Both Docloy and Qualify are what I would consider to be fantastic in this category and have many similarities, although there are a couple of minor differences to consider. They each have not only the ability to deploy your own applications, but they also provide a good number of templates you can deploy as well, consisting of many popular services.

19:11 This is great for beginners who just want to deploy something without needing to know how to configure it from scratch. Personally, I again really prefer the UI here when it comes to doc ploy. However, they are both similar in functionality when it comes to deploying an application template. Additionally, both platforms also have a dedicated database deployment service, which I'll talk more about in its own category.

19:33 As for deploying one's own applications, both Coolify and Docky allow you to deploy from either a Git repository, a Docker image, or even a Docker Compose. Additionally, whilst they both allow you to deploy from a GitHub repository, Docky also provides support for other git providers such as GitLab and Bitbucket, which is one of the two major differences between the two platforms.

19:56 The other one is that whilst both platforms support the ability to build a project without needing to define a docker file, both of them supporting Nyx packs, Docfoy also supports a number of other build types such as Railpack, Heroku build packs and pakito build packs. Apart from these main differences, when it comes to everything else, both docloy and codify are incredibly similar.

20:15 Specifically, when it comes to configuration, allowing you to select which server you want to deploy on, either your local one or if you've managed to set up a multiple server setup, a remote one, and also being able to configure other things such as start command, environment variables, etc., etc., with the major differences between the two just being user interface.

20:34 One last thing to mention, however, is that Docky also allows you to deploy through an AI assistant, meaning you can hook it up to an LLM in order to generate and set up your deployment. Whilst I haven't used this in a production setting yet, I do think it's a pretty cool and well-implemented feature. If you happen to be more agreeable to the idea of vibe cisadmining your infrastructure, then I think that this could be a useful feature.

20:57 Overall, when it comes to service and application deployment, I do think that Docky is ever so slightly ahead due to the fact that it supports more Git providers and more build options. However, in all honesty, I think it's very very close. Of course, if you're using something other than GitHub or prefer to use a different builder instead of Nyx packs or Docker, then Docky wins hands down.

21:16 For my own personal use case, however, both platforms meet all my needs. So, therefore, I'm going to go ahead and make this a tie and give one point to each. Okay, for this next category, as I mentioned before, both platforms provide the ability to deploy a dedicated database service, which has some specific productionready database features compared to other types of services you can deploy.

21:37 Perhaps the most important of these features is that both platforms provide the ability to configure schedule backups for your data to an S3 compatible store. This is a really important feature to have when it comes to a production database. So, it's great to see that both platforms easily support it. In addition to backups, each platform also allows you to configure the database image, although there is a difference in functionality between the two platforms.

22:00 Coolifier will only let you select a tag from the base Docker image, whereas dock ploy will allow you to select from a different image entirely. Now, there are pros and cons to each approach. But personally, I think docklos is better suited to my own personal needs as it means I can use my own Postgres image with specific extensions enabled if I need to.

22:19 Whereas with Koolifi, I would have to deploy a new service entirely from scratch. In addition to this, another key difference between the two platforms is the number of database services that they support. Whilst both of them support the most popular ones which are Postgres, MySQL, Reddus, Maria DB and MongoDB, Kruify also supports three more including Dragonfly DB, KDB, and ClickHouse.

22:44 Although you can of course still deploy these manually through dock ploy and in fact dragonfly DB is available as a template. Additionally, because docy supports volume backups, which qualify does not, then it means you're still able to have a production ready experience with these databases. Because of this, then the database category is yet another tie, meaning that both qualify and doclo get one point each.

23:04 In my own personal case, because I use Neon when it comes to Postgres, then I don't actually use my platform as a service when it comes to deploying a database. But even so, it's still really awesome that both of these platforms make it easy to deploy one with scheduled backups enabled. Okay, now that we've gone through a lot of the main considerations that I had with each platform, let's quickly go through some of the other features that each one provides, looking at any similarities as well as some key differences

23:29 before then defining which platform is going to be best for certain use cases. To begin, let's cover review apps, aka preview deployments, which is the main reason I decided to move away from my original Docker Stack implementation in the first place. Both platforms have support for simple preview deployments, allowing you to deploy a review version of your application whenever a pull request is made to your configured branch.

23:52 This allows you to effectively review the changes that the pull request will make in a dedicated environment before merging those changes in. Both platforms allow you to configure preview deployments with their own environment variables. Cordify automatically populates these from your existing ones, whereas Docky requires you to redefine them, and there are pros and cons to each approach.

24:14 Whilst this is great, I do wish there was a way to dynamically set environment variables for each preview app deployment, which in my opinion would give a little more versatility to the feature. Now, each of these platforms do provide an API to update the environment variables of all the preview deployments. uh but they don't work for each individual deployment itself.

24:33 Additionally, it would also be rather useful to be able to manually trigger a review app from an API or web hook. Whereas currently, you can only really deploy these either automatically or by manually pressing a deploy button through the UI. By having the ability to trigger a deployment through the API or through a web hook, it would allow one to effectively perform other tasks before kicking off the review apps deployment.

24:55 Uh such as being able to create a new database branch in Neon, for example. When it comes to docloy, there is an open issue for this. Uh but unfortunately, it's not yet implemented. Fortunately, when it comes to my own setup, I've managed to get preview deployments working in a way that I'm really happy with. integrating both Neon and Doc Ploy so that I can have a new branch on my production data whenever I kick off a review.

25:17 This is done manually using the API to create a deployment rather than using the built-in feature. If you're interested in how I do this, then let me know in the comments down below and I'll draft up a future video. Whilst we're on the subject of APIs, both platforms provide one as well as a CLI which you can use to automate various different tasks.

25:38 Whilst I haven't used the callify API much, it does appear to have pretty much the same functionality as the doc ploy one which you can do quite a lot with. However, when comparing the readmes of the two CLIs together, it does appear that the qualify one doesn't support all of the API operations, whereas the docloy one does. As I mentioned, I've managed to set up my own CI/CD pipeline using the API for docloy so that I can perform some additional tasks before creating a review app and it's working pretty well.

26:05 Another feature that both Cordify and Docky have is support for notifications which can be configured for a number of different events in each platform such as deployments, metrics, backups, and even scheduled events. Both platforms support configuring notifications to be sent to Slack, Telegram, Discord, and email through SMTP. Qualify does have an additional email configuration through its resend integration, which personally I really like, especially as I now use resend as my main transactional email provider.

26:35 The key difference when it comes to notification between the two platforms is that Coolify supports the pushover service whereas dopy supports goify. Pushover is a service that allows you to get real-time push notifications on any of your supported devices such as iOS, Android, and even desktop computers. Although it does cost a onetime fee for each device that you set up.

26:53 Goify on the other hand is more for automation. So think of an open- source AWS SQS. The nice thing about Goify is that you can hook it into other platforms using something like N8N, which means you can easily add in support for pushover if you want to. Personally, I again think this gives a slight edge to do ploy as you can use Goify to basically build automations around any of the notifications that it may send out.

27:16 Uh but for the most part, this is pretty similar between the two. Another feature that both Cordify and Docky support is multi-erver setups and clustering. This allows you to set up remote servers for deploying applications so that you don't take up resources on the same machine that you're running your platform on and is really recommended when it comes to a production setup.

27:36 Qualified takes this a step further as it allows you to specify a remote server as a dedicated build server. This helps to keep the load on your hosting server low and ensures that your application's performance remains unaffected by the build process. In my opinion, this is a really nice feature and one that I wish Docklo supported. There is an issue open to add this into Docky, so maybe one day soon we'll see it come about.

27:58 For my own needs, however, I tend to build most of my applications in CI/CD, but I'd still love to see this remote build option become available for doc ploy. Setting up a remote machine is done over SSH, which as I mentioned before, I like to keep secure using tailscale uh rather than connecting over the public internet. Fortunately, both docloy and qualify work well when it comes to this configuration.

28:20 However, in order for it to work, I found that you need to either use the machine's Tailscale IP address or the fully qualified domain name provided by Tailscale, both of which can be found in the admin dashboard. In addition to remote servers, both platforms also support clustering through the use of Docker Swarm, although Coolifi does currently mark this as an experimental feature, so your mileage may vary.

28:42 Another useful feature that both platforms support is scheduled tasks. This is where you can define a chron task inside of either a service or a resource to run periodically either inside of a container or an image. Docklo does take this a step further and allow you to run a schedule on the machine itself which you can provide a bash script to. However, most of the time you're likely going to use these on the actual containers themselves.

29:05 Either way, this is really useful when it comes to a deployment service as you can do things such as backing up data or periodically running tasks whenever you need to. The next feature I want to talk more about is monitoring and metrics. Both platforms provide metrics for both servers and services/resources. However, one key difference is that Docky does this out of the box, whereas with Coolify, it requires this to be manually enabled.

29:29 One advantage that Docky has over Coolify is that you can use these metrics with the built-in notification system. Basically allowing you to publish them to Godify. This means you can effectively perform automation in response to certain usage events, such as when a server's CPU or memory load crosses a certain threshold, which is really cool, but also necessary for a production ready system, especially if you want to set up anything such as autocaling.

29:53 As I mentioned, monitoring and metrics in Cify do require this to be manually enabled. And upon doing so, I did notice an increase in my server CPU usage, sometimes spiking up to 25%. Uh, which was a bit of a concern. Additionally, the metrics provided by Sentinel, which is Cordifi's home solution, didn't include any disk usage, or at least I couldn't see where this was.

30:15 Although, I did manage to find a way to send disk usage alerts as notifications. However, given that these aren't able to be integrated into a system such as Godify, then I'm not too sure how easy it would be to be able to perform any autoscaling in response to these events. Now, to be fair to Coolify, metrics are still an experimental feature at the time of recording.

30:35 So hopefully we'll see some improvements to these in the near future. Another feature that Doglo has, which I couldn't confirm if Coolify does, is volume backups, which allow you to effectively back up container volumes to an S3 compatible store. This is very similar to database backups that we saw already but works for generic docker volumes which again is really important when it comes to a production ready workflow.

30:58 The last feature that I find to be really useful in my own workflow is the ability to configure traffic which is what both platforms use as the default ingress service. This allows you to perform advanced configuration when it comes to routing network traffic to your services including things such as rate limiting authentication redirects load balancing etc etc.

31:16 When it comes to dock ploy, these configurations are found underneath the advanced tab of a service, which allows you to modify common actions through the UI or make advanced changes directly to the traffic configuration. Cify also provides the ability to configure traffic and set up advanced routing, but initially I found it a little challenging to find where this was.

31:38 After reading the documentation, I found that like docloy this is located in two different places. The main traffic configuration is found under the proxy menu of a service configuration which is just a YAML file that you can edit uh similar to the main traffic configuration in doc ploy. As for specific application configurations, these are found at the bottom of the settings of a resource where you can set port forwarding HTTP basic and also make edits to a resource container labels which allows you to perform

32:08 advanced traffic configuration. Personally, I actually prefer the container labels approach that Coolify takes. Uh, but again, the UI and inconsistent saving ended up tripping me up, which as you may be able to tell was a common occurrence when it came to Coolify and why I just generally preferred Doc Ploy. That being said, however, I think there are still two main reasons why someone like myself would actually prefer to use Calify instead.

32:35 The first of which is that there is one feature that Coolify provides out of the box that Docloy does not. This is support for Cloudflare tunnels which allows you to deploy both Coolify and the load balancer/ ingress without exposing your machine to the internet. This is most useful for homelab setups where you can expose your services without needing to forward ports which is a great thing to have from a security point of view.

32:58 Now to be fair, you can still set up docloy to work over a Cloudflare tunnel. In fact, there's even a Cloudflare D template available in Doc Ploy. However, given that these platforms are meant to abstract away the need to worry about managing infra, then I do think that Qualify here has the edge in providing it as a baitin feature, especially if you're looking to deploy this on your own home lab.

33:21 In my own use case, because I'm deploying on a VPS and because I prefer to use Cloudflare proxy when doing so, then I don't need this feature. So it didn't weigh into my final determination, although it would be nice to have. The second and perhaps most major reason as to why one would want to choose Coolify over Docky is due to open- source licensing.

33:41 Coolify is considered fully open-source being under the Apache 2 license which makes it incredibly permissive. Docloy on the other hand is a little bit more complicated. Whilst the core of dock ploy is considered open- source also being under the Apache v2 license there is some code that is exempt from this. This is the code for compos templates multiode support schedules preview deployments and multi-server features of which cannot be sold or offered as a service without consent from the original authors.

34:14 Unfortunately this means that dock ploy isn't fully considered open source. Instead, you could consider it more to be source available, which I do think is a massive shame. Personally, I'd love to see these features come under something like the AGPL V3, which would both help to protect the author's IP whilst also preventing any ambiguity from self-hosting.

34:36 For some people, I imagine this will be the biggest reason to prefer Coolify over Doc Ploy. And for me, it's a bit of a tough pill to swallow. However, given that I think Doc Ploy has a better production experience for my own personal needs, then it's a compromise that I'm willing to make, even if I don't personally love it. With that, we can now take a look at our final score.

34:55 Doc Ploy gets an additional plus one when it comes to the feature set category, as in my opinion, it just wins out with a couple of production ready features. Coolify, on the other hand, wins the license category, bringing it up to another plus one. This brings the total score to four points for qualify and six points for Doc Ploy, which is pretty close.

35:16 But for myself, this makes Doc ploy the winner. As I mentioned before, this ultimately comes down to my own personal preference and needs. And for others, this score may look slightly different, especially if you consider features such as Cloudflare Tunnels, which some people may prefer over the other features that do ploy provides. At the end of the day, however, the biggest thing for me was the user interface, which I personally feel is the main thing that holds Coolify back, which is a shame because it's a fantastic

35:45 piece of software. In any case, that wraps up the overview of each platform. And whilst each of them does have their own strengths and weaknesses, at the end of the day, both are absolutely fantastic. And really, the choice for me came down to my own personal preference. Of course, this is just a moment in time. And in the future, we'll either see hopefully improvements to Coolify's UIUX, which the developers did address in the release of V4, or we might even see some licensing improvements come to Doc Ploy, or perhaps

36:14 one day I may even take a shot at rolling my own version instead. In any case, I hope you found this video useful for making your own decisions on which platform is going to be right for you. And of course, once you've done so, you can go ahead and deploy your platform of choice on a VPS provided by today's sponsor, Hostinger. Make sure to use my link found in the description down below, and also use my coupon code, dreams of code, to get an additional 10% off.

36:40 A big thank you to Hostinger for sponsoring this video, and a huge thank you to you for watching. I'll see you on the next one.