10 min read
How to Deploy Node App Free: 4 Paths That Work in 2026
Key takeaways
- Heroku's free tier ended in 2022, so free Node hosting now means build-limited platforms, the 12-month AWS tier, or local deployment.
- Most free tiers cover build minutes, not always-on compute, so a sleeping Express server is a trial rather than free hosting.
- Express apps crash on free hosts when they hard-code the port instead of binding to process.env.PORT.
- Vercel runs Express as serverless functions, breaking WebSockets, in-memory sessions and held database connections.
- Developers paying with MTN or Airtel Money are locked out of most free tiers at the billing screen because upgrades require a USD card.
Yes, you can deploy a Node app free in 2026, but every free tier breaks a real Express app somewhere: sleep timers, cold starts, port binding rules, or build-minute caps. This guide walks the four realistic paths, shows exactly where each one fails, and ends with a decision flowchart that treats mobile money payment as a first-class criterion.
Can you actually deploy a Node app free in 2026?
Yes, but the free options left are narrower than they look. Heroku killed its free tier in 2022 and now runs on paid Eco dynos, billed per dyno-hour through the Heroku documentation. What remains truly free is build-limited hosting like Vercel, the AWS 12-month tier, or running on your own machine.
What 'free tier' means for a running Express server
A free tier usually covers build minutes, not always-on compute. An Express server that sleeps on idle requests, or a dyno that runs out of hours mid-month, is not free hosting; it is a trial. Push-to-deploy from GitHub with automatic HTTPS is the baseline worth comparing, as shown in git push deployment.
The card problem nobody mentions
Most "free" tiers require a card on file before you upgrade, and USD-billing cards are the barrier for many Kenyan and Ugandan developers. If a provider cannot accept MTN or Airtel Money, the free tier is a dead end the moment you need a custom domain or more RAM.
Which free Node.js hosting tier survives production traffic?
The worked Express app we test against
Take one app: an Express API with a Postgres connection, a /health route, a couple of JSON endpoints, and app.listen(process.env.PORT). That last line matters. Any free tier that fails to inject a PORT variable will crash the app on boot, so port binding is the first filter. Then we check what happens after 15 minutes of no traffic, whether the build step has a hard cap, and whether a custom domain survives the free plan.
Free-tier limits side by side
| Limit | Heroku | Vercel | AWS free tier | Omeganodes |
|---|---|---|---|---|
| Sleeps when idle | Yes | Serverless, no sleep | No | No |
| Cold start | Yes, after sleep | Yes, per function | No | No |
| Build minutes | Limited by eco dyno | Capped per month | 12-month expiry | Not capped |
| Port binding | PORT env var | Handled for you | You manage it | PORT env var |
| Pay with mobile money | No | No | No | Yes |
The pattern: Vercel handles the Express app poorly because it wants serverless functions, not a long-running app.listen process. Heroku sleeps. AWS expires. Omeganodes runs the app as a persistent process with automatic HTTPS, and you can pay with MTN or Airtel Money (how it works). Where it falls short: no free tier at all, just fair regional pricing.
How do you deploy a Node app on Heroku for free in 2024 and after?
Heroku killed its free tier in late 2022, so "free" now means two workarounds: Eco dynos and student credits. Both are temporary, and both run out for a real app.
Eco dynos and the 1000-hours math
Eco dynos cost $5 per month per app, billed as 1000 shared compute hours. One app running 24/7 burns roughly 720 hours, so one app fits, two do not. Eco dynos also sleep after 30 minutes of inactivity, so a side project gets cold starts on every quiet morning. Student credits via the GitHub Student Developer Pack delay the bill but expire.
Procfile and port binding requirements
Heroku requires a Procfile and a process.env.PORT bind; hard-coded ports fail at deploy. If you want push-to-deploy without the hours math, Omeganodes deploys from GitHub with automatic HTTPS and accepts MTN and Airtel Money instead of a USD card (see the Omeganodes FAQ). Note that sleeping dynos also mean your app cannot hold long-running jobs, a constraint serverless platforms share: Vercel documents execution-time and payload caps per plan in its functions documentation.
Can we deploy a Node.js app on Vercel without hitting its limits?
Why Express on Vercel is not the same as Express on a server
Vercel runs your Express app as serverless functions, not as a long-running process. WebSockets, background jobs, in-memory sessions and anything holding a database connection open across requests all break or behave strangely. Cold starts add latency on low-traffic side projects, and long-running requests hit execution time limits. If your Express app assumes a server, expect to rewrite parts of it.
When Vercel is the right call: deploy react node app frontends
For a React frontend with a thin API layer, Vercel is hard to beat: git push to deploy, automatic HTTPS and a custom domain in minutes. It stops being the right call when you need a real Node process, a database outside their approved list, or predictable billing.
If you want push-to-deploy without serverless constraints, a PaaS like Omeganodes runs your app as a proper server with automatic HTTPS, and you pay with MTN or Airtel mobile money instead of a USD card.
How do you deploy a Node Express app to AWS free tier without surprise bills?
The AWS free tier covers 750 hours per month of a t2.micro or t3.micro EC2 instance for 12 months, plus 30 GB of EBS storage and 100 GB of outbound bandwidth. That is enough for one small Express app running 24/7, as long as you stay inside those limits and remember the clock starts at signup.
EC2 t2/t3.micro setup in five steps
- Launch a t2.micro or t3.micro Ubuntu instance in a region close to your users.
- Open ports 22, 80 and 443 in the security group.
- SSH in, install Node and PM2, clone your repo, run
pm2 start app.js. - Install Nginx as a reverse proxy on port 80.
- Add Certbot for automatic HTTPS on your custom domain.
If five steps plus server upkeep sounds like the opposite of git push to deploy, that is the honest trade-off. A PaaS like Omeganodes in Italian or Render does this plumbing for you; EC2 makes you do it.
The four bill traps: elastic IP, bandwidth, snapshots, forgotten instances
An elastic IP is free only while attached to a running instance. Stop the instance and leave the IP attached, and AWS bills you hourly. Outbound traffic beyond 100 GB per month is the second trap: a runaway loop or a scraped API can cross it in days. Third, EBS snapshots are never free-tier unlimited, and people back up daily without checking. Fourth, forgotten instances: you launch a second t3.micro for testing, the two instances together exceed 750 hours, and the second one bills from day one. Set a billing alarm before you deploy anything.
How do you deploy a Node.js app locally for testing before going live?
Local run with environment variables matching production
Run node server.js with a .env file loaded through dotenv, and mirror the variable names you will use in production: PORT, DATABASE_URL, JWT_SECRET. Set PORT=3000 locally but never hard-code it, since most PaaS platforms inject their own port. Test against a local Postgres with the same schema as your live database so the first deploy is not the first time the app runs. Confirm HTTPS-only behaviour locally with a self-signed cert if your production app forces redirects.
Tunneling a local app for demos
When you need to show a side project before buying hosting, expose it with a tunnel instead of deploying early. ngrok's documentation covers forwarding a local port to a public HTTPS URL in one command, which lets you test webhooks and mobile clients. Treat every tunnel as temporary: it dies when your laptop sleeps, so keep the real deploy plan separate.
What breaks when you deploy a React + Node app as one project?
Serving the build folder from Express
Pointing Express at client/build with express.static works on day one. It breaks on free tiers when your app sleeps: the first visitor after a cold start waits for the whole Node process to boot before seeing a single pixel. You also lose CDN caching, so every asset request hits your one dyno or instance, and a traffic spike to your landing page starves your API.
When to split: two deploys, one domain
Split when your React app gets most of the traffic, when you want deploys to frontend and backend on separate schedules, or when a static host's CDN would cut your API load. Keep them together if the app is small, internal, or mostly API-driven with a thin UI. On a PaaS like Omeganodes you can run both as two services from one repo and still pay with MTN or Airtel Money.
How do you deploy a Node app with Azure DevOps pipelines on a free tier?
Azure DevOps gives you a free Microsoft-hosted pipeline grant, and for a simple Node app the YAML is short enough to write once and forget. You push, the pipeline runs npm install and tests, and you deploy wherever your server lives.
A minimal azure-pipelines.yml for Node
trigger:
- main
pool:
vmImage: ubuntu-latest
steps:
- task: UseNode@1
inputs:
version: '20.x'
- script: npm ci && npm test
- script: npm run build
That is the whole pipeline for a typical Express app. Deployment steps (scp, SSH, or a webhook to your host) come after the build, so the CI part stays identical no matter where the app runs.
Free grant limits and who this suits
Microsoft's free parallel job grant for Azure DevOps gives one free parallel job with a monthly minute cap, and public projects get the grant without a approval wait. For one solo developer pushing a side project a few times a day, that is enough. It breaks down once you run tests on every push to several branches, because minutes burn fast and a queued pipeline waits on your single job. Treat it as CI, not hosting: the pipeline builds and ships, but you still pay for the server separately, which matters if your card situation already rules out most hosts.
Which option should you pick if you cannot pay with an international card?
Decision flowchart: card vs mobile money vs no payment
Start with payment, not features. If you have a card that bills in USD, pick on runtime needs: Vercel for frontend-heavy React, Render or Railway for a real Express server with a database. If you only have MTN Mobile Money or Airtel Money, most of those paths close at the billing screen, no matter how good the free tier is, because the first overage or upgrade requires a card the platform accepts.
If mobile money is your only payment method, the honest flowchart is short. Local deployment stays free for testing but nothing ships. AWS free tier needs a card on signup. Heroku needs a verified card for anything beyond the eco trial. That leaves platforms that bill in local currency or accept mobile money directly, which is a shorter list than the feature comparisons above suggest.
Where Omeganodes fits — and where it falls short
Omeganodes is built for exactly this case: git push to deploy from GitHub to EU servers, automatic HTTPS, custom domains, no Kubernetes, no YAML, and MTN or Airtel mobile money instead of a USD card. For a first SaaS or a side project, that removes the billing wall the other paths hit.
Where it falls short: it is a small platform, so you should not expect the ecosystem depth of Render or Fly.io, and if you outgrow managed PaaS entirely, the HN commenter is right that no Heroku alternative takes care of quite as much. Test your app locally first, deploy free where possible, and pay with mobile money only when a platform actually supports it.
FAQ
Is there still a truly free way to deploy a Node.js app without a credit card?
Barely. Heroku's free tier died in 2022, AWS requires a card at signup, and Vercel needs one before you upgrade. What remains genuinely free: building and testing locally, tunneling a demo through ngrok, or the 12-month AWS window if you already have a card. Without any payment method, nothing ships publicly.
Why does my Express app crash on a free host even though it works locally?
Usually port binding. Locally you hard-code 3000, but most hosts inject their own PORT variable and expect app.listen(process.env.PORT). Hard-coded ports fail at deploy. Sleep timers are the other culprit: hosts like Heroku kill idle dynos, so the first request after 30 quiet minutes hits a cold start or a dead process.
Can I deploy a MERN stack app on a free tier and keep the database free too?
Yes, but with trade-offs. Vercel hosts the React frontend free, and MongoDB Atlas has a free cluster, but the Express backend needs a long-running process that serverless platforms handle poorly. WebSockets, in-memory sessions, and held database connections break. On sleeping free tiers, every cold start makes visitors wait for the whole Node process to boot.
How much traffic can a free Node.js host handle before I have to upgrade?
Less than the tier implies. Sleep timers mean low traffic actually hurts more: quiet periods trigger cold starts. AWS's 750 monthly hours cover one t2.micro around the clock, but 100 GB of outbound bandwidth and build-minute caps run out fast. A traffic spike to a static frontend can starve your API on a single instance.
Do I need to pay in USD to use Heroku, Render or Railway from Kenya or Uganda?
In practice, yes. All three require a card that bills in USD before you reach a custom domain, more RAM, or an overage, so the free tier becomes a dead end at the billing screen. MTN or Airtel Money does not work there. Your realistic options are platforms that accept mobile money directly or bill in local currency.
Deploy at the speed of Africa
World-class hosting, open to every developer, wherever you build and however you pay. Start free in a couple of minutes — no credit card, no lock-in.