# Node.js hosting in 2026: how to deploy an Express app

> A Node.js server in production needs one long-running process that listens on the port it is given, restarts when it crashes and exits cleanly on SIGTERM. On Livops you push a repository with package.json and it runs as a web app for 39 credits a month (39,000 so'm). Here is what Node needs, and how a VPS, Render, Railway, Fly.io, DigitalOcean and Heroku compare.

Source: https://livops.dev/en/hosting/nodejs-hosting

By Livops team, the people who build and run Livops. Updated 20 November 2026.

A Node.js server is one long-running process, and hosting it well comes down to the same few things wherever it runs: listen where the platform sends traffic, keep secrets in the environment, start again after a crash, and finish the requests in flight when you are asked to stop. This page covers each for an Express app, compares the usual places to run one with each provider's own prices, and ends with the exact files Livops reads to deploy it.

## What does a Node.js app need in production?

### A port from the environment, on every interface

A platform tells the app which port to use, almost always in `PORT`. Read it, and leave the host out: when `host` is omitted, Node accepts connections on the unspecified address, `::` or `0.0.0.0`[1], which is what a container needs. Passing `'localhost'` or `'127.0.0.1'` makes the app reachable from inside the container only.

```js
const express = require('express')
const app = express()

app.get('/healthz', (req, res) => res.send('ok'))

const server = app.listen(process.env.PORT || 3000)
```

### An LTS release of Node

Node 22, 24 and 26 are the LTS lines today, and the project's own page says production applications should use only LTS releases[2]. Say which one you need in `engines.node` or `.nvmrc`, so the host does not guess.

### `NODE_ENV=production`

With it set, Express caches view templates and CSS generated from CSS extensions, and prints less verbose errors; its documentation cites tests showing up to three times the performance from this alone[3].

### Something that restarts it

A crashed app stays down until something starts it again. Express recommends a process manager, or the operating system's init system, for exactly that[3]. On a platform this is the platform's job.

### A clean exit on SIGTERM

Before a new version replaces the old one, the old process receives SIGTERM; it should stop accepting requests, finish the ones in progress, close its database connections and exit[4]:

```js
process.on('SIGTERM', () => {
  server.close(() => process.exit(0))
})
```

### A health check

A load balancer sends traffic to an instance only once its health check answers[4]. A route like `/healthz` above, that answers without touching the database, is enough for most apps.

### Secrets and a database outside the code

API keys belong in environment variables, not in the repository or a committed `.env`. Anything that must survive a restart, users and orders above all, belongs in a database rather than in memory or on the container's disk.

## The options at a glance

| Option | What it is | Smallest paid always-on process | What you still maintain |
| --- | --- | --- | --- |
| Livops | A platform; servers in Uzbekistan | 39 credits (39,000 so'm) a month | Your code |
| A VPS in Uzbekistan | A virtual machine with root | 82,000 so'm a month: 1 vCPU, 2 GB, 30 GB HDD (SmartCloud)[5] | The system, Node, a process manager, a reverse proxy, HTTPS, deploys |
| Render | A platform with web services | $7 a month: 0.5 CPU, 512 MB[6] | Your code |
| Railway | A platform billed by usage | Hobby: $5 a month, including $5 of usage[8] | Your code |
| Fly.io | Virtual machines billed by the second | $3.69 a month: shared-cpu-1x, 512 MB[9] | Your code, and its Docker image |
| DigitalOcean App Platform | A platform with container instances | $5 a month: 1 shared vCPU, 512 MiB[10] | Your code |
| Heroku | The original platform with dynos | Basic: $7 a month, 0.5 GB[11] | Your code |

Other providers' prices are from each provider's own page, read on 20 November 2026; the dates are in Sources below. Livops prices are the ones the cabinet bills today.

## Each option

### Livops

An Express, Fastify, Koa, Hono or NestJS project is recognised from `package.json` and runs as a web app with an address and HTTPS. Every `git push` ships a new version, and payment is in so'm through Payme or Click, Uzbekistan's payment services. The servers are in Uzbekistan: close to users there, farther from users in Europe or America. You do not get root, and one app's memory stops at 2 GB; for more than that, or for system software of your own, a VPS fits better.

### A VPS

The most machine for the money: SmartCloud's cheapest 2 GB plan is 82,000 so'm a month[5], and on it you can run several Node apps side by side. Everything between the machine and a running app is yours: Node itself, a process manager or a systemd unit, nginx in front, a certificate, the deploy, and the operating system's updates.

### Render

The smallest paid web service is $7 a month for 0.5 CPU and 512 MB[6]; the Hobby workspace itself is $0 plus compute[6]. Render also has a free instance type for web services, with limits described below[7].

### Railway

The Hobby plan is $5 a month and includes $5 of usage, with services always on[8]. Memory is about $10 per GB a month and CPU about $20 per vCPU a month, billed by the second[8]; usage past the included $5 is billed at those rates. Plans are paid by card[8]. Its regions are California, Virginia, Amsterdam and Singapore[12].

### Fly.io

The cheapest machine, shared-cpu-1x with 256 MB, is $2.19 a month and 512 MB is $3.69[9] — the lowest dollar prices in this table. A personal organisation whose bill comes to less than $5 a month has it waived[9]. After the trial, a credit card is needed to keep using billable resources[9].

### DigitalOcean App Platform

A fixed shared instance with 1 vCPU and 512 MiB is $5 a month and includes 50 GiB of outbound transfer[10]. A fixed CPU keeps the app to one container instance[10].

### Heroku

Basic dynos are $7 a month with 0.5 GB and stay on; Eco dynos are $5 and sleep after 30 minutes of inactivity[11]. Zero-downtime deploys come with Standard-1X, $25 a month[11]. Heroku has moved to a sustaining engineering model; see [the Heroku alternatives compared](https://livops.dev/en/compare/heroku-alternative).

## VPS or platform: what do you maintain?

On a VPS, Express is the easy part. The work is around it: a process manager that restarts the app and survives a reboot, a reverse proxy, certificates that renew, a deploy script, log rotation, and the security updates nobody reminds you about. On a platform you hand over a repository and get a URL; you give up root and the freedom to install anything you like. If the server itself interests you, a VPS teaches you more and costs less per app once you run several. If the app is the point, use a platform.

## Where can you host a Node.js app for free?

- **Livops** has no free tier for apps. On an account that has not paid yet, the first bot or app runs for 15 minutes on a zero balance, once, so you can watch it answer. Static sites are free.
- **Render** gives each workspace 750 free instance hours a month; a free web service spins down after 15 minutes without inbound traffic and takes about a minute to start again[7].
- **Railway** has a Free plan with $1 of usage a month, up to 1 vCPU and 0.5 GB per service, whose services sleep after 5 to 10 minutes without outbound traffic; a trial gives $5 of credit for 30 days with no card[8].
- **Fly.io** has no free tier for new organisations; a trial gives $1 of credit for 7 days, and a personal bill under $5 a month is waived[9].
- **DigitalOcean App Platform** is free for up to 3 static sites only[10].
- **Heroku** lists no free dyno; the cheapest is Eco at $5[11].

## Node.js hosting on Livops

1. In the cabinet, create a project and choose the source: a GitHub repository, an uploaded folder or `.zip`, or the **Express + PostgreSQL** template.
2. Put your keys under **Variables**; mark one as a secret and its value is never shown again. For a database, add PostgreSQL under **Databases**: `DATABASE_URL` is written into the app's variables by itself.
3. Deploy. The log shows the install, the build and the start, and the app gets a `<name>.livops.app` address with HTTPS.

What Livops reads from the repository:

- **The type.** `express`, `fastify`, `koa`, `hono`, `@nestjs/platform-express` or another server library in `package.json` makes it a web app.
- **Install.** `npm install`, or pnpm, Yarn or Bun when `packageManager` in `package.json` names one.
- **Build.** `npm run build`, only when `package.json` has a build script.
- **Start.** `npm run start`. With no start script: a `web:` line in a `Procfile`, the file `main` names, or `index.js`, `server.js`, `app.js` or `main.js`, also under `src/`. When `start` is a development command — `nest start`, `nodemon`, `--watch` — and a `start:prod` script exists, that runs instead.
- **Node version.** Node 22, or Node 24 when `engines.node`, `.nvmrc` or `.node-version` asks for 24 or newer.

To set any of it yourself, put `livops.json` in the repository root:

```json
{
  "kind": "web",
  "build": "npm run build",
  "start": "node dist/server.js",
  "healthPath": "/healthz"
}
```

When the app runs:

- **The environment** has `PORT` (3000 unless you change it), `HOSTNAME=0.0.0.0` and `NODE_ENV=production`.
- **On a new push**, the new version has a minute to answer on `PORT`. Without a `healthPath` any HTTP answer counts; with one, that path must answer 2xx or 3xx. Only then does traffic move to it. The old version keeps running for 15 seconds so requests in flight finish, then gets SIGTERM and 30 seconds to exit. If the new one never answers, the old one keeps serving.
- **If it ignores `PORT`** and listens on exactly one other port, 1024 or higher, it is started once more on that port, which is kept for the next deploys, and the log says so.
- **If it crashes**, it is started again. Ten crashes inside 15 minutes and it is stopped, and you are told with its last lines.
- **Memory.** A web app gets one CPU and 384 MB unless you choose 256, 512, 1024 or 2048 MB (`"memory"` in `livops.json`, or Settings); the size is part of what you pay for. An app killed for memory says so in the log.
- **Files** written to `/app/data` (the `DATA_DIR` variable) survive restarts and deploys; `/tmp` and files next to the code do not.

A web app is **39 credits a month (39,000 so'm)**. One credit is 1,000 so'm, and bought credits never expire. See [Pricing](https://livops.dev/en/docs/pricing) for plans, which give more credits than they cost, and [Frameworks and livops.json](https://livops.dev/en/docs/frameworks) for every field.

## Questions

**Which file does Livops start?**

The start script in package.json, run with npm run start. With no start script it takes a web line from a Procfile, the file package.json's main field names, or index.js, server.js, app.js or main.js, also under src/. You can write the command yourself in livops.json or in Settings.

**Which port should my Express app listen on?**

The one in the PORT variable, which is 3000 unless the project says otherwise. app.listen(process.env.PORT || 3000) is enough. Do not pass localhost or 127.0.0.1 as the host: then only the container itself can reach the app.

**Which Node.js version does Livops use?**

Node 22 by default. If engines.node in package.json, .nvmrc or .node-version asks for 24 or newer, the project is built and run on Node 24.

**Do I need PM2 on Livops?**

No. The platform starts your process again when it exits, and pm2 start in particular puts the app in the background and returns, so the container would end as soon as it started. Start node directly.

**Does a TypeScript or NestJS app work?**

Yes. If package.json has a build script it runs during the build, and the start script runs the result. When start is a development command such as nest start or nodemon and there is a start:prod script, start:prod is used instead.

**How much does a Node.js app cost on Livops?**

39 credits a month, which is 39,000 so'm at 1,000 so'm a credit. There is no free tier for apps; on an account that has not paid yet, the first app runs for 15 minutes on a zero balance, once, so you can see it answer.

**Who wrote this page?**

The Livops team. Every price and limit of another provider on this page links to that provider's own page, with the day we read it.

## Sources

1. [Node.js — net, server.listen()](https://nodejs.org/api/net.html). Checked 20 November 2026.
2. [Node.js — Previous releases](https://nodejs.org/en/about/previous-releases). Checked 20 November 2026.
3. [Express — Production best practices, performance and reliability](https://expressjs.com/en/advanced/best-practice-performance.html). Checked 20 November 2026.
4. [Express — Health checks and graceful shutdown](https://expressjs.com/en/advanced/healthcheck-graceful-shutdown.html). Checked 20 November 2026.
5. [SmartCloud — VDS plans](https://smartcloud.uz/cloud-services/vds/). Checked 20 November 2026.
6. [Render — Pricing](https://render.com/pricing). Checked 20 November 2026.
7. [Render — Deploy for free](https://render.com/docs/free). Checked 20 November 2026.
8. [Railway — Pricing](https://railway.com/pricing). Checked 20 November 2026.
9. [Fly.io — Pricing](https://docs.fly.io/about/pricing). Checked 20 November 2026.
10. [DigitalOcean — App Platform pricing](https://www.digitalocean.com/pricing/app-platform). Checked 20 November 2026.
11. [Heroku — Pricing](https://www.heroku.com/pricing/). Checked 20 November 2026.
12. [Railway — Deployment regions](https://docs.railway.com/reference/deployment-regions). Checked 20 November 2026.
