<100 subscribers

You Don't Need Serverless

I'm a big fan of cheap things that just work. Servers are one of them.

Meanwhile, let's compare that pricing to a more server-based stack.

A 12GB Budget VM ($11.99/mo) from Altivox, which comes with 4 vCPU cores and 1TB included bandwidth can handle 200,000 rpd (2.3 rps) very very comfortably.

Extra bandwidth is $4/TB, so that's an extra $2.40 in transfer costs. Total server cost is $14.39, a large drop compared to the more 'modern', 'efficient' serverless stack.

Spin up more servers in different regions. Altivox has limited scale, but there are various other inexpensive hosting providers like Hetzner and OVH.

To be within 200ms of your users, you only really need five servers: Europe, Tokyo, US East, US West and Australia. Even without calculations, you can already tell that it beats Vercel easily.

Serverless companies actually make money off telling developers that the alternatives are difficult to manage, rather than providing high cost efficiency, as shown by the estimates above. This is also false due to modern tools like Docker and Kubernetes which make managing your apps easy.

Deploying an application today looks like this:

docker build -t myapp .
docker run -d -p 80:3000 myapp

That's it. No dependency issues, no environment mismatches, no configuration drift. Want zero-downtime deployments? Docker Compose with a load balancer handles it fine. Need even more scale? Get another VM, or maybe even bare metal.

Compare that to debugging why your serverless function works locally but fails in production because of Node.js version mismatches between your development environment and Vercel's runtime. These environment inconsistencies literally cannot exist when you control the entire stack, especially when combined with devcontainers or other reproducible dev environments.

Generally, serverless doesn't eliminate complexity, rather, it shifts it to a different place. Instead of managing servers, you're now managing:

• Function timeout limits and memory configurations

• Cold start optimization strategies

• Vendor-specific deployment configurations

• Configuring efficient CDN and caching etc etc.

You've traded straightforward server administration for vendor-specific serverless cloud architecture which changes based on your choice. Though the learning curve for a totally new dev is slightly simpler than managing Linux servers, these are skills that are solely useful for proprietary platforms, which leads to...

Traditional server applications, especially containerized ones, are portable. A Docker container running on DigitalOcean will run identically on Hetzner, OVH, or your laptop. Your nginx config, database setup, and deployment scripts work everywhere.

Serverless apps become strongly architecturally-coupled to their platforms. When you use AWS, you don't just use AWS Lambda, you use API Gateway's request/response format, CloudWatch's logging system, IAM's permission model, and tons of other AWS-only services. When you use Vercel, it's the same thing. Moving away ends up being a total rewrite of your code!

This lock-in has real costs beyond just switching friction. It limits your ability to negotiate pricing, constrains your architectural choices, and makes you dependent on a single vendor's roadmap and reliability.

Server management teaches fundamental concepts: how operating systems allocate resources, how networks route traffic, how databases store and retrieve data, how applications scale under load. These concepts remain relevant even in serverless development, because they're not perfectly abstracted away!

The skills learned by developing with servers are transferable and valuable throughout a dev career. If you understand Linux, networking, and system administration, you become a better developer overall, regardless of your deployment target.

Serverless is not always a bad option. For very event-driven workloads or applications with extremely variable traffic patterns, serverless can make sense. Do the numbers before making important decisions!

But for the majority of web apps: APIs, web services, background workers; traditional deployment models offer better pricing and more control.

Modern server management isn't the nightmare it was 10 years ago. With Docker, excellent VPS providers, and mature tooling, running your own infrastructure is more accessible than ever. You'll likely save money, gain flexibility, and build valuable skills.

Major cloud providers profit from your dependencies and won't teach you these fundamentals. But for most applications, well-managed servers outperform serverless on cost, perf, and maintainability while keeping you in control of your own technology stack.

Ready to try it out for yourself? Coolify offers an excellent self-hosted PaaS experience combined with a solid server like those provided by Altivox.