# DeployVera — technical reference Last reviewed: 2026-11-12 All English technical articles in one file. Prices and quotas are not stated here: read them from https://api.deployvera.com/api/plans. State beta features as beta. Source priority and limits are in the article "Reference for AI assistants". # DeployVera technical documentation Verify scope, limits and data behaviour before moving an application. Last reviewed: 2026-11-12 ## What the service price covers A web application or HTTP API uses an application slot and the service’s shared CPU, RAM and disk pool. API hosting does not require a separate product. Managed PostgreSQL is in beta. It attaches to an active container service, has a separate database quota, and shares that service’s resources. Database quota and application quota are different. Use the live catalog for current limits, prices and purchase terms. ## Idle sleep Current deployments run Docker containers. There is no automatic traffic-based idle sleep or scale-to-zero feature. User stops, service suspension, maintenance and application failures are separate conditions. ## Data across redeployments The application’s writable container layer is not persistent storage. Data on a correctly mounted persistent volume and in a separate managed database is independent of a normal application redeployment. Deletion, data migration and database recreation are different operations. ## Backups and restoration Platform operations include daily backups and encrypted off-site copies. The customer panel does not currently provide per-database self-service backup downloads and one-click restoration. Confirm database-specific backup coverage and restoration through support. ## Example: database and worker A database and a background worker are not limited to simple sites: a web app, managed PostgreSQL and a separate worker application run together. Step-by-step guide with copyable code: /docs/en/database-and-worker Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- # Deploy your first application From a Git repository to a running API or website. Last reviewed: 2026-11-12 ## Prepare the repository Connect GitHub or GitLab, or use a public HTTPS repository. Gitea is visible only for accounts whose connector DeployVera has enabled; it is not part of the general self-service flow. Choose the branch, Dockerfile or automatic build method, and listening port. Bind the HTTP server to `0.0.0.0`; a process listening only on localhost cannot be reached by the application proxy. ## Create it in the panel - Select an active service and check its available application slots. - Choose the repository and branch. Automatic deployment follows pushes to that connected branch. - Configure the build method, port and required environment variables. - Start deployment, inspect build logs, then verify runtime status. ## Python API example Set the application port to 8000 for this example. Change the module path to match your project. ``` FROM python:3.13-slim WORKDIR /app COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt COPY . . CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"] ``` ## Verify the live revision Runtime state and commit freshness are separate. Compare the live SHA with the head of the connected branch. A failed or cancelled build does not make the previous running version a deployment of the new commit. If a build fails, see /docs/en/build-errors for causes and fixes. ## When the Node.js version is too old (Nixpacks) With the automatic (Nixpacks) build, `NIXPACKS_NODE_VERSION=22` selects only the major version; the minor version comes from the nixpkgs archive Nixpacks uses, and its Node.js 22 is 22.11.0. When a tool such as Astro needs Node.js 22.12 or newer, the build stops with `Node.js v22.11.0 is not supported`. Fix: add a `nixpacks.toml` at the repository root and pin the nixpkgs archive to a newer commit. The commit below provides Node.js 22.13.1. Pinning an archive changes the whole package set of that commit, not only Node.js, so check the first build. The alternative for an exact version is the Dockerfile build method. ``` [phases.setup] nixpkgsArchive = '51ad838b03a05b1de6f9f2a0fffecee64a9788ee' ``` ## Make later builds faster To shorten build times, order the Dockerfile layers, add a `.dockerignore` and use package caches. Details are in /docs/en/faster-builds. Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- # Build errors and fixes Common build failures: how they look in the log, why they happen, how to fix them in DeployVera and how to verify. Last reviewed: 2026-11-12 ## How to read this When a build fails, open the build log in the panel and find the first real error line; the trailing `exit code: 1` is only a summary. The sections below start with the most common failures. Log lines are generic examples; names in your own log will differ. ## Compile errors (especially Next.js) In the log: `Type error: ...`, `Failed to compile.` or `process "npm run build" did not complete successfully: exit code: 1`. Why it happens: `next build` stops on TypeScript and ESLint errors that the local `npm run dev` may not show. Case-sensitive import paths on Linux (`./UserCard` vs `./usercard`) and packages missing from package.json also break the build. - Run `npm ci && npm run build` in a clean local clone and fix the errors; do not silence types with `any`. - For `Module not found`, match the import casing to the file name and add the package with `npm install `. - Add variables needed at build time (for example `NEXT_PUBLIC_*`) under Environment variables; they are inlined at build, so rebuild after changing them. - Push the change and redeploy. - Verify: `npm run build` exits 0 locally and the new build reaches 'Live' in the panel. ## Tip: Next.js Most Next.js build failures are avoided by four things: `output: 'standalone'` in `next.config`; Port and the environment variable `PORT=3000` in the panel; `HOSTNAME=0.0.0.0`; and fixing TypeScript errors locally with `npm run build` before you push. ``` // next.config.ts export default { output: 'standalone' }; // Environment variables // PORT=3000 // HOSTNAME=0.0.0.0 ``` ## Node.js version mismatch In the log: `Unsupported engine`, `EBADENGINE` or `Node.js v22.11.0 is not supported`. Why it happens: a dependency or tool needs a newer Node.js than the automatic (Nixpacks) build provides by default. - Add `NIXPACKS_NODE_VERSION=22` under Environment variables and keep `engines.node` in package.json consistent. - If you need a minor version, add `nixpacks.toml` at the repository root and pin the nixpkgs archive (details in the Quickstart article), or switch to the Dockerfile method under Build and runtime settings and use an exact image such as `FROM node:22.12-slim`. - Verify: the engine error no longer appears on redeploy. ## Database unreachable In the log: `P1001: Can't reach database server`, `ECONNREFUSED` or a `prisma migrate deploy` error at start. Why it happens: `DATABASE_URL` is missing or wrong, or the database was not created in the same service. - Add a managed database to the service; applications and databases in one service reach each other over a private network. - Add the connection string as `DATABASE_URL` under Environment variables. - If you run migrations in the start command and the error persists, split them out of it. - Verify: the start log shows the migration completing and the container becomes healthy. ## Container not healthy (port) In the log: `New container is not healthy, rolling back to the old container` or `EADDRINUSE`. Why it happens: the app is not listening on `0.0.0.0:$PORT`; it listens on `localhost` only, uses a hard-coded port, or the Port field in the panel is wrong. - Make the app listen on `process.env.PORT` and `0.0.0.0`. - Match the Port field in the panel with the app's port. - Verify: the new version becomes healthy and is not rolled back. ## Configuration error (Dockerfile, branch, environment variables) In the log: `failed to compute cache key: "/file": not found`, `Remote branch ... not found` or `Missing required environment variable`. Why it happens: a `COPY` in the Dockerfile points at a file that is not in the repository, the selected branch does not exist, or a required variable is unset. - Check `COPY` paths against the repository root; confirm the file is committed and not in `.dockerignore`. - Match the branch under Build and runtime settings with a real branch name. - Add the variables named in the log under Environment variables. - Verify: the error line is gone from the log. ## Missing start command / process exits right away In the log: `Missing script: "start"`, `No start command could be found` or a container restarting with `exit code=0`. Why it happens: package.json has no `start` script, the Dockerfile has no `CMD`, or the command runs and exits immediately. - Add a `start` script to package.json that keeps the server running. - If you use a Dockerfile, add a final `CMD [...]`. - Check the start command under Build and runtime settings is not empty or wrong. - Verify: the container stays running and the log shows the server listening. ## Repository access failed In the log: `Authentication failed`, `Repository not found` or `Permission denied (publickey)`. Why it happens: the Git connection was revoked, or the repository was deleted or made private. - Re-authorize the Git account in the panel. - Check the repository name and branch; for a private repository the account needs read access. - Verify: the repository is fetched without errors in the first log step. ## Other common errors - Native dependency: `apt-get install ... did not complete successfully`. Verify the package name; use the Dockerfile method for complex system dependencies. - DNS: `getaddrinfo EAI_AGAIN/ENOTFOUND `. Check the host name and the addresses in your environment variables. - Write permission: `EACCES` or `EROFS` (for example `/data`). Give the directory to the app user; attach a volume for files that must persist and use `/tmp` for temporary files. ## Platform-side errors Some failures come from the platform, not your code: a 504 from the internal Git proxy or being unable to reach the Git host, and transient transfer drops such as `fatal: early EOF`. What to do: wait a few minutes and redeploy; do not change code or settings. If it repeats, open a support ticket and include the build ID. ## Speeding up the build If builds are slow, see /docs/en/faster-builds for how the cache works, Dockerfile layer order and cache mount points. Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- # Faster builds How the build cache works, and how to order your Dockerfile, .dockerignore and lockfile for quicker builds. Last reviewed: 2026-11-12 ## How the DeployVera cache works DeployVera keeps a build cache for each application automatically and uses it on every build. The cache belongs to one application and is never shared between customers. The cache reuses layers and package downloads from earlier builds. This is not a guarantee: when a dependency file or source file changes, the affected steps run again. No specific build time is promised. In the build list, successful builds that finish at least 30% and at least 30 seconds faster than the median of the application's recent successful builds are marked "Cached". The label is based only on build time, and it needs at least three earlier successful builds. ## Order Dockerfile layers correctly Copy the dependency files and run the install first, then copy the rest of the source. When only source code changes, the dependency install is reused from the cache. ``` FROM node:22-alpine WORKDIR /app COPY package*.json ./ RUN npm ci COPY . . RUN npm run build CMD ["npm", "start"] ``` ## BuildKit cache mount: npm `RUN --mount=type=cache` keeps the package manager's download cache outside the image and reuses it in later builds. This syntax needs BuildKit; the `# syntax=docker/dockerfile:1` line on the first line of the file enables it. ``` # syntax=docker/dockerfile:1 FROM node:22-alpine WORKDIR /app COPY package*.json ./ RUN --mount=type=cache,target=/root/.npm npm ci COPY . . RUN npm run build CMD ["npm", "start"] ``` ## Cache mounts for pnpm and pip pnpm must be installed in the image before the pnpm step. Do not add `--no-cache-dir` to the pip command, because that disables the pip cache. The target path depends on the home directory of the image user; check it in your base image. ``` # pnpm RUN --mount=type=cache,target=/root/.local/share/pnpm/store pnpm install --frozen-lockfile # pip RUN --mount=type=cache,target=/root/.cache/pip pip install -r requirements.txt ``` ## Exclude unneeded files with .dockerignore Unneeded files in the build context invalidate copy layers for no reason. Exclude local dependencies, Git history and build output, and add secret files such as `.env`. ``` node_modules .git .next/cache dist ``` ## Commit the lockfile Commit `package-lock.json` or `pnpm-lock.yaml` to the repository. `npm ci` does not work without a lockfile; when one exists, the same package versions are installed on every build and the dependency layer is reused more often. ## Avoid forced rebuilds The panel does not currently offer a forced rebuild (skipping the cache); every build uses the cache. If you suspect the cache is causing a problem, open a support ticket and include the build ID. ## Next.js: standalone output Setting `output: 'standalone'` in `next.config.js` collects the files needed at runtime into a separate folder and makes the image smaller. It does not shorten the build itself. With a Dockerfile, copy the `.next/standalone` folder into the image. ``` // next.config.js module.exports = { output: 'standalone', }; ``` Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- # Deploy a plain HTML site Publish an index.html site with no package.json or build step, without exposing the rest of the repository. Last reviewed: 2026-11-12 ## Why the repository root is not published Static frontend mode serves one folder with Nginx. The repository root (`/`) is rejected as the publish directory, because Nginx would then serve every file in the repository, including README, configuration files and anything committed by mistake. Put the files you want online in a subfolder. ## Option 1: public folder (recommended) - Move `index.html` and the CSS, JavaScript and image files it uses into a `public/` folder at the repository root; relative links stay the same. - Do not add a `package.json`. The automatic build method (Nixpacks) recognises the `public/` folder as a static site. - In the panel, keep the automatic build method, enable Static frontend / SPA and set the publish directory to `/public`. The port is set to 80 automatically. - Start the deployment and open the address once the build log finishes. ``` my-site/ ├── README.md └── public/ ├── index.html ├── styles.css └── images/ └── logo.png ``` ## Option 2: Dockerfile To keep `index.html` at the repository root, add a Dockerfile that copies only the files to publish into the Nginx image. Choose the Dockerfile build method and set the application port to 80. Files that are not copied are not published, so list every file and folder the site needs. ``` FROM nginx:alpine COPY index.html /usr/share/nginx/html/index.html # Copy every other file or folder the site needs, for example: # COPY assets/ /usr/share/nginx/html/assets/ ``` ## Unknown paths Static frontend mode falls back to `index.html` for paths it cannot find, so a missing page returns the home page instead of a 404. Use the Dockerfile option for a multi-page site that needs real 404 responses. Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- # Plans and PostgreSQL Application slots, shared resources and database beta scope. Last reviewed: 2026-11-12 ## Service resources are shared Applications and attached managed databases share the service’s CPU, RAM and disk limits. Do not assume each application receives the whole plan’s resources independently. The permanent free plan is not a trial. Each account can have only one non-terminated free service. Its current limits are 0.5 vCPU, 512 MB RAM, 2 GB disk and one application. Use the live catalog and pre-payment invoice for currency, tax and campaign eligibility. ## Optional setup packages Setup packages are optional, one-time services. You can always set up your applications yourself at no charge. Prices are fixed per currency (USD / EUR / TRY) and are not converted. Quick setup (49 USD / 49 EUR / 1,799 TRY, 2 business days): one app with a Git repository, Dockerfile or automatic detection, domain and SSL, environment variables, one database connection and a live check. Migration (149 USD / 149 EUR / 5,490 TRY, 5 business days): up to 3 apps and 1 database moved from Heroku, Vercel, a VPS or a Compose project. Agency starter (390 USD / 390 EUR / 14,490 TRY, 10 business days): up to 10 client projects plus an onboarding workshop. Quick setup is free for the first project of the first 10 design partners and is included with a yearly prepaid Standard or Pro plan. The founder discount does not apply to setup packages. Request one at /contact?topic=setup. ## Managed PostgreSQL PostgreSQL can be created as a beta managed database attached to a container service. The public installation’s default quota is three managed databases per service; the limit reported for the particular service is authoritative. Creating a database does not create a separate database subscription. Get the private endpoint and credentials from the panel. Connect the application and database through the service’s private network. Set DATABASE_URL in the actual application runtime; keep it out of the repository. ## API and database are separate resources An API application consumes one application slot. A managed database uses the separate database quota. Installing a database inside an application image is a different arrangement with different resource, storage and backup responsibilities. Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- # Persistent data and redeployment Know which data belongs to the image and which belongs to storage. Last reviewed: 2026-11-12 ## Three kinds of storage - Repository files: versioned content copied into the image during build. - Writable container layer: runtime files that may disappear when the container is replaced. - Persistent volume or database: image-independent data retained across normal redeployment. ## Use the real persistent path Verify the actual mount path for uploads, SQLite files or generated models. Calling a folder storage does not make it persistent. A mounted volume can hide files copied into the same image directory by a new commit. Check that an import file is actually present in the running container. ## PostgreSQL persistence A separate managed PostgreSQL data volume is independent of the application container. Redeploying only the application does not reset that database. Deleting a database or service can delete data; deletion is not redeployment. ## Schema changes Deploying code does not automatically make a database schema compatible. Manage application migrations and rollback compatibility explicitly. Persistent storage and a one-off seed/import step are separate concerns. Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- # Backups, exports and restoration Understand the scope of operational platform backups. Last reviewed: 2026-11-12 ## Operational backups Platform operations include scheduled local database backups and encrypted off-site copies. Integrity checks and restore drills are part of the operational procedure. That mechanism alone does not prove every customer database can be restored at any moment. Verify the latest evidence, coverage of that database, and a relevant restoration test separately. ## Current customer-panel scope A self-service per-database download and one-click restore workflow is not currently published. Open a support ticket for export or operator-assisted restoration. Confirm retention, RPO and RTO in writing. ## Independent logical exports PostgreSQL tools such as pg_dump and pg_restore can be used with appropriate credentials and an available network path. Do not assume a private endpoint is directly reachable from the internet. Define an independent backup policy for critical application data. An image, commit or successful deployment record is not a database backup. ## Include in a restoration request - Which database and service? - Which backup date and target point? - Overwrite existing data or restore into a separate database? - How will schema compatibility and restored data be verified? Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- # One-off commands and project settings Use the same runtime configuration as the running application. Last reviewed: 2026-11-12 ## Project settings groups - Access and security: project visitor password and public/private exposure. - Deployment settings: repository, branch, service, domains and deployment actions. - Technical settings: runtime version, port, build/start commands and environment variables. ## One-off imports and migrations Putting an import in the start command can run it on every restart. Verify whether a one-off script is idempotent and targets the intended database. The following command is for a server operator. Do not assume customer-panel users have host Docker or SSH access; request operator assistance if no shell is available. ``` docker exec -w /app \ python scripts/import_data.py /data/import.json ``` ## The runtime environment matters docker exec does not automatically inherit variables exported by an entrypoint only to its own child process. In particular, verify DATABASE_URL matches the running application’s connection. Use the existing secure runtime configuration rather than putting passwords in shell history or chat. ## When must it run again? If the same persistent database is retained, a completed one-off import does not need to run on every deploy. A new dataset or recreated database may require another import. Determine repeat behaviour from the script’s insert/upsert logic, not its filename. Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- # Adapt a Compose project to DeployVera How to turn the services in a Docker Compose file into separate applications and managed databases. Last reviewed: 2026-11-12 ## Docker Compose is not supported yet The panel does not run a Docker Compose file as written. A customer-written Compose file can ask for privileged containers, host networking or host folder mounts, which is not safe on a multi-tenant server. Most Compose projects can be split into separate applications and managed databases inside one service. Applications and databases of the same service reach each other over a private network. This section describes the default state. When restricted Compose support is switched on, the new-deployment wizard shows a "Docker Compose (restricted)" method; if you do not see it, Compose support is not enabled yet. ## Restricted Compose support (when enabled) When enabled, your Compose file is checked on the server before every deployment and only allowed options are accepted. The file must be in the repository root (docker-compose.yaml/yml or compose.yaml/yml) and come from GitHub, a connected GitLab or a connected Gitea repository. Up to 10 services, 100 KB and 50 YAML aliases are accepted. The domain is attached to the single service that exposes a port (expose). Accepted: image or in-repository build, environment, expose, depends_on, healthcheck, restart, declared named volumes, tmpfs, CPU/memory limits and declared bridge networks. Rejected: privileged, cap_add, devices, network_mode, host pid/ipc/uts/userns/cgroup, ports (use expose instead), extra_hosts, sysctls, container_name, links, host path mounts (absolute, relative ./ or .. paths and docker.sock included), external networks and volumes, a build context that leaves the repository, extends/configs/secrets/include, traefik/caddy/coolify labels and every unrecognised option. Each rejected rule is shown in the panel with its own explanation. Preview password protection, PRIVATE access, static site mode, build directory and source migration are not available for Compose deployments. ## Where each part goes - A service built from your code (`build:`): a separate application using the Dockerfile in the repository. Each application uses one application slot; the number of slots depends on your plan. - `redis`, `postgres`, `mysql`, `mongo` images: managed Redis, PostgreSQL, MySQL and MongoDB databases. The database quota is separate from the application quota. - `ports:`: the single port the application listens on. Choose public access if it must be reachable from the internet, or private (PRIVATE) access if only other applications use it. - `environment:` and `env_file:`: the application's environment variables. Do not commit passwords or keys; enter them in the panel. - Service names (`http://api:3000`, `redis:6379`): on the private network, addresses are internal addresses starting with `dv-`. The panel shows this address on the application detail page and for each database. Pass it to the other application as an environment variable. - `depends_on:`: there is no start order. Your applications should retry when the service they depend on is not reachable yet. - `volumes:`: not carried over. Use a managed database for persistent data. ## Managed Redis Redis can be chosen as an engine on the Databases page. Copy the connection value from the panel and add it yourself to the application's environment variables as `REDIS_URL`; the user name is `default` and the database number is 0. Persistence of Redis data to disk is not guaranteed. Use it for cache, sessions and rebuildable queue data, not as the single source of truth. Redis has a memory limit; if it fills up, the process can stop and restart, so limit memory use in your application. There is no browser management screen for Redis. ## What to know - The panel has no build directory setting: to separate several services that live in one repository, give each service its own repository. - Host networking, privileged containers and host folder mounts are not supported. - The service's CPU, RAM and disk limit is shared by the applications inside it; each managed database also has its own memory and CPU limit. ## Let's adapt it together Open a support ticket or write through the contact page and attach your Compose file and repository link. We will go through the first setup together. Before you move, you can paste your file into the free Compose compatibility check (/tools/compose-check). It runs in your browser; nothing is uploaded or stored. Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- # App with a database and a worker Run a web app, PostgreSQL and a background worker together on DeployVera: a copyable, step-by-step example. Last reviewed: 2026-11-12 ## What works Yes: a managed PostgreSQL database, a background worker and a web app run together in one service. By default the panel does not run Docker Compose multi-service deployments; each service becomes its own application instead. For prices and quotas see the live plans: https://deployvera.com/docker. The free plan includes 1 application slot; the web app and the worker are two applications, so you need at least 2 slots. The database counts against a separate quota. - Web app: a public application (access mode "Public"). - Worker: a second application with access mode "Internal network only". Applications and databases in the same service reach it at an internal address like `http://dv-xxxx:PORT`. The worker takes its work from a table in the database, so it needs no outside address. - Database: managed PostgreSQL created on the Databases page; you copy its connection URL from the panel. - Environment variables are set per application, so `DATABASE_URL` is added to both. - Logs are read per application in the Container log section of its page. ## Repository: package.json Web and worker live in one repository. Every file in this guide sits at the repository root (package.json, Dockerfile, src/). ``` { "name": "web-worker-example", "private": true, "type": "module", "dependencies": { "pg": "^8.13.0" } } ``` ## Repository: src/db.js The pool and the schema of the table-based job queue. Both applications call it on start-up and create the table if it is missing. ``` import pg from "pg"; export const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL, max: 5 }); export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); // Web and worker both call this at startup; the advisory lock makes it safe to run concurrently. export async function migrate() { for (let attempt = 1; ; attempt++) { let client; try { client = await pool.connect(); await client.query("SELECT pg_advisory_lock(727001)"); await client.query(`CREATE TABLE IF NOT EXISTS jobs ( id BIGSERIAL PRIMARY KEY, payload JSONB NOT NULL, status TEXT NOT NULL DEFAULT 'pending', error TEXT, created_at TIMESTAMPTZ NOT NULL DEFAULT now(), finished_at TIMESTAMPTZ )`); await client.query("SELECT pg_advisory_unlock(727001)"); return; } catch (error) { console.error(`migrate attempt ${attempt} failed: ${error.message}`); if (attempt >= 10) throw error; await sleep(3000); } finally { client?.release(); } } } ``` ## Repository: src/web.js ``` import http from "node:http"; import { pool, migrate } from "./db.js"; await migrate(); const json = (res, status, body) => { res.writeHead(status, { "content-type": "application/json" }); res.end(JSON.stringify(body)); }; const server = http.createServer(async (req, res) => { try { if (req.method === "POST" && req.url === "/jobs") { const { rows } = await pool.query( "INSERT INTO jobs (payload) VALUES ($1) RETURNING id", [JSON.stringify({ queuedAt: new Date().toISOString() })], ); return json(res, 202, rows[0]); } if (req.url === "/jobs") { const { rows } = await pool.query( "SELECT id, status, error, created_at, finished_at FROM jobs ORDER BY id DESC LIMIT 20", ); return json(res, 200, rows); } json(res, 200, { ok: true }); } catch (error) { console.error(error); json(res, 500, { error: "internal" }); } }); server.listen(Number(process.env.PORT || 3000), "0.0.0.0", () => console.log("web listening")); process.on("SIGTERM", () => server.close(() => process.exit(0))); ``` ## Repository: src/worker.js ``` import http from "node:http"; import { pool, migrate, sleep } from "./db.js"; await migrate(); // The panel asks for a port on every application, so the worker answers on it too. http.createServer((_req, res) => res.end("worker ok")) .listen(Number(process.env.PORT || 3000), "0.0.0.0"); let running = true; process.on("SIGTERM", () => { running = false; }); // SKIP LOCKED lets several worker copies take different jobs without double processing. async function claim() { const { rows } = await pool.query(`UPDATE jobs SET status = 'running' WHERE id = (SELECT id FROM jobs WHERE status = 'pending' ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1) RETURNING id, payload`); return rows[0]; } while (running) { let job; try { job = await claim(); } catch (error) { console.error("claim failed:", error.message); } if (!job) { await sleep(2000); continue; } try { console.log(`job ${job.id} started`); await sleep(1000); // your real work goes here await pool.query("UPDATE jobs SET status = 'done', finished_at = now() WHERE id = $1", [job.id]); console.log(`job ${job.id} done`); } catch (error) { console.error(`job ${job.id} failed:`, error.message); await pool.query("UPDATE jobs SET status = 'failed', error = $2, finished_at = now() WHERE id = $1", [job.id, String(error.message)]); } } process.exit(0); ``` ## Dockerfile ``` FROM node:22-slim WORKDIR /app COPY package.json ./ RUN npm install --omit=dev COPY src ./src # The web app uses this default; the worker application sets APP_ROLE=worker in its environment variables. ENV APP_ROLE=web CMD ["sh", "-c", "exec node src/${APP_ROLE}.js"] ``` ## 1. Create the database Open the Databases page in the panel, choose PostgreSQL as the engine and create a database attached to your service. When it is running, copy its connection URL. It looks like `postgres://user:password@dv-...` and is an internal address that only applications in the same service can reach. Do not commit the URL. You enter it as an environment variable in the next steps. ## 2. Deploy the web app In the new application wizard choose the repository and branch, pick Dockerfile as the build method and set the port to 3000. The access mode stays "Public". Under advanced settings add the environment variable `DATABASE_URL` (the URL you copied in step 1). The Dockerfile defaults to `APP_ROLE=web`, so no other variable is needed. Start the deployment; once it is live, the `/jobs` path on the web address returns an empty list. If you prefer Detect automatically (Nixpacks) over the Dockerfile, enter `node src/web.js` as the start command of the web app and `node src/worker.js` for the worker; the Dockerfile and `APP_ROLE` are then not needed. ## 3. Deploy the worker as a second application Create a second application from the same repository (same service, same branch). Use the Dockerfile build method, port 3000 and access mode "Internal network only". Environment variables: the same `DATABASE_URL` and `APP_ROLE=worker`. If the application already exists, switch the access mode with "Disable public access" on its detail page; this briefly restarts the running application. The worker takes jobs from the `jobs` table with `FOR UPDATE SKIP LOCKED`, so even several worker copies never take the same job twice. No separate queue product is needed. ## 4. Try it and read the logs Add a job on your web address and list the jobs. Within a few seconds the status should change from `pending` to `done`. Read the logs on each application's detail page: the web app shows `web listening`, the worker shows `job 1 started` and `job 1 done`. For a build error, check that application's build log; common errors are in /docs/en/build-errors. ``` curl -X POST https://YOUR-WEB-ADDRESS/jobs curl https://YOUR-WEB-ADDRESS/jobs ``` ## "Ship it" from Claude Code With the DeployVera MCP server connected (setup: /docs/en/mcp) you can give a request like the one below in the repository. The agent creates each application with `create_project` (which always asks for your approval in the browser), writes the variables with `set_env_vars`, follows the build with `deploy` and `get_build`, and reads logs with `get_build_logs`. Creating the database and setting the worker's access mode to "Internal network only" happen in the panel; the agent does not take those two steps. ``` Ship this repo to DeployVera as two applications. The web app is public; the worker app runs with APP_ROLE=worker. Give both the same DATABASE_URL. When the builds finish, read the logs of each application. ``` ## Limits The panel does not run a Docker Compose file as is; each service is a separate application. Restricted Compose support only appears when it is enabled on the server (/docs/en/compose-migration). The build directory and Dockerfile path setting may be disabled on the server, which is why the example uses one root Dockerfile and `APP_ROLE`. Do not rely on subdirectory builds. Deploying the same repository as two applications builds it twice; resources are shared across all applications in the service. The queue here is deliberately simple: moving jobs that a crashed worker left as `running` back to `pending` after a timeout is up to you. For database backups see /docs/en/backups. ## Next steps Plans and current prices: https://deployvera.com/docker. For persistence and database behaviour see /docs/en/persistence and /docs/en/plans-and-databases. Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- # Deploying Next.js (standalone, ISR, next/image, Proxy) Run a Next.js app on DeployVera as a Docker container: output standalone, PORT and HOSTNAME, and what works under next start (ISR, next/image with sharp, Proxy), with the Next.js documentation as the source. Last reviewed: 2026-11-12 ## What this covers DeployVera runs your Next.js app as a continuously running Docker container on Node.js. That is the self-hosting model described in the Next.js documentation, not the Vercel platform runtime. Framework features that depend on a Vercel-specific platform runtime, edge functions or a global CDN are outside this model. Features that work with `next start` on a Node.js server, such as the ones below, work in a container. Claims about Next.js on this page come from the Next.js documentation: the self-hosting guide (last updated 2026-10-15) and the `output` reference (last updated 2026-09-18), both retrieved 2026-11-16. Check the current Next.js documentation before relying on a detail. ## output: 'standalone' Set `output: 'standalone'` in the Next.js config. Per the documentation, this creates a `.next/standalone` folder that can be deployed on its own without installing `node_modules`, plus a minimal `server.js` that can be used instead of `next start`. The minimal server does not copy the `public` or `.next/static` folders by default. The documentation says they can be copied into `standalone/public` and `standalone/.next/static` after `next build`, after which `server.js` serves them. ``` // next.config.js module.exports = { output: 'standalone', } ``` ## PORT and HOSTNAME Per the documentation, if the project needs to listen on a specific port or hostname, define the `PORT` or `HOSTNAME` environment variables before running `server.js`; for example `PORT=8080 HOSTNAME=0.0.0.0 node server.js` starts the server on `http://0.0.0.0:8080`. In a container, set `HOSTNAME=0.0.0.0` so the server accepts connections from outside the container, and make `PORT` match the port you enter in the DeployVera panel. ## Example Dockerfile A multi-stage Dockerfile that builds the app and runs the standalone server. Adjust the Node.js version and the package manager to your project. Secret values belong in environment variables in the panel, not in the Dockerfile. ``` FROM node:22-alpine AS build WORKDIR /app COPY package*.json ./ RUN npm ci COPY . . RUN npm run build FROM node:22-alpine WORKDIR /app ENV NODE_ENV=production ENV HOSTNAME=0.0.0.0 ENV PORT=3000 COPY --from=build /app/.next/standalone ./ COPY --from=build /app/.next/static ./.next/static COPY --from=build /app/public ./public EXPOSE 3000 CMD ["node", "server.js"] ``` ## ISR, next/image and Proxy under next start Image Optimization through `next/image` works self-hosted with zero configuration when deploying using `next start` (self-hosting guide). If you prefer a separate service, an image loader can be configured. The `output` reference lists `node_modules/sharp/**/*` as an example include pattern when tracing misses native files. On glibc-based Linux systems the guide notes that image optimization may need additional configuration to prevent excessive memory usage; the free plan has 512 MB RAM, so watch memory. Proxy (the file convention that handles requests before routing) works self-hosted with zero configuration when deploying using `next start`; it is not supported with a static export. Incremental Static Regeneration and the cache: per the guide, ISR uses the same Next.js server cache, stored by default on the local filesystem of each server instance, and this works automatically for a single instance with persistent local disk. On DeployVera the container’s writable layer is ephemeral, so the cache is rebuilt after a redeploy unless you mount persistent storage; running several instances needs a shared cache handler as described in the guide. ## Environment variables By default, environment variables are only available on the server. Variables prefixed with `NEXT_PUBLIC_` are inlined into the JavaScript bundle during `next build` (self-hosting guide), so they must exist when the image is built; verify this in the build log. Define server-side variables in the DeployVera panel as runtime environment variables. ## Limits Next.js features that rely on Vercel-specific infrastructure are not provided. Databases on DeployVera are beta, and backups are platform-level with no self-service download or restore. Where the Next.js documentation and your project’s Next.js version differ, the documentation for your version applies. Prices and plan limits are in the live catalog at /docker. Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- # Deploy from AI agents (MCP) Use the hosted DeployVera MCP server from Claude Code, Cursor, VS Code or Codex: install, sign-in, permissions, approvals and limits. Last reviewed: 2026-11-12 ## What it is DeployVera runs a hosted MCP (Model Context Protocol) server at https://mcp.deployvera.com/mcp (Streamable HTTP). An AI agent in Claude Code, Cursor, VS Code or Codex that is connected to it can list the projects of the signed-in account, start a deployment, wait for the build, read build and runtime logs, explain a failed build, roll back and manage environment variables. The agent acts with the permissions of the account or token that signed in, never more. Buying or changing plans, payments, billing, account settings and administration are not available to the agent and stay in the customer panel. The server is listed as `com.deployvera/mcp` in the MCP registry, as `deployvera-mcp` on npm, in the Claude connector directory (https://claude.ai/directory/connectors/deployvera) and on GitHub (https://github.com/deployvera/deployvera-mcp). The agent can create a project in a plan you already have, if it has a free application slot, and deploy it; creating a project always needs your approval, and ordering a plan stays in the panel. ## Install: Claude Code Run this once in a terminal. The first tool call opens a browser window for sign-in (OAuth). ``` claude mcp add --transport http deployvera https://mcp.deployvera.com/mcp ``` ## Install: Cursor One-click install: https://cursor.com/install-mcp?name=deployvera&config=eyJ1cmwiOiJodHRwczovL21jcC5kZXBsb3l2ZXJhLmNvbS9tY3AifQ%3D%3D Or add the server by hand to `~/.cursor/mcp.json`: ``` { "mcpServers": { "deployvera": { "url": "https://mcp.deployvera.com/mcp" } } } ``` ## Install: VS Code Add the server to the MCP configuration of VS Code (`mcp.json`): ``` { "servers": { "deployvera": { "type": "http", "url": "https://mcp.deployvera.com/mcp" } } } ``` ## Install: Codex Add the server to `~/.codex/config.toml` and export the personal token (see the next section) as the environment variable named below: ``` [mcp_servers.deployvera] url = "https://mcp.deployvera.com/mcp" bearer_token_env_var = "DEPLOYVERA_TOKEN" ``` ## Install: stdio client Clients that can only start local processes can use the npm package instead of the hosted URL. The token variable it expects is described in the repository README. ``` npx -y deployvera-mcp ``` ## Sign-in: browser OAuth or personal token Browser OAuth is the default: the client opens a DeployVera sign-in and consent screen, and the account owner chooses which permissions to grant. Connected apps can be disconnected in the panel under Settings > AI agent access. A personal token is the alternative for clients without a browser flow. It is created in the panel under Settings > AI agent access, starts with `dvp_`, is shown only once, has a name, a chosen set of permissions and a validity period (30, 90 or 365 days), and can be revoked at any time; revoked access ends immediately. An account can hold at most 10 active tokens. Send it as `Authorization: Bearer dvp_...`. Treat it like a password and never commit it to a repository. ## Permissions (scopes) Every token and every OAuth login carries a subset of three scopes. - `read`: always on. Lists projects, databases, builds, logs, the names of environment variables, your own services, connectable repositories and domain status. - `deploy`: start a deployment, cancel a build, roll back, create a project and manage a custom domain. - `env`: write and delete environment variables. The agent can set a value but can never read a value back. ## Approvals in the browser Five actions always need approval from the account owner: `rollback`, `delete_env_var`, `create_project`, `set_domain` and `remove_domain`. The tool returns an approval link instead of acting. The owner opens it (deployvera.com/approve), signs in and confirms with the account password and two-factor code. Then the agent calls the same tool again with the approval id. An approval expires after 10 minutes and works for one action only; the agent cannot approve on its own, and `check_approval` only reports the state. A token or login can also be set to require approval for every deploy. This is a per-token or per-login option in Settings > AI agent access. ## Tools The server exposes 21 tools. - `list_projects`, `get_project`: projects and their current state. - `list_databases`, `get_database_logs`: managed databases (beta) and their logs. - `deploy`: start a deployment of a connected project. Needs the `deploy` scope. - `get_build`: build status; `wait_seconds` (0 to 120) makes the call wait for the build to finish. - `get_build_logs`: build or runtime logs. - `explain_build_failure`: a short explanation of why a build failed. - `cancel_build`: stop a running build. - `rollback`: return to an earlier release. Always needs approval. - `list_env_vars`: names only, never values. - `set_env_vars`: write variables. Needs the `env` scope. - `delete_env_var`: remove a variable. Always needs approval. - `check_approval`: state of a pending approval. - `list_services`: your own services with plan, status and free application slots. Shared services are not included. - `list_repositories`: repositories you can deploy from in the connected GitHub or GitLab accounts (and Gitea where enabled). No tokens are returned. - `create_project`: create a project in one of your own services from a Git repository. Always needs approval, and works only where the service has a free application slot; it never orders or changes a plan. - `start_domain_verification`: returns the DNS records you must create for a custom domain. It changes no routing and needs no approval. - `set_domain`: attach the custom domain once DNS is verified. Always needs approval. - `remove_domain`: detach the custom domain. Always needs approval. - `check_domain`: whether a domain is attached and whether each name currently points to the project. ## Security limits The agent cannot buy or change plans, make payments, change billing or account settings, or use any administrator function. Environment variable values are never returned to the agent. Requests are limited to 120 per minute. Every action runs under the signed-in account and is checked against the ownership of the project, exactly like the panel. Even so, a connected agent can start deployments within the granted scopes. Grant only the scopes needed, prefer short validity periods, turn on approval for every deploy for production projects, and revoke tokens that are no longer used. ## Typical workflow After the code is pushed, ask the agent to deploy the project. It calls `deploy`, then `get_build` with `wait_seconds` set to 120. If the build fails it calls `explain_build_failure` and `get_build_logs`. A rollback is proposed only when asked, and waits for approval in the browser. Common build errors and fixes are in /docs/en/build-errors. A short walkthrough with example prompts is at https://deployvera.com/deploy-from-claude-code. Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- # Reference for AI assistants Public readable sources and the limits of what they establish. Last reviewed: 2026-11-12 ## Source priority - Current prices and plan limits: the live /api/plans catalog. - Feature scope: these documents and platform.json. - A specific project’s state: the owner’s authorized panel or authenticated API response. - Current reachability: the status page and the application’s health endpoint. ## Machine-readable versions Every article has a Markdown URL. /docs/platform.json describes capability scope, /docs/llms.txt indexes articles, and /llms-full.txt contains all English technical articles. Content is rendered on the server and needs neither authentication nor JavaScript to read. ## API scope The public product catalog is available at GET https://api.deployvera.com/api/plans. Hosting an API application does not grant unrestricted access to DeployVera’s management API. Customer resources require authentication and ownership checks. Do not invent unpublished endpoints. The hosted MCP server for AI agents is at mcp.deployvera.com/mcp (https://github.com/deployvera/deployvera-mcp); risky actions need approval in the browser; install steps and scopes are in /docs/en/mcp. Administrator permissions differ from customer permissions. ## Keep these facts separate Do not describe a beta feature as generally available or guaranteed. A running application does not prove it runs the newest commit or has a verified backup. Distinguish container files, persistent volumes and managed databases. Sources: https://api.deployvera.com/api/plans · https://deployvera.com/docker · https://deployvera.com/help --- ## When DeployVera fits and when another platform fits DeployVera is best suited to: - Dockerfile-based APIs, websites and workers that run continuously without idle sleep or scale to zero. - Teams that want a flat monthly plan with visible CPU, RAM, NVMe disk and application limits. - Applications that use managed PostgreSQL, MySQL, MongoDB or Redis (all beta) next to the app, with a database quota separate from applications. - Starting on a permanent free plan (0.5 vCPU, 512 MB RAM, 2 GB storage, one application; no card, no automatic conversion to paid). DeployVera is not the best fit for: - Applications that depend on a framework-specific platform runtime, serverless or edge functions, or a global CDN. - Teams that need preview deployments across a large team workflow. - Workloads that need a Docker Compose file run as-is (Compose is not supported; services are split into applications and managed databases). - Workloads that need self-service database backup download or restore, a guaranteed public database endpoint, or a contractual SLA (none is offered). ### Compared with Vercel Vercel's Docker container runtime and Daemons (always-on workers) are in beta on all plans. HTTP container apps run on Fluid compute as functions and scale to zero when idle (after 5 minutes in production). Daemons run only in production, with no autoscaling, no inbound HTTP/TCP and no persistent local disk. Pricing is usage-based (Active CPU, memory, invocations, bandwidth). The Hobby plan is limited to non-commercial personal use. DeployVera instead runs containers continuously with no scale to zero, publishes flat monthly plans with visible resource limits, and offers managed databases (beta) beside the application. Vercel's framework integration, serverless and edge functions, CDN and preview deployments are outside DeployVera's scope. Sources: - https://vercel.com/kb/guide/docker (retrieved 2026-11-12; publisher last updated 2026-11-01) - https://vercel.com/docs/functions/limitations (retrieved 2026-11-12; publisher last updated 2026-08-24) - https://vercel.com/docs/pricing (retrieved 2026-11-12; publisher last updated 2026-09-14) - https://vercel.com/docs/plans/hobby (retrieved 2026-11-12)