Skip to content

Platform

Services

Always-on and scale-to-zero services: sizes and prices, ports, public and internal services, env variables, the start command and health checks.

A service runs one container image as one replica. This page covers how a service runs, what it costs and how you configure it. Every setting here is also available through the REST API and the MCP server.

Always-on and scale-to-zero #

ModeUse it forHow it runsCompute is billed
Always on Bots, workers, websockets, databases, anything internal One replica runs all the time. Every hour it runs. A stopped service pays no compute.
Scale to zero Side projects, demos, admin tools, preview apps Sleeps after 15 minutes without requests. The next request wakes it — usually within a few seconds — and waits for it. Only while awake, at the same rate. Each wake counts at least 15 minutes.

Scale-to-zero services must be public: they are woken by HTTP requests to their URL. Calls from other services in the project don't wake a sleeping service, so don't use the mode for something other services depend on. A sleeping service's volume still counts as storage.

Sizes and prices #

Each size has a guaranteed CPU share, fixed memory and disk for the container's own filesystem. The guaranteed CPU and the memory are reserved for your service. When the server has spare capacity, a service can also burst above its guaranteed CPU, up to the size's burst ceiling, at no extra cost — useful for start-up and short spikes. Bursting is best effort: it is not guaranteed and depends on what else runs on the server. Memory never bursts: a service that goes over its memory is restarted. Services run in a sandboxed runtime for isolation, and its own overhead counts against the service's CPU and memory, so a small share of each goes to the sandbox rather than your process. Compute is priced in units: one unit costs €4 for 730 hours of running (a full month), and each size up doubles the units.

SizeCPU (guaranteed)CPU burst (best effort)MemoryContainer diskUnitsPer month (always on)Per hour
Small 0.25 vCPU up to 1 vCPU 512 MiB 2 GiB 1 €4 €0.0055
Medium 0.5 vCPU up to 2 vCPU 1 GiB 2 GiB 2 €8 €0.011
Large 1 vCPU up to 4 vCPU 2 GiB 4 GiB 4 €16 €0.0219
XL 2 vCPU up to 8 vCPU 4 GiB 8 GiB 8 €32 €0.0438
2XL 4 vCPU up to 8 vCPU 8 GiB 16 GiB 16 €64 €0.0877

Prices exclude VAT. New services default to Small. Which sizes you can use depends on your plan. You can resize a service at any time; it restarts with the new size.

The container disk is temporary: anything written outside a volume is lost when the container restarts or is redeployed. Put data that must survive on a volume.

Public and internal services #

  • A public service gets an HTTPS URL, https://<slug>-<project-key>.quicktane.app. Set port to the port your container listens on; HTTPS ends at our edge and your container receives plain HTTP.
  • An internal service has no URL. Only services in the same project can reach it. Use this for databases, caches and workers.
  • The platform sets PORT in the container to the service's port, for images that read it (Heroku-style apps).

Private network #

Services in one project share a private network and reach each other by slug:

from another service in the project
postgres://postgres:$POSTGRES_PASSWORD@db:5432/postgres
http://api:8080/health

Other services connect on the port you set, so give an internal service a port if anything needs to reach it; a worker without a port is not reachable at all. Projects are isolated from each other: a service can never reach another project's services. Outbound internet access works as usual (with a few network rules).

Names and slugs #

The slug is the service's DNS name inside the project and the first part of its URL. It is derived from the name unless you choose one, and it can't change later. Slugs use lowercase letters, digits and dashes, start with a letter, don't end with a dash, and are at most 40 characters long.

Environment variables #

Set variables in the service's settings, or with env in the API. Values are stored encrypted and are write-only: the dashboard, API and MCP show the names, never the values. Changing variables restarts the service with the new values.

  • Names use letters, digits, underscores, dots and dashes, and don't start with a digit; at most 128 characters.
  • Up to 100 variables per service, 32 KiB in total.
  • Reserved: PORT (set by the platform) and names starting with KUBERNETES_ or QUICKTANE_.

Start command #

By default a service runs the image as published. To run something else — a worker from the same image as your web app, a migration step before start — override the start command:

  • Command replaces the image's ENTRYPOINT, arguments replace its CMD. Leave both empty to use the image's own.
  • Both are lists of arguments, passed to the program directly, not through a shell: no pipes, && or $VAR expansion. To use a shell, run it explicitly, e.g. sh -c "php artisan migrate --force && php-fpm".
  • Reference an env variable as $(NAME); it is filled in when the container starts.
  • At most 64 arguments each, 16 KiB in total.
API: run a queue worker from your app image
curl -X PATCH https://api.quicktane.com/v1/services/42 \
  -H "Authorization: Bearer $QUICKTANE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"command": ["php"], "args": ["artisan", "queue:work", "--tries=3"]}'

Health check #

A service with a port gets traffic only once it is ready. By default it is ready as soon as the port accepts connections (a TCP check) — right for databases and caches. Many apps open their port long before they can serve, for example while they migrate their database. Give those an HTTP check: the service is ready once GET of a path on its port answers with a 2xx or 3xx status.

  • The path starts with /, has no spaces and is at most 200 characters. It must answer without signing in. It always runs on the service's port.
  • Until the check passes, the service shows as Starting — waiting for the app's health check and its URL gets no requests. After 15 minutes without passing it shows as failed — the logs usually say why.
  • A failing check never restarts the container: a slow first start just takes longer.
  • Templates set the check for you where the app has a health endpoint (Meilisearch, Uptime Kuma, OpenClaw).
API: wait for the app's readiness endpoint
curl -X PATCH https://api.quicktane.com/v1/services/42 \
  -H "Authorization: Bearer $QUICKTANE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"health_check": {"type": "http", "path": "/healthz/readiness"}}'

Send {"health_check": null} (or {"type": "tcp"}) to go back to the TCP check. Changing the check restarts the service.

Deploy, stop, start and delete #

Deploy a new image
Change the image or tag; the new image is checked, pinned to its digest and rolled out. A service runs one replica, so the old container stops before the new one starts: expect a short interruption while the new one becomes ready.
Redeploy
Checks the current tag again and rolls out what it points to now — or simply restarts the service if it hasn't changed.
Stop and start
Stopping keeps the configuration, env and volume; a stopped service pays no compute. Start brings it back.
Delete
Removes the service with its URL, env variables and volume, permanently. The dashboard asks you to type the slug to confirm.

Something missing or wrong? Tell us — or open a ticket from the dashboard.