Framework deployment guides

Deploying Node.js

Deploy applications built with Node.js.

The platform detects Node.js applications by checking for package.json.

The default Build Command is npm run build. You can replace it in settings with a custom command such as yarn build or pnpm build.

The default Run Command is npm start. You can change it to commands such as node server.js or pm2-runtime start app.js.

Set the desired Node.js version through the NODE_VERSION environment variable, for example 18 or 20.

Your application must listen on the port supplied through the PORT environment variable. Otherwise, it will not be reachable.

Deploying Python

Deploy Python frameworks such as Django and FastAPI.

Python applications are detected automatically using standard dependency files such as requirements.txt, Pipfile or pyproject.toml.

Set PYTHON_VERSION to specify the exact Python version you need, for example 3.11 or 3.12.

In Python, the Build Command commonly collects static files with python manage.py collectstatic —noinput or applies migrations. Configure it in the dashboard.

For Python web applications, configure the Run Command with a standard WSGI/ASGI server, for example gunicorn config.wsgi:application or uvicorn main:app —host 0.0.0.0 —port $PORT.

To protect your code, keep sensitive values such as SECRET_KEY, database connection details and tokens exclusively in the dashboard’s environment variables.

Deploying Laravel

Recommended deployment setup for Laravel projects.

Laravel projects are recognized and processed through composer.json.

During deployment, the system automatically installs and builds backend dependencies with composer install and frontend dependencies with npm install and npm run build.

Add commands such as php artisan optimize or php artisan migrate —force to a custom Build Command to run them during deployment.

Set PHP_VERSION to specify the exact PHP version, for example 8.2 or 8.3.

The public directory becomes the document root. Enter essential environment settings, including APP_KEY and database details, before your first deployment.

Deploying Go

Build and run services written in Golang.

Go services are well suited to the cloud platform because of their speed and low resource usage.

The platform identifies modules and dependencies through go.mod and builds the application with go build by default.

Set GO_VERSION to specify the exact Go version, for example 1.21 or 1.22.

You can customize both the Build Command and Run Command through the dashboard.

The generated binary runs as the main process. Make sure it receives requests on the port provided through the PORT environment variable.

Deploying Ruby

Deploy Ruby on Rails and Sinatra applications.

The platform identifies Ruby applications through Gemfile and automatically installs dependencies with bundle install.

Use RUBY_VERSION to select the Ruby version, for example 3.2 or 3.3.

For Rails applications, the system handles asset compilation. Change the Build Command if necessary to run migrations, for example bundle exec rake db:migrate.

Web applications typically run through Puma or Unicorn, and their Run Command is configurable. Remember to set RAILS_ENV to production.

Deploying Rust

Build fast, safe services with Rust.

Rust projects are detected through Cargo.toml and prepared with cargo build —release.

Set the desired Rust version through RUST_VERSION.

Customize the Build Command to add flags or features, and configure the output binary’s Run Command as needed.

Rust compilation may take time because of release-profile optimizations, but produces a fast, compact binary.

The resulting binary runs in an isolated environment and must be ready to receive HTTP requests on the port supplied through PORT.

Deploying React

Deploy client-side React applications (SPAs).

React applications created with Create React App or Vite are fully supported.

The platform builds your application with npm run build and hosts the output directory, usually build or dist, as a static site on a fast web server.

Set the Node.js version required for the build through NODE_VERSION.

If you use a different build command, such as yarn build or pnpm build, configure it in Build Command.

Because the application is an SPA, unmatched requests (404) automatically fall back to index.html so client-side routing, such as React Router, works correctly. Static sites do not need a Run Command.

Deploying Vue

Deploy client-side Vue.js applications.

Vue.js projects created with Vue CLI or Vite are built during deployment.

The default command is npm run build. The output directory, such as dist, is extracted and served as a static site without a Node.js server.

As with other JavaScript frameworks, customize the build’s Node.js version with NODE_VERSION and its build command in settings.

As with React, browser History API support for client-side routing with Vue Router is preconfigured.

Deploying Next.js

Deploy hybrid and server-rendered applications.

Next.js applications are detected automatically and configured according to their output type: Static Export or SSR.

Set the Node.js version for the server and build with NODE_VERSION.

For SSR applications, npm run build runs first, then the Run Command, which defaults to npm start, starts a Node.js service on the assigned port. You can change both commands in the dashboard.

Next.js features such as API Routes and Image Optimization work without additional configuration.

Deploying Astro

Build fast, content-focused sites with Astro.

Astro supports both static output and server-side rendering (SSR). The system automatically detects and configures your project.

Set NODE_VERSION to change the Node.js version used for building and running the application.

The default Build Command is npm run build. In static mode, the dist directory is served by our fast edge web servers as a static site without a Run Command.

In SSR mode, for example with the Node adapter, the service starts as a dynamic application after building. Configure its Run Command in the dashboard, for example node dist/server/entry.mjs.

Deploying Svelte

Deploy lightweight Svelte and SvelteKit applications.

Standard Svelte projects and SvelteKit applications are detected natively.

Customize the Node.js version for building and running with NODE_VERSION. You can also change the Build Command, such as npm run build.

For SvelteKit, use the appropriate adapter: usually @sveltejs/adapter-node for dynamic applications or @sveltejs/adapter-static for fully static sites.

With adapter-node, run your application as a dynamic service. The default Run Command is usually node build/index.js and can be changed in the dashboard.

Deploying static sites

Host plain HTML/CSS/JS sites.

If no dependency file such as package.json is found in the repository root, the platform treats the application as a plain static site.

No build runs by default in this mode. All repository files are placed directly on the web server.

You can still configure a custom Build Command to run scripts before serving the site, such as shell scripts or Python static-site generators like MkDocs.

This approach suits landing pages, resumes, documentation and custom static sites without a specific framework. Static sites do not require a Run Command.