Dokku on VPS: installation, setup, and maintenance

Dokku on a VPS allows you to transform your virtual server into a powerful PaaS platform, simplifying application deployment and management using Docker containers, automated Git deployment, and environment configuration. This tool offers an elegant alternative to large cloud PaaS solutions like Heroku, enabling developers to maintain full control over their infrastructure, optimize costs, and deploy applications in literally minutes. Installing Dokku on a VPS from Valebyte.com opens up possibilities for creating a flexible and scalable environment for your projects, whether they are web applications, APIs, or microservices, with minimal overhead and a high degree of automation. It is ideal for those seeking a balance between ease of use and full server control, leveraging the benefits of what a VPS is.

What is Dokku and why is it ideal for deployment on a VPS?

Dokku is an open-source Platform as a Service (PaaS) that allows you to deploy and manage applications on your own server using Docker containers. Essentially, it's "your own Heroku," but with full control over the infrastructure and without high monthly bills for every little thing. When people talk about Dokku VPS, they mean precisely this combination: a Virtual Private Server with Dokku installed, transforming it into a personal PaaS environment.

Dokku as a mini-PaaS: key advantages

The main advantage of Dokku lies in its simplicity and efficiency. It allows developers to focus on code rather than server administration. Here are the key features that make Dokku appealing:

• Git-centric deployment: You simply do a git push to a repository on your VPS, and Dokku automatically builds your application (using Buildpacks or a Dockerfile) and deploys it in a Docker container. This significantly speeds up the CI/CD process for small teams and individual developers.
• Docker usage: Each application is isolated in its own Docker container, ensuring stability, portability, and easy dependency management. This also means Dokku efficiently uses your server's resources, as Docker is much lighter than full-fledged virtual machines. You can learn more about the differences in the article Containers vs. VMs vs. Bare-metal.
• Plugins for services: Dokku has an extensive ecosystem of plugins that allow you to easily add databases (PostgreSQL, MySQL, Redis, MongoDB), message queues, and other services to your applications. These services also run in Docker containers and are easily linked to your application.
• Automatic HTTPS: Integration with Let's Encrypt allows you to easily set up free SSL certificates for your applications, ensuring a secure connection.
• Low resource footprint: Dokku itself is quite lightweight and does not require significant resources, making it ideal for deployment on budget or mid-range VPS instances.
• Full control: Unlike commercial PaaS where you are limited by the platform's capabilities, Dokku gives you full access to the server. You can configure anything, install any software, and have complete control over your data. This is especially important for those who prefer self-managed VPS.

Comparing Dokku with large PaaS and manual deployment

To understand Dokku's value, it's helpful to compare it with other approaches:

Dokku vs. Heroku/Netlify/Vercel:

• Cost: Dokku is significantly cheaper. You only pay for your VPS (e.g., from $5-10 per month), whereas Heroku can quickly become expensive as your application grows and services are added. For example, migrating from Heroku Postgres to your own Managed-PG on a VPS can save significant money, as we wrote in the article How to migrate from Heroku Postgres to managed-PG on a VPS.
• Control: Dokku gives you full control over the server and environment. In commercial PaaS, you are limited by their ecosystem.
• Complexity: Heroku is simpler to start with, but Dokku is also very straightforward after initial setup. Dokku requires a basic understanding of Linux and Docker.
• Scaling: Heroku offers seamless horizontal scaling. Dokku requires manual scaling (e.g., spinning up a new VPS and configuring Dokku for a new application) or using more complex orchestration tools like Kubernetes if you go beyond a single server.

Dokku vs. manual deployment on a VPS:

• Automation: Dokku automates most routine tasks: dependency installation, building, container creation, Nginx/Caddy configuration, SSL. With manual deployment, all of this must be done manually or by writing your own scripts.
• Isolation: Dokku uses Docker for application isolation, which is safer and more reliable than running everything on a single server without containerization.
• Maintenance: Dokku maintenance (updates, backups) is standardized. With manual deployment, each project can have its own peculiarities.
• Deployment time: With Dokku, deploying a new application takes minutes. Manual deployment can take hours.

Thus, Dokku strikes a golden mean, offering the convenience of PaaS with the flexibility and cost-effectiveness of your own server. It's an excellent choice for developers, startups, and small teams who need an efficient platform for deploying applications without excessive complexity or high costs.

System requirements for Dokku on a server: which VPS to choose?

Choosing the right VPS for Dokku installation is a crucial step that will determine the performance and stability of your applications. While Dokku itself is quite lightweight, your applications and their services will consume the primary resources. When choosing a Dokku VPS, it's important to consider not only current needs but also potential growth.

Minimum and recommended configurations

For a successful launch of Dokku and one or two small applications (e.g., a simple Node.js API and PostgreSQL), the following minimum characteristics are required:

• Operating System: Ubuntu 20.04/22.04 LTS, Debian 11/12, or CentOS 7/8. Ubuntu LTS is usually the most recommended choice due to broad support and up-to-date packages.
• RAM (Random Access Memory): Minimum 1 GB. This will be enough for Dokku, Docker, and one or two very light applications without significant load. However, if you plan to run a database or more resource-intensive applications, this will not be sufficient.
• CPU (Processor): 1 vCPU. A modern processor (e.g., Intel Xeon E3/E5 or AMD EPYC) with a clock speed of 2.0 GHz or higher.
• Disk: Minimum 20 GB SSD. SSD is critical for Docker and database performance. NVMe will be even better.
• Swap (Swap file): It is recommended to configure a Swap file of 1-2 GB, especially with 1-2 GB RAM, to avoid OOM errors during application builds or peak loads.

Recommended configurations for multiple applications or moderate load:

• RAM: 2-4 GB. This will comfortably accommodate several applications, one or two databases (PostgreSQL, Redis), and ensure stable operation.
• CPU: 2 vCPU. This will provide better performance for building applications, processing requests, and running background tasks.
• Disk: 40-80 GB NVMe SSD. A fast disk will significantly improve application response times, especially for those that actively work with a database.
• Swap: 2-4 GB.

For high-load applications or a large number of services:

• RAM: 8 GB and more.
• CPU: 4 vCPU and more.
• Disk: 100 GB+ NVMe SSD.

The importance of SSD/NVMe and a stable connection

The choice of disk subsystem is of paramount importance for the performance of a Dokku self-hosted environment:

• SSD/NVMe: Traditional HDDs are highly discouraged for Dokku. Docker actively works with the disk when building images, running containers, and logging. Databases such as PostgreSQL or MySQL are also very sensitive to disk speed. Using SSD, and even better NVMe, will significantly reduce deployment time, speed up applications and databases, and improve overall system responsiveness.
• Stable network connection: Your VPS will require a stable and high-speed internet connection. This is necessary for fast downloading of Docker images, Git pushes during deployment, and to ensure low latency for your application users. Look for providers offering 1 Gbit/s or 10 Gbit/s ports, even if the actual throughput will be lower.
• Server location: Choose a data center located closer to your target audience to minimize latency.

Valebyte.com offers various VPS plans with NVMe disks that are ideally suited for Dokku, providing high performance and reliability. For example, for small projects, a plan with 2GB RAM / 2vCPU / 40GB NVMe will be suitable, and for more serious tasks — 4GB RAM / 4vCPU / 80GB NVMe and higher.

Step-by-step Dokku installation on a VPS: preparation and initialization

The process of installing Dokku on your VPS involves several key stages: server preparation, installing Docker (on which Dokku runs) and Dokku itself, and then its initial configuration. This section will guide you through each step.

Server preparation: OS, updates, SSH key

Before proceeding with Dokku installation, you need to ensure your VPS is ready.

1. Operating System selection: Make sure your VPS has a supported operating system installed. Ubuntu 22.04 LTS is recommended.
2. System update: Connect to your VPS via SSH (typically using the command ssh root@your_server_ip or a user with sudo privileges) and update all packages to the latest versions.

sudo apt update
sudo apt upgrade -y
sudo apt autoremove -y

3. SSH key setup: For secure and convenient application deployment with Dokku, using SSH keys is critical. Ensure your public SSH key is added to the server. If you haven't generated keys yet, do so on your local machine:

   ssh-keygen -t rsa -b 4096 -C "[email protected]"

   Then copy the public key to the server:

   ssh-copy-id root@your_server_ip

   Or manually add the contents of the ~/.ssh/id_rsa.pub file to the ~/.ssh/authorized_keys file on the server.
4. Hostname configuration: Set a proper hostname for your server. This is not strictly mandatory but good practice.

   sudo hostnamectl set-hostname your-dokku-server.com

   Ensure this hostname resolves to your server's IP via DNS.

Installing Docker and Dokku: commands and verification

Dokku runs on top of Docker, so you need to install Docker first. If your VPS from Valebyte.com comes with a pre-configured Ubuntu image, Docker might already be installed, but it's best to check.

Installing Docker (if not installed):

sudo apt install -y apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io

Verify Docker installation:

sudo docker run hello-world

If you see a welcome message, Docker is installed correctly.

Installing Dokku:

Dokku provides a convenient script for installation. Execute the following commands:

wget https://dokku.com/install/docker.sh
sudo DOKKU_TAG=v0.32.7 bash docker.sh

Replace v0.32.7 with the current Dokku version, which can be found on the official Dokku website. The script will install all necessary components, including Dokku and its dependencies. The process may take several minutes.

Initial Dokku setup via web interface

After the Dokku installation is complete, you need to perform the initial setup through the web interface. Open a web browser and navigate to your server's address:

http://your_server_ip

You will see the Dokku welcome page. Here you will need to complete a few steps:

1. Public Key: Paste your public SSH key. This is the same key you used to access the server. Dokku will use it for authentication during Git pushes.
2. Hostname: Enter the domain name you plan to use for your applications (e.g., your-dokku-server.com). If you don't have one, you can leave the IP address, but for convenience and HTTPS, a domain name is preferable.
3. Use Virtual Hostnames: Be sure to check this option. It allows Dokku to automatically route requests to your applications based on their domain names (e.g., my-app.your-dokku-server.com).

Click "Finish Setup". Now your Dokku on the server is ready to receive its first applications.

Deploying your first application with Dokku: Git push and plugins

After successful Dokku installation and initial setup, you are ready to deploy your first application. The deployment process with Dokku is surprisingly simple and resembles working with Heroku: you simply "push" your code to a Git repository on the Dokku server.

Adding an SSH key and creating an application

Ensure that the public SSH key you use to access the server (and which you added in the Dokku web interface) is also added to your local SSH agent. This will allow you to interact with Dokku via Git without issues.

Creating an application on Dokku:

On your local machine, in the root directory of your project, first initialize a Git repository (if you haven't already):

git init

Then add Dokku as a remote Git repository. Replace my-app with your desired application name and your-dokku-server.com with your server's IP or domain:

git remote add dokku [email protected]:my-app

This command not only adds the remote repository but also tells Dokku to create a new application named my-app.

Deploying an application: example with Node.js/Python

Now you can deploy your application. Dokku automatically detects your application type based on Buildpacks (e.g., package.json for Node.js, requirements.txt for Python, Gemfile for Ruby) or uses a Dockerfile if present in the project root.

Example of Node.js application deployment:

Ensure your package.json contains a start script (e.g., "start": "node server.js") and that all dependencies are listed.

git add .
git commit -m "Initial deploy"
git push dokku master

Dokku will begin the build process:

1. Clones your code.
2. Detects the Buildpack (in this case, Node.js).
3. Installs dependencies (npm install or yarn install).
4. Compiles the application (if necessary).
5. Creates a Docker image.
6. Launches a container with your application, using the start script.
7. Configures Nginx/Caddy to proxy requests to your application.

After a successful deployment, Dokku will output your application's URL, usually in the format http://my-app.your-dokku-server.com.

Example of Python application deployment (Flask/Django):

Ensure you have a requirements.txt with all dependencies and a Procfile specifying how to run your application. For example, for Flask:

web: gunicorn app:app

Or for Django:

web: gunicorn your_project.wsgi --log-file -

Then:

git add .
git commit -m "Initial deploy"
git push dokku master

The process will be similar to Node.js, but with the Python Buildpack.

Plugin management: database (PostgreSQL, Redis) and other services

Most applications require a database or other external services. Dokku simplifies their installation and linking to your application through its plugin system. For Dokku Docker, this means running additional containers with services.

List of available plugins:

dokku plugin:list

Installing the PostgreSQL plugin:

dokku plugin:install https://github.com/dokku/dokku-postgres.git postgres

Creating a PostgreSQL service for your application:

dokku postgres:create my-app-db

Linking the service to the application:

dokku postgres:link my-app-db my-app

This command will create an environment variable (e.g., DATABASE_URL) in your my-app application, containing the connection string to the my-app-db database. Your application can then use this variable to connect to the database.

Example for Redis:

dokku plugin:install https://github.com/dokku/dokku-redis.git redis
dokku redis:create my-app-redis
dokku redis:link my-app-redis my-app

After linking services, you may need to redeploy the application for it to recognize the new environment variables:

dokku ps:rebuild my-app

Or simply make a new git push.

Dokku significantly simplifies infrastructure management, allowing you to focus on development rather than configuring databases and other services. This makes the Dokku self-hosted solution a powerful tool for productive work.

Configuring Reverse Proxy and HTTPS for Dokku applications

For any web application, availability via a domain name and a secure HTTPS connection are critically important. Dokku automates these processes, using Nginx (by default) or Caddy as a reverse proxy and integrating with Let's Encrypt for free SSL certificates.

Automatic HTTPS with Let's Encrypt

Dokku has excellent integration with Let's Encrypt, making it easy to obtain and configure SSL certificates for your applications. This is a key feature for any Dokku VPS deployment.

1. Install the Let's Encrypt plugin: First, you need to install the Dokku Let's Encrypt plugin.

   dokku plugin:install https://github.com/dokku/dokku-letsencrypt.git

2. Add a domain to the application: Before requesting a certificate, ensure your application is associated with a domain name. Let's say your application is called my-app, and you want it to be accessible at my-app.example.com. You need to configure an A-record in your example.com domain's DNS, pointing to your Dokku server's IP address. Then add this domain to your Dokku application:

   dokku domains:add my-app my-app.example.com

3. Request an SSL certificate: Now you can request a Let's Encrypt certificate for your application:

   dokku letsencrypt:enable my-app

   Dokku will automatically request and install the certificate. If successful, your application will be accessible at https://my-app.example.com. Dokku will also configure automatic certificate renewal.
4. Specify an email for notifications: It is recommended to specify an email for notifications from Let's Encrypt (e.g., about renewal issues):

   dokku letsencrypt:set my-app contact_email [email protected]

If you use the server's primary domain (e.g., your-dokku-server.com) for all applications (my-app.your-dokku-server.com), it is sufficient to add an A-record for the primary domain and a Wildcard CNAME record *.your-dokku-server.com pointing to the primary domain, or individual A-records for each subdomain. Then request a certificate for each application.

Custom domains and proxying

Dokku uses Nginx or Caddy (depending on configuration) to route incoming requests to the correct application container. This is the role of the reverse proxy.

Managing application domains:

• Adding a domain:

  dokku domains:add my-app custom.my-domain.com

  Don't forget to configure the DNS A-record for custom.my-domain.com to your Dokku server's IP.
• Removing a domain:

  dokku domains:remove my-app custom.my-domain.com

• Viewing domains:

  dokku domains:report my-app

Nginx/Caddy configuration:

By default, Dokku uses Nginx. If you want to use Caddy (which can be simpler to configure HTTPS), you can install the corresponding plugin:

dokku plugin:install https://github.com/dokku/dokku-caddy.git

After installing the Caddy plugin, Dokku will use it instead of Nginx for new applications. For existing applications, a switch or recreation might be required. Caddy automatically handles HTTPS for domains you add to applications.

Advanced Nginx/Caddy configuration:

In some cases, you may need to add custom directives to your Nginx or Caddy configuration. Dokku allows this by creating configuration files in specific directories:

• For Nginx: Create a file /home/dokku/my-app/nginx.conf.d/custom.conf on your VPS. Any directives added to this file will be included in the Nginx configuration for my-app. For example, to increase the upload file size limit:

  client_max_body_size 100M;

  After modifying the file, you need to rebuild the Nginx configuration:

  dokku nginx:build-config my-app

• For Caddy: Similarly, you can add custom Caddyfile directives to /home/dokku/my-app/Caddyfile.d/custom.conf.

Using these features, you can easily configure access to your applications via custom domains with a secure HTTPS connection, which is standard for any modern web application deployed on Dokku on a server.

Dokku Maintenance: Backups, Updates, and Monitoring

Regular maintenance is critically important for any production system, and a Dokku self-hosted environment is no exception. A proper backup strategy, timely updates, and effective monitoring will ensure the stability, security, and reliability of your applications.

Data and configuration backup strategies

Data loss can be catastrophic. Therefore, developing a reliable backup strategy is priority number one.

1. Application data backups (databases):

Dokku plugins for databases (PostgreSQL, MySQL, Redis) typically provide commands for creating and restoring backups. For example, for PostgreSQL:

# Create a backup
dokku postgres:export my-app-db > my-app-db-backup.sql

# Restore a backup (be careful, this will overwrite existing data!)
cat my-app-db-backup.sql | dokku postgres:import my-app-db

It is recommended to automate this process using cron jobs. For example, for a daily PostgreSQL backup:

# Add to crontab -e
0 3 * * * dokku postgres:export my-app-db > /home/dokku/backups/my-app-db-$(date +\%Y\%m\%d\%H\%M\%S).sql

Ensure that the /home/dokku/backups/ directory exists and has sufficient permissions.

2. Dokku configuration backup:

All Dokku configuration is stored in the /home/dokku directory on your server. You can make a full backup of this directory:

sudo tar -czvf /root/dokku-config-backup-$(date +\%Y\%m\%d\%H\%M\%S).tar.gz /home/dokku

This includes application settings, environment variables, SSH keys, plugin data, etc. In case of complete server loss, having this archive and database backups will allow you to restore your Dokku environment on a new VPS.

3. Off-site backup storage:

It is critically important to store backups not on the same server as the original data. Use external storage such as S3-compatible cloud storage, FTP servers, or other VPS instances (for example, an email hosting server might have additional space). You can use rsync, scp, or specialized tools for automatic backup uploads.

4. File system backups (if applicable):

If your application stores user files on disk (rather than in S3 or another cloud storage), make sure you also back up these directories. You can use the Dokku dokku-storage plugin for this.

Updating Dokku and Docker

Regular updates to Dokku and Docker are important for receiving new features, bug fixes, and security patches.

Updating Dokku:

Before updating Dokku, ensure you have a fresh backup. Then execute the following commands:

sudo apt update
sudo apt upgrade -y dokku

If you want to update to a specific version, use:

sudo DOKKU_TAG=v0.32.7 apt-get install dokku -y

Always check the official Dokku documentation before major updates for breaking changes.

Updating Docker:

Docker should also be updated regularly. Since Dokku depends on Docker, Docker updates may sometimes require restarting the Dokku service or even the entire server. Docker updates typically occur through the standard package manager:

sudo apt update
sudo apt upgrade -y docker-ce docker-ce-cli containerd.io

After updating Docker, you may need to restart Dokku containers:

dokku ps:rebuildall

Monitoring VPS and application resources

Monitoring allows you to track the performance of your Dokku on the server and respond promptly to issues.

• Basic VPS monitoring: Use standard Linux utilities:
  • htop or top: to view CPU, RAM, Swap usage, and processes.
  • df -h: to check free disk space.
  • free -h: for detailed RAM and Swap information.
  • docker stats: to view resource usage by individual Docker containers.
• Application log monitoring: Dokku collects your application logs. You can view them using:

  dokku logs my-app
  dokku logs my-app -t # to view logs in real-time

• Advanced monitoring: For more serious production environments, consider using external monitoring systems such as Prometheus/Grafana, Datadog, New Relic, or Zabbix. These systems can collect metrics from your VPS and Docker containers, alert you to problems, and provide historical data for analysis.

By regularly checking these metrics, you can identify bottlenecks in time, prevent overloads, and ensure the smooth operation of your applications on Dokku.

Choosing a VPS configuration for Dokku under real load: tables and recommendations

Determining the optimal VPS configuration for Dokku is a balance between cost, performance, and scalability. Since a Dokku VPS can be used for a wide variety of projects, from small personal websites to high-load APIs, it is important to correctly assess your application's needs.

Assessing needs: number of applications, traffic, resources

When choosing a VPS, consider the following factors:

1. Number and type of applications:
   • Static sites/very light APIs (1-2 units): If you host a few static sites or microservices that rarely receive requests, resource requirements will be minimal.
   • Dynamic web applications (1-3 units): Applications on Node.js, Python/Django/Flask, Ruby/Rails, PHP (Laravel/Symfony) with a single database require more RAM and CPU.
   • High-load APIs/services (1 unit): If you have one, but very active application, it may require significant CPU and RAM resources.
   • Many applications/microservices (3+ units): Each application and its services (databases, cache) consume resources. The more there are, the more powerful the VPS should be.
2. Expected traffic and number of users:
   • Low traffic (up to 1000 unique visitors per day): Minimal requirements.
   • Medium traffic (1000-10000 visitors per day): More CPU and RAM will be needed to handle concurrent requests.
   • High traffic (10000+ visitors per day): May require scaling beyond a single Dokku server or migrating to a dedicated server.
3. Database type and size:
   • Small DB (up to 1 GB): PostgreSQL/MySQL, Redis for cache — can run on a VPS with 2-4 GB RAM.
   • Medium DB (1-10 GB): Requires 4-8 GB RAM and a fast NVMe disk.
   • Large DB (10+ GB): May be worth considering a dedicated database server or a Managed Database Service.
4. Use of background tasks/workers: If your application actively uses queues (Redis/RabbitMQ) and background workers, this also increases CPU and RAM consumption.
5. Future plans: Always leave a small resource buffer for future growth. Scaling up a VPS (upgrade) is usually possible, but sometimes requires a server reboot.

Table of recommended Valebyte.com VPS plans

Based on the needs outlined above, we offer approximate VPS configurations from Valebyte.com that are well-suited for Dokku self-hosted deployments.

Dokku Use Case	Recommended Valebyte.com VPS Plan	vCPU	RAM (GB)	NVMe Disk (GB)	Approximate Monthly Price ($)
Minimal (1-2 light APIs/sites, no DB or very light DB)	Dokku Starter	1	2	40	$7 - $10
Small Project (2-4 web applications, 1-2 small DBs, moderate traffic)	Dokku Standard	2	4	80	$15 - $25
Medium Project (4-8 applications/microservices, 2-3 medium DBs, medium traffic)	Dokku Pro	4	8	160	$30 - $50
Large Project/High Load (Many applications, large DBs, high traffic)	Dokku Enterprise	6+	16+	320+	$60+

Note: Prices are approximate and subject to change. Current rates and availability can be checked on the Valebyte.com website. All plans include high-speed NVMe disks and a stable network connection.

Scaling and optimization

Even with a correctly chosen VPS, scaling or optimization may be required over time.

Vertical Scaling:

The simplest way to scale a Dokku VPS is to upgrade your current VPS to a more powerful plan (adding CPU, RAM, disk). Most providers, including Valebyte.com, allow this with minimal downtime.

Horizontal Scaling:

Dokku in its basic configuration is not designed for horizontal scaling of a single application across multiple servers. If your application reaches the limits of a single powerful server, consider the following options:

• Application splitting: Divide a monolithic application into several microservices and deploy them on different Dokku servers.
• External databases: Migrate databases to dedicated database servers (e.g., Managed PostgreSQL) or to another VPS to free up resources on the main Dokku server.
• Using a CDN: For static content, use a CDN to reduce the load on your server.
• Migrating to Kubernetes: For truly high-load and distributed systems, it may be necessary to migrate from Dokku to more complex container orchestrators, such as Kubernetes.

Application optimization:

Sometimes the problem is not the VPS, but inefficient code. It's always worth checking:

• Database query optimization: Use indexes, avoid N+1 queries.
• Caching: Implement caching at the application level (Redis, Memcached) and at the HTTP level (CDN, Varnish).
• Efficient resource usage: Optimize code to consume less CPU and RAM.

A smart choice of VPS configuration and a well-thought-out scaling strategy will allow you to effectively develop your projects on Dokku, ensuring stable operation and controlled costs.

Conclusion

Dokku on a VPS is a powerful and cost-effective solution for application deployment that transforms your virtual server into a full-fledged PaaS platform, combining the simplicity of Heroku with full control over the infrastructure. For most developers and startups looking for a balance between flexibility, performance, and cost, Dokku on a VPS with 2-4 GB RAM and an NVMe disk from Valebyte.com will be an optimal choice, allowing them to focus on code rather than the complexities of administration.