Skip to content

What you actually run, if you run it yourself.

The whole delivery path is AGPL-3.0: ingress, subscribers and topics, orchestration, durable runs, delivery. Self-hosting it means three processes and one database, and none of the proprietary part, because the proprietary part is only what makes Palumb multi-tenant, and you are one tenant.

This page is the operational answer: what runs, what it costs to keep alive, and what becomes yours the moment you take it. If you are after the licences and the boundary between open and proprietary, that is the open source page.

Last updated:

What runs

Three services, on one machine if you like. No orchestrator to learn and no second datastore: the durable engine keeps its journal in the same Postgres you are already backing up.

The application
Ingress, subscribers and topics, orchestration, the delivery path to your provider.
Rs
Restate
The durable runs: waits, timers, retries and the journal that survives a restart.
PostgreSQL
Everything that has to still be there tomorrow: one database, no second store.
docker-compose.yml 
services:
  app:
    image: palumb/palumb
  restate:
    image: restatedev/restate
  postgres:
    image: postgres:17

the whole of it, on your machine

Services
3
Our code
AGPL-3.0

The service count is structural. The two hardware numbers are calculated from the parts rather than measured, and we will replace them with measured ones.

You bring your own sending provider, exactly as you would with the managed service: Palumb has no sending capacity of its own, and the credentials are the tenant's (yours) encrypted at rest. How this compares to the other self-hostable option is a separate page, with the file and the version it was counted from.

What becomes yours

The part nobody puts on a self-hosting page, because it does not help anyone sell anything. It is the whole decision, so here it is.

  • Upgrades

    And reading the release notes before them.

  • Backups

    Of Postgres, and at least one restore you have actually tried.

  • The secrets

    The key that encrypts each tenant's provider credentials, and its rotation.

  • TLS and the domain

    Including the reachability of the endpoint Palumb calls.

  • Watching it

    Something has to notice at three in the morning, and that something is you.

  • Your sending reputation

    The same as with us, because the credentials are yours either way.

None of it is hard. All of it is recurring, and that is the difference between a stack you can install in an afternoon and a stack you have adopted.

We would not self-host it either

Making the exit uncomfortable is lock-in wearing a different coat, so we document it properly and we will not pretend it is difficult. The honest argument for letting us run it is the list above: maintaining anything has a running cost, and that cost rarely pays for a team whose business is not notifications. It is the same trade we make as buyers: our own error tracker ships as a self-hostable product, and we pay for the hosted one.

And the decision is not final in either direction. Same code both ways, same SDK, same workflows in your repository: moving between them is a deployment decision, not a migration.

Everyone who joins gets in, and it costs nothing. Your invite goes out when the beta opens.

Join the beta