You hand it over.
We run it.
Watasu is a modern PaaS for teams who'd rather ship product than babysit clusters. Push code, attach a database, watch it run — at a fraction of what you're paying today.
git push watasu mainEnumerating objects: 81, done.Counting objects: 100% (81/81), done.Delta compression using up to 16 threadsCompressing objects: 100% (72/72), done.Writing objects: 100% (81/81), 207.74 KiB | 23.08 MiB/s, done.Total 81 (delta 4), reused 0 (delta 0), pack-reused 0 (from 0)remote:remote: -----> Starting build...remote: Build startedremote:remote: -----> Preparing sourceremote: Cloud Native Buildpacks app detectedremote: Detected Procfile processes: webremote: [build] Using persistent buildpack cache (40Gi)remote:remote: -----> Successfully built!remote:remote: -----> Launching...remote: Released v1remote: https://myapp.watasuhost.com deployed to Watasuremote:To https://git.watasu.io/myapp.git * [new branch] main -> main
git push to live URL in under 30 seconds.
Built for three kinds of frustrated
Different starting points, same destination: stop fighting infrastructure and start shipping.
Tired of rebuilding the same platform
Stop writing the same Helm charts, ingress controllers, secret loaders, and Grafana dashboards for the third company in a row. Watasu ships them once, correctly, with a contract you can actually point at.
Just want it on the internet
If you've got an app and a Git repo, you've got everything you need. Push code, get a URL with TLS. Add a database with one command. No YAML, no clusters, no operators.
Done with surprise hosting bills
Predictable EUR billing that stays that way as you grow. Multi-DC resilience included at no extra charge. No hidden egress invoices, no "contact sales" tier blocking the plan you actually want.
Four commands. One running app.
No cluster setup. No YAML. No 47-page onboarding doc.
Install
brew install watasu — single binary, macOS, Linux, Windows.
Create
watasu create my-app — a managed URL with TLS, a Git remote, ready in seconds.
Push
git push watasu main — Cloud Native Buildpacks or your Dockerfile, your call.
Attach
watasu addons:create postgresql --app my-app — connection string injected automatically.
Everything an app needs, in one bill
The boring infrastructure work — done, tested, and on by default. You write code; we run the platform.
Push to deploy
Git push triggers a Cloud Native Buildpacks or Dockerfile build, a release, and a rolling update — with output streamed back to your terminal.
Managed databases & caches
PostgreSQL, Valkey (Redis-compatible), ClickHouse, Redpanda (Kafka-compatible), and S3-compatible object storage. One command to attach.
Grafana, automatic
Logs, metrics, and traces — wired into a per-app Grafana the moment you attach the first observability add-on. No setup.
Multi-DC by default
Apps with two or more replicas are spread across two German data centers (Nuremberg + Falkenstein) for resilience without configuration.
Custom domains with TLS
Point a CNAME, run `watasu domains:wait`. Certificates are provisioned and renewed automatically.
GitHub-native workflows
Auto-deploy from a branch, promote built artifacts between staging and production, spin up a review app for every pull request.
Microservices, the easy way
Name a process `*-tcp` to get a private TCP endpoint reachable only by apps you explicitly trust. Service-to-service traffic without VPCs, mTLS gymnastics, or service mesh setup.
WebRTC-ready out of the box
Name a process `*-rtc` and Watasu provisions a dedicated TURN gateway, a public UDP port, and a stable hostname per replica — with `TURN_*` injected as env vars. SFUs, voice agents, and real-time apps just work.
EU-hosted, GDPR-by-default
Hosted in Germany. No US data plane, no transatlantic data transfers, no surprise compliance work.
Standard containers, no lock-in
Your code runs as a standard container image. No proprietary build artifact, no platform-specific runtime contract. Walk away with the same image any time — there is nothing to migrate off.
Managed services that show up in seconds
One CLI command. Connection details injected as config vars. Backups, monitoring, and Grafana already wired in.
PostgreSQL
from €3/moHobby, Standard, and Premium tiers with sync-replica HA.
Valkey
from €1/moRedis protocol-compatible cache. Auto-failover from Standard.
ClickHouse
from €15/moAnalytical database for events, logs, and dashboards at scale.
Redpanda
from €30/moKafka-compatible streaming. Durable, replayable event flow.
Object Storage
from €2/moS3-compatible bucket with scoped credentials. Geo-replicated tiers.
Grafana + Logs/Metrics/Traces
free hobby tierPer-app observability. Dashboards, alerts, exploration — included.
Real numbers, in EUR
Predictable monthly pricing. Free hobby tiers on the things worth trying. No hidden egress, no enterprise paywall on the features you actually need.
A small always-on app. Side projects, internal tools, demos.
- Always-on small pod
- Single instance, single DC
- Perfect for prototypes and weekend builds
A serious app at startup scale. Real production traffic.
- 1 vCPU, 2 GB memory
- Scale to 2+ replicas for multi-DC HA
- The right baseline for production
More headroom — heavier traffic, memory-bound workers, single-replica heavy lifters.
- 4–16 vCPU, 8–32 GB memory
- Scale to 2+ replicas for multi-DC HA
- Room for in-memory caches and image processing
Every tier — including Hobby — gets the build pipeline, managed *.watasuhost.com + TLS, streaming logs, GitHub auto-deploy, custom domains, free hobby tiers on observability, and any add-on you attach. PostgreSQL from €3, Valkey from €1, ClickHouse, Redpanda, object storage — all available regardless of pod size.
Run things most PaaS won't
Watasu's process naming contract isn't just for web and worker. Two suffixes unlock workloads other platforms either don't support or hide behind enterprise plans.
Microservices
*-tcp
Name a process api-tcp or
grpc-tcp and it gets a private TCP endpoint
reachable only by apps you explicitly trust. Service-to-service traffic without VPCs, service mesh,
or one-more-cert-rotation-script.
- Private internal gRPC, RPC, raw TCP
- Explicit per-app trust grants
- Same Procfile shape as a regular process
WebRTC, voice, SFUs
*-rtc
Name a process sfu-rtc and Watasu
provisions a dedicated TURN gateway, allocates a public UDP port, gives every replica a stable hostname,
and injects TURN_* as env vars. ICE done.
- Per-process TURN, not a shared cluster bottleneck
- Bring your own SFU — mediasoup, Pion, anything
- Voice agents and real-time apps without infra weeks
Ship something today.
Top up, push code, watch it run. The whole loop is faster than scrolling back to the top of this page.