Hey, I’m Fabio 👋 I’ve been working in systems and distributed compute for a while now, and I wanted to write up a few thoughts on serverless—specifically how it works (and doesn’t) for container-based workloads.

Not a deep dive, more like a brain dump. Maybe someone finds it useful.

So, serverless.

It’s still a bit of a misnomer, right? There are servers, just not ones you have to think about. You ship code, and the platform handles the infra: scaling, provisioning, patching, etc. You don’t manage machines; you write code, define logic, and it runs when triggered.

That idea is still powerful. And in a lot of cases, serverless feels like the cleanest, simplest model—especially for things like:

  • ML inference
  • ETL pipelines
  • Media processing
  • Event-driven stuff
  • Scheduled jobs

You only pay for what you use, and you don’t need to configure VMs or clusters. For most people, that’s a win.

That said, "serverless" means different things depending on who you ask. The cloud landscape is layered, and it helps to know what’s what.

  • At the base you’ve got IaaS (Infrastructure as a Service): raw compute like EC2, spot instances, or GPU VMs.
  • Then there’s self-managed containers like Kubernetes or ECS, where you handle orchestration.
  • Above that is serverless containers (e.g. Cloud Run, Fargate, Modal, RunPod), which abstract the cluster but still give you a container.
  • And the top layer is fully-managed PaaS, like Vercel or Netlify, and FaaS (Function as a Service), where you’re barely thinking about infra at all. Most people call the top two layers "serverless" but the experience and flexibility vary a lot.

Cloud providers by service model (IaaS + PaaS), 2025

But…

Serverless today comes with real trade-offs. The most obvious one is cold starts. Some platforms are better than others, but if your job spins up slowly, that’s a problem, especially for anything latency-sensitive.

Then there’s the fragmentation. You can end up with 50 little function files, weird interdependencies, logs all over the place. And debugging across distributed services?... not always fun.

Also, there’s vendor lock-in. When a platform wraps your logic in its own SDK and runtime model, you often lose control over things like packaging, sidecar containers, or file system paths. It’s fine until it isn’t.

Platforms I’ve explored

  • AWS Lambda and Google Cloud Functions — The OGs. Still solid for simple event-driven use cases. But not ideal for long-running or compute-heavy stuff.
  • Google Cloud Run and AWS Fargate — A better fit for containers. You can bring your own Docker image, define a runtime, and let them handle scaling. I like Cloud Run for its simplicity, though startup time and pricing can be a bit opaque.
  • Modal — Honestly, Modal’s SDK is pretty neat. You can write a Python function and run it on the cloud with minimal effort. But once you need custom system packages or want to bring in something like ffmpeg or handle persistent volumes, it gets tricky fast.
  • RunPod — More low-level. You get pods with GPU/CPU power and can run containers pretty freely. Super useful for ML work. But it does require a bit more ops knowledge—mounting volumes, networking, that kind of thing.

Where I landed

Serverless isn’t going anywhere. It’s still great for a lot of workloads. But if you’re running real compute—longer jobs, heavier pipelines, containerized apps—you want more control without having to manage clusters manually.

So back in 2022 I started a project called ByteNite, with the goal of bringing control back into serverless, while keeping the abstraction that makes it so appealing. I've built it around Docker containers to stay portable and provider-agnostic.

Also, I've been doing a lot of research on cloud pricing, and found out huge markups (up to 7x) between their regular on-demand rates and their serverless ones. It's just frustrating to let this happen because nobody has stepped into the space to create competition with some fresh new technology. Maybe I'll post more about pricing analysis if ppl are interested.

What I’d love to see more for developers is a platform that gives you:

  • The simplicity of serverless
  • The control of containers
  • And a developer experience that’s not buried in YAML

If anyone’s found something that strikes that balance well, I’d love to hear about it, as I'm here to learn!

Thanks for reading. Always happy to nerd out in the comments about containers, distributed jobs, or just infra pain in general 😄