# 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. 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 in Enelsa mode or for an account explicitly granted connector access. 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. 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 --- # 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, a personal access-token flow or an MCP server. 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)