Guide
What Is Node.js Hosting? Hosting or VPS?
Node.js hosting lets you run JavaScript server apps such as Next.js, Express or NestJS with npm, SSH and Git. Without managing a server, you put your app live in minutes with cPanel’s “Setup Node.js App” tool.
What Is Node.js Hosting and Who Is It For?
Node.js is an open-source runtime that runs JavaScript on the server. Node.js hosting is a hosting service with that runtime ready, so you can put your app online in a few steps. Unlike classic PHP hosting, requests are answered by a JavaScript app that runs its own HTTP server, and you can install npm packages.
Thanks to its event-loop design, Node.js handles many concurrent connections with little memory, which is why it is a common choice for APIs, dashboards and server-rendered sites. It is a practical option for teams that build the frontend in React or Vue and the API in Node.js, developers who keep server and client in one Next.js project, and small SaaS projects that don’t want to manage a server.
How Does a Node.js App Run at BurtiNET?
Our plans run on cPanel, CloudLinux and LiteSpeed Enterprise. Apps are managed on the Setup Node.js App screen in cPanel (CloudLinux Node.js Selector): you choose the version and set the app folder, domain and startup file (for example app.js). “Run NPM Install” installs dependencies into a virtual environment dedicated to the app.
Using Phusion Passenger, the app starts on the first request; if it stays idle for a long time it is stopped and starts again on the next request. Environment variables and restarts are managed from the same screen. Because every app has its own Node.js version and dependency folder, an older API on Node.js 22 and a new Next.js site on Node.js 24 can run side by side in the same account.
Which Apps Can You Run on Node.js Hosting?
Any Node.js app that serves HTTP requests: server-rendered Next.js and Nuxt sites, REST or GraphQL APIs built with Express, Fastify or NestJS, headless CMSs such as Strapi, and webhook services for forms or payment notifications. For example, an online store’s stock API, a mobile app’s backend or a company site’s Next.js frontend all fit this model.
Use the MySQL databases in your plan or external services such as MongoDB Atlas. Discord or Telegram bots and queue workers that must run without HTTP requests are not a good fit for this model.
Setup Notes by Framework
How 8 popular frameworks, from Next.js to Strapi, run on this platform:
- Next.js: React SSR framework. After next build it runs with next start or the standalone server.js.
- Express: Minimal web and API framework. app.js is the startup file and listens on process.env.PORT.
- NestJS: TypeScript API framework. Compiled with nest build; dist/main.js is the startup file.
- Nuxt: Vue SSR framework. After nuxt build the Nitro server runs from .output/server/index.mjs.
- Fastify: Low-latency API framework. Started with fastify.listen({ port: process.env.PORT }).
- Remix: Remix / React Router 7. Runs on Express via @remix-run/express or @react-router/express.
- Strapi: Headless CMS. Works with a MySQL database; building the admin panel needs plenty of RAM.
- Astro: Content-first framework. For SSR, the @astrojs/node adapter (standalone) runs dist/server/entry.mjs.
How to Deploy a Node.js App in cPanel in 6 Steps
Express, Next.js or NestJS: these steps use the Setup Node.js App screen to put your app live on your own domain in about 15 minutes.
- Create the application: Go to cPanel → Software → Setup Node.js App → Create Application, enter the Node.js version, Production mode, application root, URL and startup file, then click Create. Keeping the application root outside public_html means your source code can’t be reached from the web.
- Upload your code: Upload a zip in File Manager and extract it, run git clone over SSH, or add a .cpanel.yml to the root of a repository connected to cPanel Git Version Control. Don’t upload the node_modules folder.
- Install dependencies: Click Run NPM Install on the Setup Node.js App screen; packages are installed into a virtual environment for that app. If you prefer SSH, enter the virtual environment with the source command shown at the top of the panel and run npm install.
- Set environment variables: Production mode sets NODE_ENV=production. Add secrets such as database credentials and API keys one by one with Add Variable under Environment variables, and read them in code as process.env.DB_HOST.
- Build and restart: For Next.js, NestJS or TypeScript projects, run npm run build first and point the startup file at the compiled entry (for example dist/main.js), then click RESTART. For Express, the startup file can simply be app.js.
- Connect the domain and check SSL: Once the domain’s A record points to your server, AutoSSL installs a free certificate automatically; check it under cPanel → SSL/TLS Status. Finally, open the address in a browser or with curl and check the response.
How to Deploy a Next.js Project
The next build step in Next.js uses a lot of memory. For larger projects we recommend building on your own machine or in a CI environment such as GitHub Actions. The most practical route is adding output: 'standalone' to next.config: Next.js produces a .next/standalone folder with only the files it needs plus a server.js, which you set as the startup file.
Remember to copy the public and .next/static folders into the standalone folder yourself. Fully static projects can also publish the out folder produced with output: 'export'. If you build on the server, Node Plus and higher plans have more room.
Why no PM2? What is a cold start?
Your app starts when a request arrives and stops when idle; the platform manages the process. Light apps start instantly, large Next.js apps in a few seconds.
Node.js Versions and LTS Support
Production apps should only run LTS versions that still receive security updates. Node.js 18 reached end of life in April 2025 and Node.js 20 on 30 April 2026; they no longer get patches for new vulnerabilities. Our plans offer Node.js 22 (supported until April 2027) and Node.js 24 (supported until April 2028). We recommend starting new projects on 24 and moving existing ones before support for 22 ends; switching takes one click in the panel.
A Node.js Server (VPS) or Shared Hosting?
Shared Node.js hosting is an affordable, maintenance-free option for websites, APIs and mid-sized projects: server updates, security and backups are our job. If you need root access, Docker, custom ports, WebSocket-heavy apps or bots and queue workers running 24/7, a Virtual Server (VPS) or VDS is the better choice.
A rough rule: if your app only answers incoming HTTP requests, hosting is enough; if something has to run even without requests, you need a virtual server.
Where Should Your Node.js App Run: Hosting, VPS or Serverless?
We compared three infrastructure models on 8 points, from setup to pricing:
- Setup and management: Node.js hosting is ready in cPanel and we maintain the server; on a VPS the OS, updates and security are on you; serverless platforms manage it for you with platform-specific config.
- Root access: Node.js hosting has no root but offers jailed SSH and the cPanel Terminal; a VPS gives full root access; serverless offers only platform tools and a CLI.
- Always-on processes: on Node.js hosting the app starts on request and may stop when idle; a VPS runs it 24/7 with PM2 or systemd; serverless code runs for the length of a request.
- Pricing model: Node.js hosting and VPS plans have a fixed monthly price (a VPS based on allocated resources); serverless is usage-based, so the bill grows with traffic.
- Data location: Node.js hosting and BurtiNET VPS servers are in Turkey; serverless platforms are mostly in US and EU regions.
- Scaling: Node.js hosting upgrades in one click (up to 8 GB RAM); a VPS upgrades CPU, RAM and disk and you configure it; serverless scales automatically, and so does the cost.
- E-mail and database: included with Node.js hosting (5–50 mailboxes, 3–unlimited MySQL); you install them yourself on a VPS; serverless needs separate services and fees.
- Turkish-language support: Node.js hosting includes technical support in Turkish; a VPS gets infrastructure support while the software is on you; serverless usually means English docs and support tickets.
Why Host Your Node.js App in Turkey?
If your users are in Turkey, running your app in the country lowers latency. A round trip to a server inside Turkey usually stays under 20 ms, while a round trip from Istanbul to a server in Frankfurt typically takes 30–50 ms; if a page makes several API calls while loading, that gap repeats with every call. Our servers are at the Tier-3 Mars Data Center in Istanbul, and keeping personal data and backups in the country also makes KVKK compliance easier.
Security, Backups and Resource Isolation
CloudLinux keeps every account within its own CPU, RAM and I/O limits, so a busy account on the same server doesn’t affect your app. Jailed SSH means your account only sees its own files. Every plan includes free SSL and DDoS protection, and your data is backed up daily with JetBackup. AutoSSL renews certificates automatically before they expire.
For databases that change often, we also recommend running mysqldump nightly with cPanel Cron Jobs and copying the output to your own storage. Our 99.9% uptime commitment is backed by our SLA.
Node.js Hosting Prices and How to Choose a Plan
Current prices are shown on the plan cards and exclude VAT; the longer the billing period, the lower the monthly cost. When comparing prices, ask two questions: which billing period does the advertised price belong to, and does it include VAT? Many headline prices on the market are the monthly equivalent of a 3-year upfront payment.
- Node Starter (2 vCores, 2 GB RAM, 150 processes): enough for one Express or Fastify API, a webhook service or a personal project.
- Node Plus (4 GB RAM, 200 processes): suits you if you build Next.js on the server or run 2–3 projects together.
- Node Pro (4 vCores, 6 GB RAM, 300 processes): for agencies running Strapi alongside Next.js and SSR-heavy sites.
- Node Ultra (6 vCores, 8 GB RAM, 400 processes): for many production apps.
Annual and longer terms include a free .com.tr domain.
What Resource Limits Mean: vCore, RAM, EP, NPROC and I/O
Every account runs within its own limits through CloudLinux’s LVE technology; those limits are the numbers in the plan table.
- vCore is the processor power you can use: 2 vCores means CPU equal to two full cores at the same time (2 on Starter and Plus, 4 on Pro, 6 on Ultra). An app that hits the limit is slowed down, not stopped.
- RAM is the total memory of all processes in your account (2, 4, 6 and 8 GB); every running Node.js app, npm install and build takes a share of it. If the limit is exceeded, the process asking for memory is terminated, which is why RAM decides whether large builds succeed.
- EP (Entry Processes) is the number of processes entering your account at the same time. It is not visitors per second but requests handled at the same moment; since requests finish in milliseconds, even a small EP value can handle heavy traffic. When the limit is full, visitors see a “508 Resource Limit Is Reached” error.
- NPROC (process limit) is the total number of processes that can exist in the account at once (150, 200, 300 and 400); SSH sessions, cron jobs and child processes started during builds all count. When it is reached, no new process can start.
- I/O is the cap on disk read and write speed; at the limit, work slows down rather than stopping.
You can track your usage with historical graphs on the Resource Usage screen in cPanel.
Performance Tips to Speed Up Your Node.js App
Get more out of the same resources on shared Node.js hosting with these settings:
- NODE_ENV=production: according to the Express documentation, this single setting can improve performance up to three times thanks to template caching and shorter error output; choosing Production as the Application mode in Setup Node.js App sets it.
- Compression: the compression middleware gzips JSON and HTML responses; text-heavy responses usually shrink by 60–80%.
- Caching: keep frequently read, rarely changing data (category lists, settings) in memory for a short time, and give static files a long Cache-Control lifetime.
- Database pool: instead of opening a new MySQL connection on every request, use a pool of 5–10 connections with mysql2’s createPool; connections stay open and aren’t rebuilt per request.
- Don’t block the event loop: fs.readFileSync, large JSON.parse calls and the synchronous version of bcrypt make every request wait; prefer the async versions.
- Shorten cold starts: load only the modules you need at startup and defer heavy preparation until after the first request.
- Memory limit: if builds hit the RAM limit, keep Node.js below your plan’s RAM with a value such as NODE_OPTIONS=--max-old-space-size=3072.
Node.js Security Checklist Before Going Live
Check these items before you put your app live:
- Secrets: put API keys and database passwords in the environment variables in Setup Node.js App, not in code or Git; if you use a .env file, add it to .gitignore.
- Dependency scanning: run npm audit --omit=dev before every deployment and commit package-lock.json to pin versions.
- HTTP headers: the helmet package removes the X-Powered-By header and adds protective headers such as Content-Security-Policy and Strict-Transport-Security with a single line (app.use(helmet())).
- Rate limiting: limit login and form endpoints with express-rate-limit, for example to 100 requests per IP per 15 minutes; since the app runs behind the web server, add app.set('trust proxy', 1) to see the real visitor IP.
- Input validation: validate user input with a schema library such as zod or joi, and always use parameterised SQL queries.
- Version tracking: support for Node.js 22 ends on 30 April 2027; plan your schedule around it.
- SSH: use an SSH key instead of a password; you can generate and authorise one on the cPanel → SSH Access screen.
Automatic Git Deployment with .cpanel.yml
cPanel’s Git Version Control tool clones your repository into your account and runs the commands in the .cpanel.yml file at the repository root, in order, during deployment. There are two ways to work: with push deployment the repository is hosted in cPanel and every git push triggers a deployment automatically; with pull deployment you click “Update from Remote” and then “Deploy HEAD Commit” in the panel for a repository on GitHub or GitLab.
A typical file has three commands: export DEPLOYPATH=/home/user/apps/myapp/ sets the target folder, /bin/cp -R app.js src package.json $DEPLOYPATH copies the files, and touch $DEPLOYPATH/tmp/restart.txt restarts the app. For deployment to work, the file must be committed at the repository root, the repository must have at least one branch, and the working tree must have no uncommitted changes. Don’t copy node_modules; run Run NPM Install again when package.json changes.
Common Node.js Hosting Mistakes and How to Fix Them
If your app won’t start or returns a 503 error, it is usually one of these:
- Hard-coding the port: use app.listen(process.env.PORT || 3000) instead of app.listen(3000); the server forwards requests to your app.
- Skipping the build: in Next.js, the error “Could not find a production build in the '.next' directory” means npm run build wasn’t run before next start; TypeScript and NestJS projects also won’t start without the compiled dist folder.
- Wrong startup file: the startup file field must point to the right file relative to the application root (app.js, dist/main.js or the server.js in the standalone output); a wrong file usually ends in a 503 error or an “Incomplete response received from application” message.
- Uploading node_modules: CloudLinux keeps dependencies in a virtual environment per app and uses a symbolic link named node_modules in the root folder; a real node_modules folder uploaded from your computer makes Run NPM Install fail. Delete the folder and install from the panel.
- Case sensitivity: require('./Models/User') works on macOS and Windows, but if the file is named models/user.js it throws “Cannot find module” on the Linux server.
- Forgetting to restart: code changes don’t take effect until the app restarts; click RESTART in the panel or update the timestamp of tmp/restart.txt with touch.


