Serverless is a Scam.

Every time someone reaches for serverless to build a simple backend, a container dies inside me.

“Serverless” promises simplicity, scalability, and zero maintenance. In practice, it gives you time limits, vendor lock-in, surprise billing, and complexity disguised as convenience. You end up duct-taping together SaaS services just to do what a Docker container can do out of the box.

Let me break it down — and preempt the counterarguments along the way.

What Even Is Serverless?

Serverless means you deploy individual functions to a cloud platform, and it handles provisioning, scaling, and execution. You don’t manage the server — you just drop your code in and go.

At least, that’s the dream.

Here’s what you actually get:

• Strict runtime limits (e.g., 15-minute max execution on AWS Lambda)
• Zero state retention between runs
• Cold starts (unless you pay extra, and "pre-warm" your functions)
• Opaque debugging
• Vendor-specific quirks and configs
• A lot of YAML

And if you want to do literally anything non-trivial — long-running jobs, background processing, persistent connections, file uploads — it falls apart fast.

Containers: Simple, Powerful, Boring (In a Good Way)

You know what works?

A container.

• Starts fast
• Runs anywhere
• Keeps state (just add a Docker volume!)
• No arbitrary time limits
• You can attach a debugger, use your favorite runtime, and run locally or in prod — no magic, no special rules

Example:

docker run -v my-data:/data my-app

Boom — stateful workload, works on your laptop, your VPS, or your edge node.

No vendor lock-in. No hidden costs. No rewriting your app to fit someone else’s constraints.

Serverless Pricing: Designed to Confuse You

Serverless pricing is a dark pattern.

• You pay per invocation
• Per memory used
• Per execution duration
• Per GB transferred
• Per region
• Per secret accessed (yes, really)

The pricing page is five layers deep, full of made-up terms like:

• Provisioned Concurrency Units
• GB-seconds
• Requests Tier 1/2/3

And the kicker? You don’t know what you’re paying until the invoice arrives.

Bandwidth is especially overpriced. $0.55/GB egress in 2025? Why?

Compare that to a $5/month VPS with predictable flat pricing and full control. Containers win by a mile.

“But Serverless Scales!”

Sure — technically. But for what? Your app with 4 users?

Most apps don’t need “infinite scalability.” They need:

• Predictability
• Observability
• Reasonable resource limits
• A working dev/staging environment

You know what’s great for that? A container.

Horizontal scaling is trivial (thats Docker Swarm):

replicas: 5

Or throw it behind a load balancer. You get scalability and control — without rewriting your app into a spaghetti of disconnected functions.

Stateless by Design = Artificial Problems

Serverless forces statelessness. That means:

• No in-memory caches
• No temporary files
• No sticky sessions
• No long-lived connections

So now you need:

• An external database
• A distributed cache
• A file storage bucket
• An event bus
• A state machine to orchestrate your state machines

Suddenly your “simple” serverless app depends on six SaaS platforms (each with their own billing, APIs, and failure modes).

Meanwhile, in a container:

• You can cache in memory
• Write to disk (Docker volume)
• Maintain sessions
• Run as long as you need

You know — like a normal program.

“But I Don’t Want to Manage Servers!”

Cool. You don’t have to.

There are tools that give you container-based platforms without ever SSHing into anything:

• Sliplane (shameless plug)
• Railway
• Coolify
• Even just Docker + systemd on a VPS doesn't require much management these days!

You still get Git-based deployments, rollbacks, logs, metrics — but you decide how things run, and you can actually understand the system.

“Serverless Is Cheaper!”

Is it?

Maybe, for 5 invocations a day. But the moment you:

• Have consistent traffic
• Need more memory
• Do actual compute
• Transfer data

...the costs spike. And you can’t optimize much because the platform abstracts everything away.

Meanwhile, containers:

• Run full-time on cheap hardware
• Can be colocated with storage or caches
• Are easy to benchmark and tune
• Don’t charge you per millisecond

When Serverless Actually Makes Sense

Alright, let’s be fair — serverless has its niche:

• Event-driven functions (e.g., image resizing)
• Infrequent tasks or webhooks
• Lightweight internal tools
• Proof-of-concepts
• Stuff that truly needs to scale up and down quickly

If your workload is truly intermittent and stateless, and you want zero operational effort, serverless can work.

But for real apps? You’ll hit a wall. And that wall will cost money, time, and brain cells.

Containers FTW

Containers give you:

• Portability
• Control
• Simplicity
• Transparency
• Flexibility

You can deploy one container, or ten. Scale them. Monitor them. Keep state. Run background jobs. Use your own database. Move providers without rewriting code.

And you’ll actually understand how your system works.

TL;DR

Serverless is cool — in theory.

In reality, it’s:

• Opaque
• Overpriced
• Overcomplicated
• Overhyped

Before you fall for it, ask yourself:

“Could this just be a container?”

The answer is probably yes. And if it is — you’ll save yourself a lot of pain by just starting there.

Got Burned By Serverless?

Drop your horror stories in the comments. Surprise bills, broken workflows, YAML nightmares — I want to hear them all.

Let’s stop overcomplicating the simple stuff.

Cheers,

Jonas, Co-Founder of sliplane.io