Automatisch

Automatisch is an open-source, no-code workflow automation platform that enables teams to connect popular services—Slack, GitHub, Google Sheets, Notion, Stripe, and 85 more—while keeping every byte of data within their own infrastructure. Unlike cloud-only competitors, every trigger and action executes inside your own Docker containers, so GDPR compliance and data sovereignty are built in rather than bolted on.

Built as a monorepo with an Express.js backend and a React/Material UI frontend, Automatisch follows the familiar trigger-then-action model: pick a trigger from one of the 90+ supported apps, chain as many action steps as needed, and deploy. The engine resolves each flow through a dedicated BullMQ queue backed by Redis, processing triggers either on a schedule, via inbound webhooks, or through polling.

The platform ships in two tiers. The Community Edition is fully AGPL-3.0 licensed and covers the core automation engine, OAuth connection management, execution history, and the visual flow editor. The Enterprise Edition adds AI agents (backed by LangChain with Anthropic and OpenAI model support), MCP server exposure, SAML SSO, role-based access control, form builders, and multi-tenant billing—all behind a commercial license that governs the .ee. files in the codebase.

With over 13,800 GitHub stars, a 122-migration Knex schema, and Vitest test coverage exceeding 94% statement coverage, Automatisch is production-grade for self-hosters who need Zapier-like power without the cloud dependency.

What You Get

• Visual flow editor — a drag-and-connect canvas built on React Flow where you assemble triggers and actions step by step without writing code
• 90+ pre-built integrations — apps spanning communication (Slack, Discord, Gmail, Telegram), project management (Trello, Asana, Monday, Notion, ClickUp), developer tools (GitHub, GitLab, Gitea), and CRM (HubSpot, Salesforce, Pipedrive)
• Execution history and debugging — every run is logged with per-step input/output data, making it easy to diagnose failures and re-test flows interactively
• Built-in scheduler and webhook triggers — fire flows on a cron schedule, respond to inbound webhooks from external services, or poll APIs at configurable intervals
• Code step — drop a JavaScript sandbox powered by isolated-vm directly into any flow to handle transformations that no pre-built action covers
• Docker Compose single-command deployment — spin up the full stack (web, worker, PostgreSQL, Redis) with one docker compose up and a handful of environment variables
• AI agents (Enterprise) — build LangChain-powered agents backed by Claude or GPT-4o that can call any Automatisch action as a tool and be triggered from workflows
• MCP server exposure (Enterprise) — expose flows as Model Context Protocol tools so external AI clients can invoke Automatisch automations directly

Common Use Cases

• GDPR-compliant marketing automation — a European SaaS company routes new Typeform signups through Automatisch to create HubSpot contacts and send welcome emails via SMTP, keeping all PII on company servers
• DevOps incident routing — engineering teams pipe GitHub webhook events through filter and notification steps to Slack channels without execution data touching a third-party cloud
• E-commerce order processing — Stripe payment events trigger a sequence that logs the sale to Google Sheets, sends a receipt via Gmail, and updates a Notion order database
• Content syndication pipeline — a media company polls an RSS feed every hour, filters new articles with the built-in Filter step, and cross-posts to WordPress, Discord, and Mailchimp automatically
• AI-assisted customer support triage (Enterprise) — an inbound webhook from a helpdesk fires a LangChain agent that classifies the ticket, looks up the customer in Salesforce, and posts a draft reply to Slack
• Internal data pipeline between self-hosted tools — teams running Gitea, Freescout, and Invoice Ninja link them through Automatisch flows, building integrations that would otherwise require custom code

Under The Hood

Architecture Automatisch separates concerns cleanly across three runtime boundaries: an Express.js HTTP layer that handles API requests and serves the React SPA, a BullMQ worker process that consumes jobs from Redis queues, and a PostgreSQL database managed through Objection.js on top of Knex. Flow execution follows a clear pipeline—the engine builds a flow context from the database, fetches initial trigger data, reverses it into chronological order, and iterates through action steps via a dedicated iterator function. Each step is processed by composing a global variable context that carries flow state, credentials, and computed parameters into the integration’s run method. The dual-queue design (a main flow queue and a separate email queue) decouples fast API responses from slow background processing, and an event-driven pause/resume mechanism supports flows that need to wait for external callbacks. The .ee. file split enforces the license boundary at the filesystem level, keeping Community and Enterprise code co-located without intermingling, sharing a single migration chain and test runner.

Tech Stack The backend runs on Node.js with Express 4.x and ESM modules throughout; Objection.js with Knex handles ORM and migrations against PostgreSQL 14+. BullMQ with Redis powers the job queue, and the worker process is a standalone Node.js binary that consumes the same queue. Authentication combines Passport.js (local, OAuth 2.0, SAML) with JWT access tokens and bcrypt-hashed passwords. The isolated JavaScript code step uses the isolated-vm package to sandbox user code in a separate V8 isolate. The Enterprise AI layer is built on LangChain with support for Anthropic and OpenAI models, and MCP server support ships via the official MCP SDK. The frontend is React 18 with Material UI v5, React Hook Form, TanStack Query for server state, and React Flow for the visual editor. The project is structured as a pnpm monorepo with separate backend, web, docs, and e2e-tests packages.

Code Quality The backend has a comprehensive Vitest test suite with over 240 test files covering models, controllers, serializers, helpers, and the execution engine, with coverage thresholds enforced at more than 94% statements, 97% branches, and 98% functions. Two distinct Vitest project configurations run in parallel—one for standard unit and integration tests, and one for engine integration tests running single-threaded to avoid race conditions in flow execution. Error handling is explicit: custom error classes (HttpError, EarlyExitError, AlreadyProcessedError) are caught and mapped to structured response objects rather than swallowed. Schema validation uses Objection’s AjvValidator with ajv-formats on every model. ESLint with Prettier enforces consistent style, and CI runs via GitHub Actions with coverage enforcement on pull requests.

What Makes It Unique Automatisch’s most distinctive technical decision is its .ee. dual-license file split: Enterprise features (AI agents, MCP, SAML, forms, role mappings, subscriptions) live in the same repository as the AGPL Community code, sharing all infrastructure and models but gated by filename convention and a runtime license check. This means both tiers share a single migration chain, test runner, and deployment artifact, reducing fork divergence at the cost of a more complex licensing model. The addition of LangChain-powered AI agents as first-class automation steps—where any Automatisch action can become a tool callable by Claude or GPT-4o—and the MCP server that lets external AI clients trigger flows positions Automatisch at the intersection of traditional iPaaS automation and the emerging AI agent ecosystem, a combination not yet common in open-source alternatives to Zapier.

Self-Hosting

Automatisch uses a dual-license model. The Community Edition is released under the GNU Affero General Public License v3 (AGPL-3.0), which means you can use, modify, and self-host it freely—including commercially—as long as any modifications you distribute or expose as a network service are also released under AGPL-3.0. This copyleft requirement applies to your changes to Automatisch’s source code, not to the flows and automations you build with it. The Enterprise Edition covers all files named with .ee. in the repository and requires a paid per-seat subscription from AB Software GmbH for production use; you may use .ee. files for development and testing without a license.

Running Automatisch yourself means operating a four-container stack: the main Express.js web process, a BullMQ worker process, PostgreSQL 14+ for persistent flow and execution data, and Redis for the job queue. A Docker Compose file is provided and is the recommended starting point. You are responsible for database backups, Redis persistence configuration, TLS termination via a reverse proxy, and secret rotation for the three required environment variables—ENCRYPTION_KEY, WEBHOOK_SECRET_KEY, and APP_SECRET_KEY. If ENCRYPTION_KEY changes, all stored OAuth credentials become unreadable, so safe key management is critical. Scaling means running additional worker containers and a load-balanced main tier; there is no built-in horizontal scaling wizard.

Compared to a managed SaaS alternative like Zapier or Make, self-hosting means you own the reliability story entirely—no managed uptime SLA, no automatic version upgrades, and no first-party support contract unless you hold an Enterprise license. Enterprise subscribers gain access to AI agents, MCP server integration, SAML SSO, granular RBAC, form builders, and usage analytics, plus commercial support channels. Community users have GitHub Issues and the Discord server. For teams that have the operational maturity to run a small Docker stack and prioritize data control over managed convenience, Automatisch CE delivers substantial value at zero licensing cost.