Run every client's app.
Without running a server for each.
The old way is a VM per customer: install everything by hand, then do it again next month. Debesis gives each one an isolated project — quotas, logs, metrics, backups, and its own line on the bill. First deploy takes minutes, and the tenth customer takes exactly as long as the first. Bring a container image, or let Ask Debesis draft the setup with you.
Proposed for your app
Spring Boot API + React · described in 30 seconds
Postgres 16
HA · db.s · 100 GiB
Compute medium
Spring Boot API · ×2
Redis small
Session cache · 512 MiB
Compute small
React frontend · ×1
Estimated
$138 /mo
The old way
One VM per client. Then do it all again.
Most European clouds hand you the parts: an instance here, a database there, storage somewhere else. Wiring them together — per customer, every time — is somebody's full-time job. Usually yours.
Today, for every customer
- Provision a VM and pick an OS
- Install the runtime, database, proxy, certificates
- Hand-write firewall rules and hope they're right
- Bolt on a log agent and some monitoring — or go without
- Guess what this customer actually costs you
- Patch it forever, and remember how it was built
With Debesis
- Create the customer's project — isolated, with quotas
- Deploy the app; add managed Postgres, cache, or streams
- Logs, metrics, health, and restarts are already there
- Usage and cost break down per project
- Scaling, HA, and backups are settings, not projects
- The next customer works exactly the same way
You could build all of this yourself — some teams do. But it's a platform project, and then it's a platform you operate forever, one customer at a time. We built it once so nobody has to build it again.
Minutes, not a week.
Push an image, pick sizes, deploy. Nothing is hand-built, so the tenth customer goes live as fast as the first — and a rollback is one click, not a rebuild.
A project per client.
Each customer gets an isolated environment with its own quotas, access rules, and cost breakdown. No shared box, no spreadsheet math at invoice time.
Included, not installed.
Logs, metrics, health checks, autoscaling, backups, HA — every service has them from day one. Nothing to bolt onto each machine.
Reachable humans.
When something breaks, you talk to the engineers who built it — not a tier-one queue. New to containers? We'll do your first deployment with you.
Services
Six services. Each one we run ourselves.
Curated, not catalogued. Everything a customer environment needs — and nothing you have to install, patch, or monitor yourself. Debesis runs on the same platform we sell.
Compute
Managed containerized apps with autoscaling, health probes, and zero-downtime deploys.
SQL
Managed Postgres with HA, automated backups, and a built-in proxy for safe access.
Storage
Volumes for your services — expansion, snapshots, and restores done right.
Messaging
Managed streams for events and async pipelines. Redis Streams today; Kafka on the roadmap.
Cache
Managed Redis for session, rate-limit, and hot-path data.
Container Registry
A private container registry with per-project access, wired straight into your deploys.
Ask Debesis
Your deployment, drafted by AI.
New to containers? This is the on-ramp. Answer a few questions — app type, stack, expected load — and Ask Debesis proposes the services, sizes them, and estimates the monthly bill. You review and deploy with a step-by-step guide.
Your answers
App type · Web app + API
Stack · Java · Spring Boot · React
Load · ~2k requests/min
Notes · Payments API with Postgres and a session cache
Proposal
Compute medium ×2 — Spring Boot API
SQL db.s — Postgres 16 · HA
Cache small — sessions · 512 MiB
≈ $138 /mo
Describe, don't configure.
A short questionnaire — app type, stack, load — is all it needs. No repo access, no YAML.
Topology that fits.
Service selection and sizing matched to your app and traffic — not a hyperscaler default.
Costs, up front.
Every proposal carries an estimated monthly bill from our real price list — before anything is created.
A guide, not a black box.
Each proposal ends in a step-by-step deployment guide. You stay in control — nothing deploys itself.
"But I need a VM"
You don't. Here's the honest translation.
If your team has shipped to virtual machines for fifteen years, this can look like a different planet. It isn't. Same Linux, same app — fewer things to babysit.
- Where does my machine go?
- You still choose the Linux base, the runtime, and the packages. They live in a container image instead of a runbook — built once, identical for every customer. What you stop getting is a box to patch and a snowflake to remember.
- Do I have to rewrite my app?
- No. If it runs on a VM, it runs here. It needs an image and a start command; nothing about your code changes. If images are new to your team, we'll build the first one with you.
- How do I bill each customer?
- Every customer is a project. Usage and cost break down per project and environment, so re-billing is reading a number instead of rebuilding a spreadsheet.
- Where do logs and access go?
- There are no boxes to log into. Logs, metrics, restarts, and rollout health sit in the console for every service, and access is granted per person, scoped to the projects they actually work on.
- What about the database?
- Managed Postgres with HA and automated backups, plus cache and streams when you need them. No install, no patch night, no replica nobody remembers.
- Can each client keep their own domain?
- Yes. Point the customer's domain at their service and the certificate is handled for you — no per-box nginx config, no renewal cron that quietly fails in eighteen months.
Side by side
The same job, three ways.
Running one customer's app is easy any way you do it. Running twenty — with separate bills, limits, and logs — is where the old way falls apart.
| A VM per client | Hyperscaler or DIY k8s | Debesis | |
|---|---|---|---|
| New customer | Provision, install, configure — every time | Terraform modules and a platform engineer | Create a project, deploy the app |
| Time to first deploy | Hours to days of setup | Fast — once you've built the platform | Minutes, and identical next time |
| What each client costs | Spreadsheet guesswork | Tag hygiene plus a cost tool | Usage and cost per project, built in |
| Logs & metrics | An agent per box — or nothing at all | Run your own logging and metrics stack | There for every service, day one |
| Scaling | Resize the VM at 3am | Yours to tune | Autoscaling and health checks included |
| Databases | Install it, patch it, pray | Operators you now operate | Managed Postgres, HA and backups included |
| Who answers when it breaks | You, at 3am | Tier-one queue | The engineer who built it |
| Global scale | One datacentre, one provider | Best-in-class, at a price | Boutique — multi-region, not multi-continent yet |
Your first client is a project away.
The console is open and the platform already runs our own workloads. Create an environment, deploy a service, and see the bill before you commit to anything.
Questions first?founders@debesis.dev