Dockerfile Is All You Need
Push your code, get a running container — without writing a build script. That was the promise of Heroku buildpacks, and it was a good promise. Most deployment tools still chase it: buildpacks, nixpacks, railpacks. We chased it too. Then we measured, and we changed direction.
Where buildpacks came from
Buildpacks predate the Dockerfile. Heroku invented them to turn source code into runnable "slugs" before containers had a standard build format. The idea survived Heroku's own decline because Railway picked up the torch — kudos to them, genuinely. They kept buildpacks maintained, made the tooling public, and the whole self-hosting community benefits: Coolify and Dokploy both build on this lineage. Nixpacks (Railway's rewrite of the idea) and now railpack (their newest take) carry the same DNA: detect your framework, assemble a build plan, hide the details.
The detection is the magic, and the magic is also the problem.
Magic you can't reproduce
A buildpack pipeline is a stack of detection scripts deciding things about your app — which runtime, which package manager flags, which start command. When it works, it feels effortless. When it breaks, you're debugging someone else's shell scripts instead of your app. Worse: you usually can't reproduce the build on your own machine. The builder has its own environment, its own cached layers, its own opinions about versions. "It built fine on the platform" is the new "it works on my machine," except now the machine is one you can't SSH into.
A Dockerfile has the opposite property. It's declarative, it's in your repo, and the build definition that runs on the server is the same file you can run on your laptop with podman build. The resulting image is not automatically byte-for-byte identical — base image tags, package repositories, CPU architecture, build arguments, timestamps, and other inputs can still change the output. The important part is that the build recipe is visible, portable, and directly runnable with Podman or Docker. If something breaks, the failure is in a file you can read, in a syntax documented by an open standard — not in a detection heuristic three layers deep.
Stability matters more than cleverness here. We'd rather give you a boring, explicit build file than a clever pipeline that surprises you on a Friday deploy.
What we tried: railpack
We didn't arrive at this from theory. We actually experimented with supporting railpack in Bundar — the full integration, real builds, real servers. The result: it wasn't as fast as building with Podman directly, especially on resource-constrained servers. And resource-constrained servers are exactly what our users run — the whole point of Bundar is deploying on your own small VPS without cloud markup, so the build has to be lean where it counts.
An extra build toolchain means extra memory, extra CPU, extra time, and another moving part between your code and a running container. On a 2 GB VPS, that overhead isn't theoretical — it's the difference between a snappy deploy and watching a build crawl.
What we do instead: generate the Dockerfile
So we kept the good part of the buildpack idea — autodetection — and dropped the magic. Bundar detects your stack the way a buildpack would (package.json means Node, requirements.txt means Python, go.mod means Go), then generates a plain Dockerfile from it. And here's the part that matters: you can see it, copy it, and modify it. The generated file is yours. Tweak the base image, add a build arg, pin a version, commit it to your repo — from that point on, it's just a Dockerfile, reproducible anywhere Podman or Docker runs.
Zero-config start, full control after. No detection scripts running at build time, no hidden environment, no "trust the pipeline." If our generated Dockerfile isn't quite right for your app, you don't file an issue against a buildpack — you edit five lines.
Why Bundar defaults to Dockerfiles
This isn't a claim that buildpacks have no place. They remain useful when zero-config detection matters more than having the build definition in the application repository. For Bundar, though, Dockerfiles are the better default: registries, CI systems, Docker, and Podman all understand them, and the build recipe stays visible to the person operating the server.
For Bundar, a Dockerfile is all we need. And if you don't want to write one, we'll write the first draft for you — then hand you the pen.