---
title: "Deploy Automatisch"
description: "No-code visual workflow builder that connects your apps and automates tasks"
category: "Automation"
url: https://railway.com/deploy/run-automatisch
---

# Deploy Automatisch

No-code visual workflow builder that connects your apps and automates tasks

**[Deploy Automatisch on Railway](https://railway.com/template/run-automatisch)**

Machine-readable deploy manifest (JSON, validated by TemplateCI): https://railway.com/deploy/run-automatisch/manifest.json

- **Creator:** A3A
- **Category:** Automation

## Template content

### Postgres https://cdn.simpleicons.org/postgresql/4169E1.svg

- **Image:** ghcr.io/railwayapp-templates/postgres-ssl:18

### automatisch-worker https://automatisch.io/android-chrome-192x192.png

- **Source:** https://github.com/gridalpha/automatisch-railway
- **Health check:** /healthz

### automatisch https://automatisch.io/android-chrome-192x192.png

- **Source:** https://github.com/gridalpha/automatisch-railway
- **Health check:** /healthcheck
- **Public domain:** Yes

### mailpit https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/mailpit.svg

- **Image:** axllent/mailpit:latest
- **Health check:** /livez
- **Public domain:** Yes

### Redis https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/redis.svg

- **Image:** redis:8.2
- **Start command:** `/bin/sh -c "rm -rf $RAILWAY_VOLUME_MOUNT_PATH/lost+found/ && exec docker-entrypoint.sh redis-server --requirepass $REDIS_PASSWORD --save 60 1 --dir $RAILWAY_VOLUME_MOUNT_PATH"`

## Documentation

# Deploy and Host Automatisch on Railway

Automatisch is an open-source business automation tool — a self-hosted Zapier alternative that connects services like Slack, GitHub, Google Sheets, Telegram and Stripe into workflows you build visually, with no code. Pick a trigger, chain actions onto it, map data between steps, and publish. Teams self-host Automatisch when the data in those workflows cannot leave their own infrastructure — customer records, invoices, support tickets — which is why it turns up in healthcare, finance and GDPR-bound European companies. It is AGPL-licensed, so there is no per-task pricing and no lock-in.

This template runs Automatisch in the shape its own production docs describe, not one all-in-one container. `automatisch` serves the web UI, the REST API and the public webhook endpoint. `automatisch-worker` is a separate BullMQ worker that executes flows, polls triggers and sends mail, so a slow third-party API never blocks a page load. `Postgres` stores flows, encrypted credentials, execution history and the built-in datastore; `Redis` carries the job queues; `mailpit` captures password-reset and invitation mail so those flows work on the first deploy with no SMTP account. Only the app and the inbox get public URLs.

![Automatisch web and worker services beside Postgres, Redis and Mailpit](https://res.cloudinary.com/rroe4rtk/image/upload/v1788862895/automatisch-architecture.png)

## Getting Started with Automatisch on Railway

Set `ADMIN_EMAIL` and `ADMIN_PASSWORD` before deploying — they become your first administrator, created inside the container before the app accepts a request. The stock image instead seeds the well-known `user@automatisch.io` / `sample` login from Automatisch's README, so your instance never serves default credentials. Open the deployed URL, sign in, and you land on the Flows screen.

Click **Create flow**, choose an app for the trigger, then an event. **Webhook → Catch raw webhook** proves the deployment end to end with no third-party account: Automatisch gives you a webhook URL, you send it a JSON payload, and **Test & Continue** captures it as sample data. Add a second step — **Datastore → Set value** pairs well — and map a trigger field into it. Publish, send the webhook again, and open **Executions**: a successful run means the endpoint, the queue and the worker are all working.

To connect real services, open **My Apps** and add a connection with that provider's OAuth or API credentials; Automatisch encrypts them with your `ENCRYPTION_KEY`. Queue health lives at `/admin/queues`.

![Automatisch flow list showing a published webhook automation](https://res.cloudinary.com/rroe4rtk/image/upload/v1788862897/automatisch-flows-list.png)
![Flow editor with a webhook trigger and a datastore action](https://res.cloudinary.com/rroe4rtk/image/upload/v1788862898/automatisch-flow-editor.png)
![Execution detail showing the order payload stored in the datastore](https://res.cloudinary.com/rroe4rtk/image/upload/v1788862899/automatisch-execution-detail.png)

## About Hosting Automatisch

Automatisch is narrower than a general-purpose workflow engine: it connects service A to service B when something happens, with a UI a non-developer can drive. Self-host it when the workflows carry data you would rather not hand to a vendor, or when per-task pricing has become the dominant cost.

- Visual flow editor with a variable picker that maps data between steps
- Around 80 integrations, plus helpers: Formatter, Filter, Delay, HTTP Request, Datastore
- Incoming webhooks with a per-flow URL; instant or polled triggers
- Encrypted storage of every connected account's credentials
- Execution history with per-step input and output, so a failed run is debuggable
- Multi-user support with an admin role

The split matters before you scale. `automatisch` handles HTTP, enqueues work and runs migrations on boot; `automatisch-worker` consumes the queues and runs the flow steps. Both build from the same image and must stay on the same version, since they share one schema and queue format.

## Why Deploy Automatisch on Railway

Railway removes the compose file and the server:

- App, worker, Postgres, Redis and mail inbox provisioned together, already wired
- Private networking, with public URLs only where they are needed
- TLS and a domain on the app service out of the box
- Secrets generated at deploy time, not copied from a sample file
- Vertical scaling and worker replicas without touching a host

## Common Use Cases

- **Ops notifications:** post to Slack when a Stripe payment succeeds or a GitHub issue opens
- **Lightweight ETL:** catch an internal webhook, reshape it with Formatter, append a Google Sheets row
- **CRM and billing glue:** create a Pipedrive deal or an Invoice Ninja invoice from a form submission
- **Scheduled housekeeping:** a daily Scheduler flow that queries an API and files the result

## Dependencies for Automatisch

- `automatisch` and `automatisch-worker` — built from [gridalpha/automatisch-railway](https://github.com/gridalpha/automatisch-railway), a thin layer over `automatischio/automatisch:0.15.0`
- `Postgres` — `ghcr.io/railwayapp-templates/postgres-ssl:18`, the durable store for flows, credentials and executions
- `Redis` — `redis:8.2`, the BullMQ queue backend
- `mailpit` — `axllent/mailpit:latest`, an SMTP sink with a web inbox

### Environment Variables Reference

| Variable | Purpose |
|---|---|
| `ADMIN_EMAIL`, `ADMIN_PASSWORD` | The first administrator, created before the app serves |
| `ENCRYPTION_KEY` | Encrypts credentials for connected apps — changing it orphans existing connections |
| `API_URL`, `WEB_APP_URL`, `WEBHOOK_URL` | The public base URL every generated webhook URL is built from |
| `POSTGRES_*`, `REDIS_*` | Database and queue host, port and credentials |
| `WORKER` | Set to `true` on the worker service only |
| `SMTP_*`, `FROM_EMAIL` | Outbound mail; point these at a real relay to send outside the template |
| `ENABLE_BULLMQ_DASHBOARD` | Serves the queue dashboard at `/admin/queues` behind basic auth |
| `TELEMETRY_ENABLED` | Set to `false` here; upstream defaults it to `true` |

### Deployment Dependencies

- Source: [github.com/automatisch/automatisch](https://github.com/automatisch/automatisch)
- Image: [automatischio/automatisch](https://hub.docker.com/r/automatischio/automatisch)
- Docs: [automatisch.io/docs](https://automatisch.io/docs)
- Runtime: Node.js 22 on Alpine, PostgreSQL 18, Redis 8

## Hardware Requirements for Self-Hosting Automatisch

| Resource | Minimum | Recommended |
|---|---|---|
| CPU | 1 vCPU | 2 vCPU |
| RAM | 1 GB across app and worker | 2 GB or more |
| Storage | 1 GB Postgres | 5 GB, growing with history |
| Runtime | Node.js 22, PostgreSQL 14+, Redis 6+ | PostgreSQL 18, Redis 8 |

Execution history is what grows, so watch the database volume rather than the app containers.

## Self-Hosting Automatisch with Docker

The project's quick start clones the repository and uses its Compose file:

```
git clone https://github.com/automatisch/automatisch.git
cd automatisch
docker compose up
```

That gives you the default login `user@automatisch.io` / `sample`, which you must change immediately. To run the image directly, supply the database, queue and key variables yourself. This starts the web role:

```
docker run -d --name automatisch -p 3000:3000 \
  -e APP_ENV=production \
  -e POSTGRES_HOST=postgres -e POSTGRES_DATABASE=automatisch \
  -e POSTGRES_USERNAME=automatisch -e POSTGRES_PASSWORD=changeme \
  -e REDIS_HOST=redis \
  -e ENCRYPTION_KEY=$(openssl rand -base64 36) \
  -e WEBHOOK_SECRET_KEY=$(openssl rand -base64 36) \
  automatischio/automatisch:0.15.0
```

Add a second container with `-e WORKER=true` and no published port for the worker. Keep the keys identical across both and stable across restarts — regenerating `ENCRYPTION_KEY` orphans every stored connection.

## How Much Does Automatisch Cost to Self-Host?

Automatisch Community Edition is free and open source under AGPL-3.0, with no task limits and no seat count. Files named `.ee.` fall under a separate Enterprise licence and unlock extras such as SAML single sign-on behind a `LICENSE_KEY`; nothing here needs one. On Railway you pay for compute and storage only.

## FAQ

**What is Automatisch?**

An open-source workflow automation tool that connects services such as Slack, GitHub, Stripe and Google Sheets, letting you build automations visually instead of writing integration code. A self-hosted Zapier alternative.

**What does this Railway template deploy?**

Five services: the Automatisch web app, a separate queue worker, PostgreSQL, Redis and a Mailpit inbox. Only the app and the inbox get public URLs.

**Why does the template include Redis and a separate worker service?**

Every flow runs through BullMQ job queues held in Redis, and the worker process consumes them. Without both, published flows would never execute — triggers would fire and nothing would happen.

**Do I need an SMTP server to run self-hosted Automatisch?**

No. Mailpit captures outgoing mail, so password resets and invitations are visible in its web inbox immediately. To deliver mail for real, point the `SMTP_*` variables at your own relay.

**Can I scale Automatisch to handle more executions?**

Yes. The worker is stateless and coordinates through Redis, so adding replicas increases throughput. Keep app and worker on the same image version, since they share one schema.

**Is Automatisch still maintained?**

The current release is 0.15.0 and upstream commit activity slowed noticeably in early 2026. The community edition is stable and self-contained, so it stays a reasonable choice for straightforward integrations; if you need a large catalogue under active development, compare it with n8n.


## Similar templates

- [N8N Main + Worker](https://railway.com/deploy/n8n-main-worker) — Deploy and Host N8N with Inactive worker.
- [Evolution API with n8n](https://railway.com/deploy/evolution-api-with-n8n) — Automate WhatsApp workflows with Evolution API, n8n, and Postgres.
- [Postgres Backup](https://railway.com/deploy/postgres-s3-backups) — Cron-based PostgreSQL backup to bucket storage

Open this page in a browser: https://railway.com/deploy/run-automatisch