I Put All My Apps on One Server. Here's What the Cloud Was Hiding.
AI can generate an application in a weekend. But can you take that application, put it on a blank Linux server, connect a domain, secure it, and keep it alive?
If the answer is no, there's one thing I think every developer should do at least once: self-host a real application.
I'm Rahul Bharati, a Senior Software Engineer. I recently did this again after almost six years, and I had forgotten how frustrating, educational, and genuinely satisfying it could be. This post is the written companion to the video below: the full story, the exact numbers, and the trade-offs I wish someone had spelled out for me.
First: homelab is not self-hosting
When I say self-hosting, I don't mean installing Jellyfin on an old computer and reaching it through Tailscale. I've done that too, but that's homelabbing. Level two, and a story for another video.
Running Jellyfin on a spare PC and reaching it over Tailscale counts as self-hosting.
That's homelabbing. Real self-hosting is renting a VPS, putting a production application on it, and making it publicly reachable through a real domain: DNS, TLS, firewall and all.
Six years ago, we would spin up a DigitalOcean Droplet, install everything manually, run applications on different ports, and configure Apache or Nginx as a reverse proxy. I wrote custom rewrite rules for extensionless routing and deployed apps without Docker. It wasn't convenient, but you understood exactly what happened after somebody typed your domain:
The name you typed turns into an IP address pointing at your server.
Your rules decide the request is even allowed through the door.
The reverse proxy hands it to the right application, on the right port.
Your code runs and starts building a response.
The last piece the response is assembled from, then sent back up the chain.
You didn't just draw those boxes in a system-design interview. You had configured them yourself.
The trap: I was paying for the possibility of traffic
Then Vercel, Railway, Supabase, Neon, and other managed platforms made deployment incredibly easy. That's a good thing. I use these platforms, and I love them. Sometimes I also hate them.
Because my side projects were scattered everywhere. Some on Vercel. One on DigitalOcean App Platform. Two used Supabase. Several used Neon. My static sites were on Cloudflare Pages.
The strange part? Most of these products didn't have users yet. I wasn't paying for traffic. I was paying for the possibility of traffic.
- I paid Supabase so an inactive project wouldn't be paused, then paid extra for a custom domain, because I treat these projects as potential products, not disposable experiments.
- DigitalOcean App Platform had its own fixed monthly cost.
- Vercel's free Hobby plan is great for personal projects, but a commercial SaaS pushes you toward Pro.
- Then I tried Aurora Serverless PostgreSQL on Amazon RDS.
That last one is where the trap got expensive.
Serverless scales to zero, so an idle app with no users costs almost nothing.
Scale to zero and your first user waits for a cold start. Keep everything warm to remove the wait, and in my configuration, with a 0.5 ACU minimum, the practical bill crossed $50 a month. For one database. With almost no users.
Every service was solving a genuine problem. But together, I was running production-grade infrastructure for products without production-grade traffic. So I asked myself: until one of these projects gets real users, why not run them on one server?
The VPS hunt (and why Hostinger)
That question sent me down the VPS rabbit hole.
I started with Hetzner, but many of the cheaper options I wanted were sold out. I ordered a root server from Netcup and signed up with Kimsufi, but identity verification was going to take another two or three days in my case.
Normally I would have waited. But I was in the middle of OpenAI Build Week and a Shipathon. I had applications to finish, deadlines approaching, and one weekend to build a stable deployment setup. I didn't want to configure a temporary server and repeat everything three days later.
So I chose Hostinger. Not because it was the absolute cheapest or most powerful, but because it was the most balanced machine I could start using immediately.
I'm paying roughly ₹6,000 a month (around $70) because I chose the monthly plan. A longer commitment would have dropped the effective cost to around ₹3,000 a month after taxes, but that required paying much more upfront, and I didn't have that budget.
For ₹6,000 I got 8 vCPUs, 32 GB of RAM, 400 GB of NVMe storage, and 32 TB of bandwidth. For comparison, a similarly specced general-purpose machine on DigitalOcean is currently listed at more than $250 a month.
So I wasn't buying a cheap place to dump side projects. I was buying breathing room.
Turning an anonymous machine into my machine
When the server arrived, all I had was an IP address, a username, and a blank Linux machine. Here's the sequence that turned it into something I trusted:
I added my SSH key and verified it worked before turning off password authentication entirely. Passwords are the first thing bots hammer; keys close that door.
Only the ports I actually need are open. Everything else is denied by default.
A fresh OS update, plus swap space so a memory spike doesn't take the whole box down.
A subdomain so I can reach the machine by name instead of memorizing another IP address.
These sound like boring tasks. But every command turns an anonymous machine into your machine. That first clean SSH login after securing everything was a genuine dopamine hit.
An abstraction I actually control
This time I didn't manually recreate my old Nginx setup. I installed Coolify, connected GitHub, and deployed my Next.js applications through Dockerfiles.
I used Dockerfiles instead of letting Coolify auto-detect with Nixpacks. Nixpacks has its own quirks, and Dockerfiles were far more stable and reproducible. Now I get Git-based deployment convenience and I can still see what lives underneath it: containers, ports, memory, logs, environment variables. The abstraction still exists, but it's an abstraction I control.
I also moved my portfolio from rahulbharati.dev on DigitalOcean to rahulbharati.com on this server. I configured the domain, issued the certificate, and redirected the apex domain to www.
That move is a good reminder that DNS points a domain toward infrastructure, but the actual redirect happens at the HTTP / reverse-proxy layer. It sounds like trivia until your redirect stops working.
The surprise: everything got faster
All my domains go through Cloudflare, so eligible static assets get cached closer to users while the VPS handles dynamic requests. There was no sleeping application, no cold function, no database waiting to wake up.
Those sub-10ms numbers are from my own tests, at my location, not a general benchmark. But the experience genuinely felt instant.
And this machine can do far more than host a few Next.js apps. On one server I can run PostgreSQL, Redis, background workers, queues, WebSockets, scheduled jobs, monitoring tools, and staging environments. All without buying a separate service for each one. I can even self-host Supabase; its recommended resources for a small-to-medium workload fit comfortably here, which could significantly cut my combined backend costs.
The honest trade-off
Self-hosting isn't free lunch. It transfers the responsibility to you.
Managed platforms don't charge only for CPU and memory. You're paying them to handle operational problems for you: updates, monitoring, secrets, backups, restoration. On your own server, you get freedom and predictable costs, but those problems become yours.
The 400 GB NVMe drive can serve a meaningful amount of early image and video content, but I wouldn't keep the only copy there. Local drive for databases, thumbnails, caches, and temporary processing; durable user uploads in Cloudflare R2; encrypted backups kept away from the server.
Could this machine run Instagram at Instagram's scale? Obviously not. Could it run an Instagram-style product through its first meaningful stage, with media in object storage and static assets behind a CDN? Absolutely. Ten thousand registered users is realistic for many sensible workloads. Ten thousand concurrent users uploading video is a completely different problem.
The honest capacity answer is always: it depends. But I now have enough headroom to discover real bottlenecks from real traffic, instead of designing an expensive architecture for imaginary scale. When one of these products earns genuine traction, I can move the containers to dedicated bare metal, probably Kimsufi or Hetzner. For now, this VPS is the correct middle ground.
Why it's worth doing once
Self-hosting is still a love-hate relationship. When a container eats all the memory, you hate it. When DNS refuses to cooperate, you hate it. When the server fails, there's nobody else to blame.
But when everything is running, with domains resolving, certificates working, deployments automatic, and applications responding instantly, you absolutely love it.
I may not have FAANG written in my bio. But I understand what happens between someone typing my domain and seeing my application. Not just theoretically. I have touched every part of that path.
Can't afford a VPS? Run Docker on an old computer and expose a temporary app through Cloudflare Tunnel. You don't need to abandon Vercel. You don't need to reject Supabase. You don't need to self-host forever. Just do it once.
Because AI can generate your application, your Dockerfile, and even the server commands. But the server will expose what you actually understand. And once you know what the Deploy button is hiding, you become much better at deciding when that button is worth paying for.
So here's my honest question for you: what's the one thing you've always shipped behind a managed platform but never actually understood underneath? That's the thing worth self-hosting. Once.