From Zero to a Running SaaS Backend in Ten Minutes with VBWD

Setting up a SaaS backend usually takes weeks. With VBWD it takes a box, Docker, and four commands. Here’s exactly how to install it and what you’ll see when it’s up.

Download, install, and own your stack.

Ask anyone who has stood up a subscription platform from scratch how long it took, and the honest answer is usually measured in weeks. You wire up a database. You add a cache. You build authentication, then billing, then an admin panel to manage the customers you do not have yet. Every piece is a decision, and every decision is a chance to get stuck.

This article makes a different claim: on a machine that already has Docker, you can go from an empty directory to a running SaaS backend, a user-facing app, and an admin backoffice in about ten minutes. Not a toy. A real stack you can log into, click around, and start shaping. Here is exactly how, with the real commands and an honest account of where the ten minutes can slip.

What VBWD actually is

VBWD is a self-hosted, source-available SaaS platform: subscription billing, user management, and an admin dashboard, built on a stack most teams already know. The backend is Python and Flask on PostgreSQL and Redis. The frontends are Vue 3 with TypeScript. Everything runs in Docker, so your laptop stays clean and the box you deploy to looks the same as the one you tested on.

It is licensed under BSL 1.1. In plain terms: it is free to use, including commercially, as long as your annual VBWD-attributable sales stay under the value of 6.7 BTC. Above that you need a commercial license, and after the change date the license converts to Apache-2.0. You can read the exact terms and the feature list before you commit a single command. No sign-up wall, no credit card to try it.

What you need before you start

The requirements are short on purpose:

A box. Your laptop is fine. A small cloud VM is fine. Linux or macOS.
Docker and Docker Compose installed and running.
Git, and a few gigabytes of free disk for the images.

That is the whole list. You do not need to install Python, Node, PostgreSQL, or Redis on the host. The containers carry their own dependencies. If docker ps runs without an error, you are ready.

The install, step by step

Four commands. Here they are in full, and then what each one is doing so nothing feels like a black box.

git clone https://github.com/VBWD-platform/vbwd-sdk-public.git vbwd
cd vbwd
./recipes/dev-install-ce.sh
make up

Clone the public SDK. The first command pulls down vbwd-sdk-public into a folder called vbwd. This repository is the orchestrator: it knows about the backend and the frontend apps and how they fit together. You can browse it first on the download page if you like to read before you run.

Move into the project. The second command just changes directory. Nothing to explain, but skip it and the next line has nothing to work with.

Run the install recipe. The third command is where the work happens, and it does the tedious parts you would otherwise do by hand. The recipe clones the component repositories in the correct order, because build order matters here: the shared frontend component library has to be built first so the user app and the admin app have something to import. It then builds that library, installs dependencies, and applies the Alembic database migrations so your PostgreSQL schema is current. This is the step that usually takes the longest, mostly because Docker is pulling and building images. Let it run.

Bring the stack up. The fourth command starts the services: the API, PostgreSQL, and Redis, with the user app and admin backoffice served behind nginx. When it settles, you have a running system.

The Make targets you will actually use

The Makefile is the control panel for day-to-day work. A handful of targets cover almost everything:

make up          # start the API, PostgreSQL, and Redis
make up-build    # rebuild the images, then start (use after code changes)
make down        # stop everything cleanly
make logs        # follow the logs when you want to see what is happening

Reach for make up-build whenever you have changed something and want it reflected in the containers. Reach for make logs the moment anything looks off; it is the fastest way to see what a service is telling you.

Choosing what gets installed

The default install gives you the core platform, but VBWD is built around plugins, and you can pick which ones come along. Pass a list to the recipe:

./recipes/dev-install-ce.sh --plugins-list cms shop tarot

That brings up the core stack plus a content management system, a shop, and the tarot vertical, all wired in from the start. You can see what else is on offer in the plugin catalogue and add or enable more later. If you want a real hostname with TLS instead of localhost, the recipe handles that too:

./recipes/dev-install-ce.sh --domain myapp.com --ssl

That points the stack at your domain and provisions certificates, which is the difference between a demo on your machine and something a colleague can reach.

What you see when it is up

Once make up reports the services running, you have three things live at once. The API is answering requests under /api/v1/: authentication, users, plans, invoices, admin operations. The user app is the customer-facing side, where people register, log in, and manage subscriptions. The admin backoffice is your side, where you manage users, plans, subscriptions, invoices, and settings from a proper dashboard rather than raw SQL.

Log into the admin app and click through the sections. Create a plan. Look at the user list. This is the point where the abstract becomes concrete: it is not a template you still have to assemble, it is a working platform you can start bending toward your own product. The full map of endpoints and screens is in the documentation when you want to go deeper.

Two honest gotchas

Speed claims are cheap, so here is where reality can bite, told straight.

A green health check is not the same as a plugin being enabled. The API can report perfectly healthy while a plugin you expected is still switched off. Plugin enable and disable state lives in a single directory on the host, shared by the backend and both frontends, and it is the source of truth. If a feature is missing, do not assume the install failed; check that the plugin is actually enabled there, and restart the affected service if you just changed it.

Ten minutes is the happy path on a prepared box. If Docker is already installed and your network is not fighting you, ten minutes is realistic. A cold machine that still needs Docker, or a slow connection pulling images, will take longer, and that is normal. The install is easy; it is not magic.

And one thing that is not a gotcha but is your responsibility: before you put real customers on this, you own your backups and your TLS setup. A running stack on day one is a starting point, not a production hardening checklist. The docs walk through what to tighten before you go live.

Download and install it now

The whole point of the ten-minute claim is to remove the reason people keep putting this off. There is no license negotiation to try it, no proprietary lock-in to fear, and no long yak-shave before you see something real. You clone one repository, run one recipe, and bring it up.

If you have a box with Docker in front of you, the best next step is to actually do it. Grab it from the VBWD download page, run the four commands above, and give it the ten minutes. Worst case, you spend an evening and run make down. Best case, you end the night logged into your own SaaS backend, picking which plugins to build your product on. Download and install VBWD, and see how far you get before your coffee is cold.