Deploying Automatisch

Automatisch is a powerful, open-source business automation tool that serves as a self-hosted alternative to Zapier and Make (Integromat). Connect over 200+ services like Twitter, Slack, Google Sheets, Discord, and more to automate your workflows without writing any code.

Unlike cloud-based automation platforms, Automatisch lets you keep all your data on your own servers—essential for businesses handling sensitive information, GDPR compliance, and industries like healthcare and finance where data sovereignty is paramount.

Self-Hosted Privacy

Keep your data on your own servers with complete control

200+ Integrations

Connect popular services like Slack, Twitter, Google, and more

No-Code Builder

Build complex workflows with an intuitive visual editor

Open Source

AGPL-3.0 licensed with an active community

Key Features

Automatisch provides a comprehensive automation platform:

Feature	Description
Visual Flow Builder	Drag-and-drop interface to create workflows
200+ Apps	Integrations with popular services and APIs
Scheduled Runs	Workflows execute at configurable intervals
Webhook Triggers	Instant automation based on webhook events
Multi-Step Flows	Chain multiple actions in sequence
Data Mapping	Transform and map data between services
Error Handling	Built-in retry and error management
Team Collaboration	Multi-user support for teams

Why Automatisch?

Feature	Automatisch	Cloud Alternatives
Data Location	Your servers	Third-party cloud
Pricing	Free (self-hosted)	Per-task billing
Privacy	Complete control	Limited visibility
Vendor Lock-in	None	High switching costs
Customization	Full source access	Limited to features
GDPR Compliance	Built-in	Complex setup

Architecture Overview

Automatisch runs as a multi-service application:

Component	Purpose
Main Service	Web UI and API server
Worker Service	Background job processing
PostgreSQL	Primary database
Redis	Job queue and caching

Note

For production deployments, you’ll need external PostgreSQL and Redis instances. Klutch.sh can deploy these separately, or you can use managed database services.

Prerequisites

Before deploying Automatisch on Klutch.sh, ensure you have:

• A Klutch.sh account with an active project
• A GitHub repository for your deployment
• A PostgreSQL database (can be deployed on Klutch.sh)
• A Redis instance (can be deployed on Klutch.sh)

Project Structure

Set up your Automatisch deployment repository:

• Directoryautomatisch/

  • Dockerfile
  • docker-compose.yml (local development only)
  • .env.example
  • README.md

Deployment Configuration

Dockerfile for Main Service

Create a Dockerfile for the main Automatisch service:

Dockerfile

FROM ghcr.io/automatisch/automatisch:latest

# Set production environment
ENV APP_ENV=production
ENV PORT=3000

# Expose the application port
EXPOSE 3000

# The entrypoint is already configured in the base image

Dockerfile for Worker Service

Create a separate repository for the worker service with this Dockerfile:

Dockerfile

FROM ghcr.io/automatisch/automatisch:latest

# Set production environment and worker mode
ENV APP_ENV=production
ENV WORKER=true

# Workers don't need to expose ports

Environment Variables

Automatisch requires several environment variables for proper operation:

Variable	Description	Required
HOST	HTTP host (your domain)	Yes
PROTOCOL	http or https	Yes
PORT	HTTP port (default: 3000)	Yes
APP_ENV	Environment (production)	Yes
ENCRYPTION_KEY	Key for encrypting credentials	Yes
WEBHOOK_SECRET_KEY	Key for verifying webhooks	Yes
APP_SECRET_KEY	Session authentication key	Yes
POSTGRES_HOST	PostgreSQL host	Yes
POSTGRES_PORT	PostgreSQL port (default: 5432)	Yes
POSTGRES_DATABASE	Database name	Yes
POSTGRES_USERNAME	Database username	Yes
POSTGRES_PASSWORD	Database password	Yes
REDIS_HOST	Redis host	Yes
REDIS_PORT	Redis port (default: 6379)	Yes
REDIS_PASSWORD	Redis password (if required)	No

Critical Security Warning

Never change ENCRYPTION_KEY or WEBHOOK_SECRET_KEY after initial setup! These keys encrypt your third-party service credentials. Changing them will break all existing connections and flows.

Generating Secure Keys

Generate secure keys for your deployment:

# Generate ENCRYPTION_KEY
openssl rand -base64 36

# Generate WEBHOOK_SECRET_KEY
openssl rand -base64 36

# Generate APP_SECRET_KEY
openssl rand -base64 36

Optional Environment Variables

Variable	Description	Default
WEB_APP_URL	Override public URL	Auto-detected
WEBHOOK_URL	Override webhook URL	Auto-detected
LOG_LEVEL	Logging level (error, warn, info, debug)	info
TELEMETRY_ENABLED	Enable usage telemetry	true
POSTGRES_ENABLE_SSL	Enable PostgreSQL SSL	false
REDIS_TLS	Enable Redis TLS	false

SMTP Configuration (Optional)

For email notifications, configure SMTP:

Variable	Description
SMTP_HOST	SMTP server hostname
SMTP_PORT	SMTP port (default: 587)
SMTP_SECURE	Enable SSL (true/false)
SMTP_USER	SMTP username
SMTP_PASSWORD	SMTP password
FROM_EMAIL	Sender email address

Local Development with Docker Compose

For local development and testing:

docker-compose.yml

services:
  main:
    image: ghcr.io/automatisch/automatisch:latest
    ports:
      - "3000:3000"
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    environment:
      - HOST=localhost
      - PROTOCOL=http
      - PORT=3000
      - APP_ENV=production
      - REDIS_HOST=redis
      - POSTGRES_HOST=postgres
      - POSTGRES_DATABASE=automatisch
      - POSTGRES_USERNAME=automatisch_user
      - POSTGRES_PASSWORD=automatisch_password
      - ENCRYPTION_KEY=${'{'}ENCRYPTION_KEY{'}'}
      - WEBHOOK_SECRET_KEY=${'{'}WEBHOOK_SECRET_KEY{'}'}
      - APP_SECRET_KEY=${'{'}APP_SECRET_KEY{'}'}
    volumes:
      - automatisch_storage:/automatisch/storage

  worker:
    image: ghcr.io/automatisch/automatisch:latest
    depends_on:
      - postgres
      - redis
    environment:
      - WORKER=true
      - APP_ENV=production
      - REDIS_HOST=redis
      - POSTGRES_HOST=postgres
      - POSTGRES_DATABASE=automatisch
      - POSTGRES_USERNAME=automatisch_user
      - POSTGRES_PASSWORD=automatisch_password
      - ENCRYPTION_KEY=${'{'}ENCRYPTION_KEY{'}'}
      - WEBHOOK_SECRET_KEY=${'{'}WEBHOOK_SECRET_KEY{'}'}
      - APP_SECRET_KEY=${'{'}APP_SECRET_KEY{'}'}
    volumes:
      - automatisch_storage:/automatisch/storage

  postgres:
    image: postgres:16-alpine
    environment:
      - POSTGRES_DB=automatisch
      - POSTGRES_USER=automatisch_user
      - POSTGRES_PASSWORD=automatisch_password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U automatisch_user -d automatisch"]
      interval: 5s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data

volumes:
  automatisch_storage:
  postgres_data:
  redis_data:

Create a .env.example file:

.env.example

# Generate these with: openssl rand -base64 36
ENCRYPTION_KEY=your-encryption-key-here
WEBHOOK_SECRET_KEY=your-webhook-secret-key-here
APP_SECRET_KEY=your-app-secret-key-here

Tip

Run docker compose up -d to start Automatisch locally. Access it at http://localhost:3000 with default credentials: user@automatisch.io / sample

Deploying to Klutch.sh

Automatisch requires multiple services. Deploy them in this order:

Step 1: Deploy PostgreSQL Database

1. Create a PostgreSQL app on Klutch.sh

   1. Navigate to your Klutch.sh dashboard at klutch.sh/app
   2. Select your project or create a new one
   3. Click Create App and connect a repository with a PostgreSQL Dockerfile

   See our PostgreSQL deployment guide for detailed instructions.

2. Note your database connection details

   1. Record the internal hostname and port
   2. Note your configured username and password

Step 2: Deploy Redis

1. Create a Redis app on Klutch.sh

   1. Create another app in your project for Redis
   2. Connect a repository with a Redis Dockerfile

   See our Redis deployment guide for detailed instructions.

2. Note your Redis connection details

   1. Record the internal hostname
   2. Note the port (default: 6379)

Step 3: Deploy Automatisch Main Service

1. Push your repository to GitHub

   1. Create a new repository with the main service Dockerfile

   git init
   git add .
   git commit -m "Initial Automatisch configuration"
   git remote add origin https://github.com/yourusername/automatisch.git
   git push -u origin main

2. Create a new app on Klutch.sh

   1. Navigate to your Klutch.sh dashboard at klutch.sh/app
   2. Select your project
   3. Click Create App and connect your GitHub repository
   4. Klutch.sh will automatically detect your Dockerfile

3. Configure environment variables

   1. In your app settings, add the following environment variables

   Variable	Value
   HOST	your-app.klutch.sh
   PROTOCOL	https
   PORT	3000
   APP_ENV	production
   ENCRYPTION_KEY	Your generated key
   WEBHOOK_SECRET_KEY	Your generated key
   APP_SECRET_KEY	Your generated key
   POSTGRES_HOST	Your PostgreSQL internal hostname
   POSTGRES_PORT	5432
   POSTGRES_DATABASE	automatisch
   POSTGRES_USERNAME	Your PostgreSQL username
   POSTGRES_PASSWORD	Your PostgreSQL password
   REDIS_HOST	Your Redis internal hostname
   REDIS_PORT	6379

4. Configure the internal port

   1. Set the internal port to 3000
   2. Select HTTP as the traffic type

5. Set up persistent storage

   1. Add a persistent volume for file storage

   Mount Path	Size
   /automatisch/storage	10 GB

6. Deploy your application

   1. Click Deploy to build and launch Automatisch
   2. Monitor the build logs for any issues
   3. Once deployed, your app will be available at https://your-app.klutch.sh

Step 4: Deploy Automatisch Worker Service

1. Create a separate repository for the worker

   1. Create a new GitHub repository with the worker Dockerfile

   Dockerfile

   FROM ghcr.io/automatisch/automatisch:latest
   
   ENV APP_ENV=production
   ENV WORKER=true

2. Create a new app on Klutch.sh

   1. Create another app in the same project for the worker
   2. Connect the worker GitHub repository

3. Configure environment variables

   1. Add the same database and Redis environment variables as the main service
   2. Add WORKER=true to enable worker mode

   Variable	Value
   WORKER	true
   APP_ENV	production
   ENCRYPTION_KEY	Same as main service
   WEBHOOK_SECRET_KEY	Same as main service
   APP_SECRET_KEY	Same as main service
   POSTGRES_HOST	Your PostgreSQL internal hostname
   POSTGRES_PORT	5432
   POSTGRES_DATABASE	automatisch
   POSTGRES_USERNAME	Your PostgreSQL username
   POSTGRES_PASSWORD	Your PostgreSQL password
   REDIS_HOST	Your Redis internal hostname
   REDIS_PORT	6379

   Caution

   The ENCRYPTION_KEY, WEBHOOK_SECRET_KEY, and APP_SECRET_KEY must be identical across main and worker services!

4. Set up persistent storage

   1. Add a persistent volume matching the main service

   Mount Path	Size
   /automatisch/storage	10 GB

5. Deploy the worker

   1. Click Deploy to launch the worker service
   2. The worker doesn’t expose any ports—it communicates via Redis

Initial Setup

After deployment, configure your Automatisch instance:

1. Access the web interface

   1. Visit https://your-app.klutch.sh
   2. Log in with the default credentials

   Field	Value
   Email	user@automatisch.io
   Password	sample

2. Change default credentials immediately

   1. Go to Settings → Profile
   2. Update your email address
   3. Change your password to a strong, unique password

   Security

   Change the default credentials immediately after first login! Anyone who knows the defaults can access your instance.

3. Configure your first integration

   1. Go to My Apps in the sidebar
   2. Click Add Connection
   3. Select a service and follow the OAuth or API key setup

Creating Your First Flow

Build a simple automation to test your deployment:

1. Create a new flow

   1. Click Flows in the sidebar
   2. Click Create Flow
   3. Give your flow a descriptive name

2. Add a trigger

   1. Click the trigger step
   2. Select an app (e.g., Schedule)
   3. Choose a trigger type (e.g., Every Hour)
   4. Configure the trigger settings

3. Add an action

   1. Click + to add a step
   2. Select an app (e.g., Slack)
   3. Choose an action (e.g., Send Message)
   4. Map data from the trigger to the action

4. Publish your flow

   1. Test your flow with the Test button
   2. If successful, click Publish
   3. Your flow is now active!

Available Integrations

Automatisch supports 200+ apps including:

Category	Apps
Communication	Slack, Discord, Telegram, Twilio
Social Media	Twitter, LinkedIn, Facebook
Productivity	Google Sheets, Notion, Airtable
CRM	HubSpot, Salesforce, Pipedrive
Development	GitHub, GitLab, Jira
Email	Gmail, Mailchimp, SendGrid
Storage	Google Drive, Dropbox, OneDrive
Payment	Stripe, PayPal, Square

See the complete list at Automatisch Available Apps.

Webhook Configuration

For instant triggers, configure webhooks:

1. Create a webhook trigger

   1. In your flow, select Webhook as the trigger app
   2. Choose Catch Raw Webhook or Catch Webhook
   3. Copy the generated webhook URL

2. Configure the external service

   1. Add the webhook URL to your external service
   2. The format will be: https://your-app.klutch.sh/webhooks/{'{'}flow-id{'}'}

Scaling Considerations

For high-volume automation:

Component	Recommendation
Workers	Deploy multiple worker instances
PostgreSQL	Use a managed database with backups
Redis	Use persistent Redis with adequate memory
Storage	Increase volume size for file-heavy workflows

Multiple Worker Deployment

Deploy additional workers by creating more worker apps with identical environment variables. Workers automatically distribute jobs via Redis.

Security Best Practices

Change Defaults

Update default credentials immediately after deployment

Use HTTPS

Klutch.sh provides automatic SSL certificates

Strong Keys

Use openssl rand -base64 36 for all secret keys

Database Security

Use strong passwords and enable SSL connections

Environment Variable Security

• Never commit secret keys to version control
• Use different keys for development and production
• Rotate APP_SECRET_KEY periodically (invalidates sessions)
• Never change ENCRYPTION_KEY after initial setup

Troubleshooting

Common issues and solutions:

Issue	Cause	Solution
Can’t connect to database	Wrong credentials	Verify PostgreSQL environment variables
Flows not executing	Worker not running	Check worker service is deployed and running
OAuth redirect fails	Wrong HOST/PROTOCOL	Ensure HOST and PROTOCOL match your URL
Webhooks not working	Wrong webhook URL	Verify WEBHOOK_URL or WEB_APP_URL
500 errors	Missing Redis	Verify Redis is running and accessible
Credentials broken	Changed ENCRYPTION_KEY	Restore original key or recreate connections

Checking Logs

Monitor your services through the Klutch.sh dashboard:

1. Navigate to your app
2. View deployment logs for startup issues
3. Check runtime logs for operational errors

Common Log Patterns

# Healthy startup
info: Starting Automatisch...
info: Connected to PostgreSQL
info: Connected to Redis
info: Server listening on port 3000

# Worker mode
info: Starting worker...
info: Processing jobs from Redis queue

Backup and Recovery

Database Backups

Regularly backup your PostgreSQL database:

• Use Klutch.sh’s backup features for PostgreSQL
• Schedule automated backups
• Test restores periodically

Critical Data

Always backup:

• PostgreSQL database (all flow definitions and execution data)
• Redis data (job queue state)
• /automatisch/storage volume (uploaded files)
• Your environment variables (especially keys)

Caution

If you lose ENCRYPTION_KEY, all stored credentials become unrecoverable. Store it securely in a password manager or secrets vault.

Additional Resources

• Official Automatisch Documentation
• Automatisch GitHub Repository
• Available Integrations
• Configuration Reference
• Automatisch Discord Community
• Automatisch on Twitter