Pxxl Framework Deployment Recipes and Configuration Guide

Pxxl auto-detects most repositories and pre-fills your install, build, and start commands from the lock files and project structure it finds. These recipes let you review, copy, or override those settings for your specific framework. Find your language or stack below, then paste the values directly into the deploy form or your pxxl.toml file.

Pxxl supports all major Node.js package managers and frameworks. Use the recipe that matches your frontend or backend stack.

React, Vue, Svelte, and Astro (Vite SPA)

Best for client-side single-page applications that produce a static dist/ or build/ output.

Setting	Value
Install Command	`npm install`, `pnpm install --frozen-lockfile`, `yarn install --frozen-lockfile`, or `bun install`
Build Command	`npm run build` (or your package-manager equivalent)
Start Command	Leave empty — Pxxl serves the generated static output automatically

package.json

{
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "preview": "vite preview"
  }
}

If you need the preview server (for example to test SPA routing), set the start command to:

npm run preview -- --host 0.0.0.0 --port ${PORT:-4173}

Next.js

Use the default next build command and make sure your start script binds to all interfaces.

Setting	Value
Install Command	Package-manager install command
Build Command	`npm run build` (or your package-manager equivalent)
Start Command	`npm run start` when the script invokes `next start`

package.json

{
  "scripts": {
    "build": "next build",
    "start": "next start -H 0.0.0.0 -p ${PORT:-3000}"
  }
}

For Next.js Standalone output (output: 'standalone' in next.config.js), change the start command to node .next/standalone/server.js.

Nuxt

Nuxt uses Nitro under the hood and reads PORT automatically in most presets.

Setting	Value
Install Command	Package-manager install command
Build Command	`npm run build` (or your package-manager equivalent)
Start Command	`node .output/server/index.mjs`

Express and NestJS API

Use this recipe for REST APIs and GraphQL servers built with Express, Fastify, Koa, or NestJS.

Setting	Value
Install Command	Package-manager install command
Build Command	`npm run build` only when TypeScript or a framework compiler is required
Start Command	`npm run start:prod` when present, otherwise `npm run start`

server.js

const express = require("express");
const app = express();
const port = Number(process.env.PORT || 3000);

app.get("/health", (_req, res) => res.json({ ok: true }));
app.listen(port, "0.0.0.0");

Always bind your server to 0.0.0.0, not localhost or 127.0.0.1. Pxxl’s proxy layer cannot reach a process that only listens on the loopback interface.

Pxxl supports Python web APIs and server-rendered applications using pip or Poetry. All Python servers must bind to 0.0.0.0 and respect the PORT environment variable.

FastAPI

FastAPI requires an ASGI server. Use Uvicorn for development and production.

Setting	Value
Install Command	`pip install -r requirements.txt`
Build Command	None
Start Command	`uvicorn main:app --host 0.0.0.0 --port ${PORT:-8000}`

main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/health")
def health():
    return {"status": "healthy"}

Django

Run database migrations in the build phase. Never hard-code database credentials — inject them via environment variables.

Setting	Value
Install Command	`pip install -r requirements.txt`
Build Command	`python manage.py collectstatic --noinput` (when static files are configured)
Start Command	`gunicorn config.wsgi:application --bind 0.0.0.0:${PORT:-8000}`

# Full release sequence including migrations
pip install -r requirements.txt
python manage.py migrate --noinput
python manage.py collectstatic --noinput
gunicorn config.wsgi:application --bind 0.0.0.0:${PORT:-8000}

Replace config.wsgi:application with your actual WSGI module path — for example core.wsgi:application or myproject.wsgi:application.

Flask

Flask requires a WSGI server. Use Gunicorn for production.

Setting	Value
Install Command	`pip install -r requirements.txt`
Build Command	None
Start Command	`gunicorn app:app --bind 0.0.0.0:${PORT:-8000}`

Pxxl supports Laravel, Symfony, Slim, and plain PHP projects via Composer.

Plain PHP

For projects without a Composer dependency file, Pxxl can serve PHP files directly using the built-in development server.

Setting	Value
Install Command	Leave empty unless `composer.json` exists
Build Command	None
Start Command	`php -S 0.0.0.0:${PORT:-8080}`

Laravel

Cache the framework’s config, routes, and views at build time to eliminate file-system lookups on each request.

Setting	Value
Install Command	`composer install --no-dev --optimize-autoloader`
Build Command	`php artisan config:cache && php artisan route:cache`
Start Command	`php artisan serve --host 0.0.0.0 --port ${PORT:-8000}`

# Full production build sequence
composer install --no-dev --optimize-autoloader
php artisan config:cache
php artisan route:cache
php artisan view:cache
php artisan serve --host 0.0.0.0 --port ${PORT:-8000}

If your Laravel app includes frontend assets built with Vite or Mix, add the Node package-manager install and build commands before the Artisan commands.

Go compiles your source into a single statically-linked binary. This makes Pxxl deployments fast and containers lean.Use this recipe for Gin, Fiber, Echo, Chi, and standard-library HTTP services.

Setting	Value
Install Command	`go mod download`
Build Command	`go build -o bin/server ./cmd/api`
Start Command	`./bin/server`

Your server must read PORT at runtime and bind to 0.0.0.0:

main.go

package main

import (
    "log"
    "net/http"
    "os"
)

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "3000"
    }
    router.Run("0.0.0.0:" + port)
}

Hard-coding a port number will cause the Pxxl health check to fail. Always read PORT from the environment.

Pxxl supports Spring Boot services built with Maven or Gradle.

Setting	Value
Install Command	`./mvnw dependency:go-offline` or `./gradlew dependencies`
Build Command	`./mvnw package -DskipTests` or `./gradlew build -x test`
Start Command	`java -jar target/*.jar` (Maven) or the Gradle-generated jar path

# Maven
./mvnw dependency:go-offline
./mvnw package -DskipTests
java -jar target/*.jar

# Gradle
./gradlew dependencies
./gradlew build -x test
java -jar build/libs/*.jar

Set SERVER_PORT=${PORT} as an environment variable, or configure your application.properties to read ${PORT:8080}, so Spring Boot binds on the port Pxxl assigns.

Pxxl supports Rails and Rack applications managed with Bundler.

Setting	Value
Install Command	`bundle install`
Build Command	`bundle exec rails assets:precompile` (when the asset pipeline is enabled)
Start Command	`bundle exec rails server -b 0.0.0.0 -p ${PORT:-3000}`

# Full production sequence
bundle install
bundle exec rails assets:precompile
bundle exec rails server -b 0.0.0.0 -p ${PORT:-3000}

Set RAILS_ENV=production and SECRET_KEY_BASE as environment variables in the deploy form before your first deployment.

Pxxl supports ASP.NET Core web APIs and Blazor applications.

Setting	Value
Install Command	`dotnet restore`
Build Command	`dotnet publish -c Release -o out`
Start Command	`dotnet out/YourApp.dll`

dotnet restore
dotnet publish -c Release -o out
dotnet out/YourApp.dll

Pxxl automatically sets the ASPNETCORE_URLS and DOTNET_URLS environment variables to the assigned port, so you do not need to configure the listening address manually.

Pxxl supports Axum, Actix-web, Rocket, and Warp services compiled with Cargo.

Setting	Value
Install Command	`cargo fetch`
Build Command	`cargo build --release`
Start Command	`./target/release/your-binary`

cargo fetch
cargo build --release
./target/release/your-binary

Your server must read PORT from the environment and bind to 0.0.0.0:

main.rs

use std::env;

#[tokio::main]
async fn main() {
    let port = env::var("PORT").unwrap_or_else(|_| "3000".to_string());
    let addr = format!("0.0.0.0:{}", port);
    // pass addr to your router's bind / serve call
}

Workers handle background jobs, queue consumers, and scheduled tasks. They do not receive public HTTP traffic and do not need a listening port.

Setting	Value
Service Type	Worker
Install Command	Package or language install command
Build Command	Optional compiler or transpile step
Start Command	The worker entrypoint — see examples below

npm run worker

Workers must keep their process running. If the process exits, Pxxl will attempt to restart it. Make sure your worker does not exit immediately after starting — it should block on a queue or event loop.

Do not expose a port in your worker configuration. Workers that try to bind to a port may interfere with Pxxl’s health-check routing. If you need both a web process and a worker from the same repository, create two separate Pxxl projects — one for the web service and one for the worker.

​React, Vue, Svelte, and Astro (Vite SPA)

​Next.js

​Nuxt

​Express and NestJS API

​FastAPI

​Django

​Flask

​Plain PHP

​Laravel

React, Vue, Svelte, and Astro (Vite SPA)

Next.js

Nuxt

Express and NestJS API

FastAPI

Django

Flask

Plain PHP

Laravel