As a student I was stuck as I could not buy subscriptions and there was no good platform to host my backend projects, free hosting platforms are convenient, but they come with limitations -
— backend goes to sleep
— limited trial usage
— credit card requirements
Then, I looked at my literally 12 year old PC, sitting in dust and it gave me a realization — Your backend doesn’t need Render, Railway, or even a credit card for AWS. All you need is an old PC/Laptop.

Now I run multiple backends 24/7 on a headless server, completely free, and yes, “secure”. Here’s how I did it.

In this blog, you’ll learn:

How to host your backend on your own PC/Laptop

• How to expose it publicly using Cloudflare Tunnel

• How to keep it running 24/7

• How to handle real issues like power cuts and network delays

Works for windows, linux and macOS as well.

How This Works

Before getting into the implementation, let’s understand how this setup actually works.

My frontend is hosted on Vercel, just like a typical setup.

Instead of deploying my node.js backend to a cloud platform, I run it locally on my PC, securely. To make it accessible over the internet, I use Cloudflare Tunnel.

Cloudflare acts as a bridge between the public internet and my local machine, allowing secure access without needing port forwarding or a public IP.

The flow looks like this:

Frontend (Vercel)
↓
Cloudflare DNS
↓
Cloudflare Tunnel
↓
My PC/Laptop (localhost)
↓
Node.js backend (managed by PM2)

Setting This Up

Let’s get into how you can set this up yourself.

The idea is simple. Your backend will run locally on your PC/Laptop, and instead of exposing it using port forwarding, we’ll use Cloudflare Tunnel to make it securely accessible over the internet.

To make everything stable and always running even in case of power cuts or network errors, we’ll also use PM2 to manage our backend processes.

Step 1. Running your backend locally

First, make sure your backend is working properly on your local machine.

For example, if you’re using Express, your server should be accessible at:

http://localhost:3000

If it doesn’t work locally, it definitely won’t work when exposed publicly, so make sure everything is running fine at this stage.

Step 2. Keeping it alive using PM2

Now, instead of running your backend with node, we use PM2.

PM2 is a process manager that keeps your app running even if it crashes or the system restarts.

Start your app using:

pm2 start app.js - name my-backend
# Once everything is running, save the process list:
pm2 save

This ensures your backend automatically restarts whenever your PC/Laptop reboots. Also, make sure to remove any passwords or set a script to auto log-in.

Step 3. Exposing it using a Cloudflare Tunnel

Now comes the most important part, making your local backend accessible over the internet.

Instead of opening ports or dealing with your router settings, we use Cloudflare Tunnel.

This allows you to securely expose your local server to a public domain.

Then, After installing cloudflared, log in to your Cloudflare account:

cloudflared tunnel login
# Then create a tunnel:
cloudflared tunnel create home-server

Step 4. Configuring the Tunnel

Next, you need to create a configuration file that tells Cloudflare where your backend is running.

In your config file, you map your domain to your local server.

For example, your domain can point to:

http://localhost:3000

Step 5. Connecting your Domain

If you have a domain, go to the DNS page of Cloudflare website and add your domain and DNS in their, and connect your DNS with your frontend platform(Vercel, Netlify etc).

Step 6. Connecting your Frontend

If you have a frontend hosted on platforms like Vercel, you just need to update your API URL.

Instead of calling localhost, you use your public domain:

https://api.yoursite.com

Step 7. Making it completely unbreakable and up 24x7

At this point, everything works, but not reliably.

I faced a major issue here.

After a power cut, my PC would restart, but the tunnel wouldn’t reconnect properly, especially because my WiFi took some time to come back online.

So even though my backend was running, it wasn’t accessible.

To fix this, I replaced the default tunnel service with a simple retry script.

This script keeps trying to reconnect the tunnel until the internet is available.

This made the system much more reliable, even with unstable power and network conditions.

Keep the PC/Laptop powered on at all times, you can even disconnect the screen and all your peripherals as well.

Problems I ran into

1. Backend worked locally but not online - This usually happens because the backend is not properly exposed or the tunnel is not configured correctly.

2. Auto-login issues on Windows - To make this setup truly automatic, I needed the PC to log in on its own after a restart. I configured auto-login correctly with the password, the system booted directly into the desktop.

This way, I currently run 5 backend servers on an old pc.

Conclusion

This setup started as an experiment, but it turned into something much more useful.

It may not replace cloud hosting for large applications, but for personal use, it’s more than enough.

Sometimes, the simplest solutions are the most effective.