Activepieces is an MIT-licensed workflow orchestration engine that runs on your infrastructure. The YC S22 project attracted 231 upvotes on Hacker News because it solves a specific problem: teams building agent orchestration need control over execution environments, data residency, and integration boundaries without paying per-execution pricing or accepting vendor lock-in.
This is not a Zapier clone. It is a self-hosted workflow engine that exposes the primitives you need to build durable automation infrastructure. The architecture decisions matter if you are running agent workflows that span hours, call third-party APIs with rate limits, or need to replay failed steps without losing state.
Execution Model
Activepieces uses a queue-based execution model with persistent state. When a workflow triggers (via webhook, schedule, or external event), the engine:
- Serializes the workflow definition into a directed acyclic graph of steps
- Enqueues each step as a discrete job with input context
- Executes steps in dependency order, writing output to a state store
- Checkpoints progress after each step completes
This means long-running workflows survive process restarts. If a step fails, the engine can retry from the last checkpoint without re-executing upstream steps. The state store is PostgreSQL by default, so you get ACID guarantees and can query execution history with SQL.
The trade-off: you cannot run arbitrary long-lived processes inside a step. Each step must complete within a timeout window (configurable, defaults to 5 minutes). For agent workflows that need to wait on external events, you model the wait as a separate trigger rather than blocking inside a step.
Integration Sandboxing
Third-party integrations run in isolated Node.js processes, not containers or WASM sandboxes. Each integration is an npm package that exports a standard interface:
export const slackSendMessage = {
name: 'send_message',
displayName: 'Send Message',
props: {
channel: Property.ShortText({ required: true }),
text: Property.LongText({ required: true }),
},
async run(context) {
const { channel, text } = context.propsValue;
const token = context.auth.access_token;
return await fetch('https://slack.com/api/chat.postMessage', {
method: 'POST',
headers: { 'Authorization': `Bearer ${token}` },
body: JSON.stringify({ channel, text }),
});
},
};
The engine spawns a child process per integration execution, passes serialized context via stdin, and reads the result from stdout. This provides process-level isolation without the overhead of container orchestration. The downside: a malicious integration can still access the host filesystem and network. If you need stronger isolation, you must run the entire Activepieces instance inside a container with restricted capabilities.
For agent orchestration, this means you can write custom tools as Activepieces integrations and trust that a crash in one tool will not take down the entire workflow. You cannot trust that a tool will not exfiltrate data or make unauthorized network calls.
Queue and Retry Primitives
The execution queue is backed by BullMQ, a Redis-based job queue with built-in retry and rate-limiting. Each workflow step becomes a BullMQ job with:
- Exponential backoff retry policy (configurable max attempts)
- Rate limiting per integration (respects API quotas)
- Priority scheduling (manual runs jump the queue)
- Delayed execution (for scheduled triggers)
This is critical for agent workflows that call rate-limited APIs. You can configure per-integration concurrency limits and the engine will automatically throttle execution. If an API returns a 429, the job goes back in the queue with a delay calculated from the Retry-After header.
The observability story: BullMQ exposes job state (waiting, active, completed, failed) and you can query it via Redis. Activepieces adds a web UI that shows execution logs, step inputs/outputs, and retry history. No distributed tracing or OpenTelemetry integration yet, so correlating failures across multiple workflows requires custom instrumentation.
Deployment Shape
Activepieces ships as a Docker Compose stack with three services:
- API server: REST API for workflow CRUD, handles webhook ingress
- Worker: Pulls jobs from the queue, executes steps, writes results
- UI: React app served statically, talks to API server
You can scale workers horizontally. Each worker polls the same Redis queue, so adding capacity is a matter of increasing replica count. The API server is stateless and can also scale horizontally behind a load balancer.
For production deployments, you need:
- PostgreSQL with enough IOPS for state writes (every step completion is a transaction)
- Redis with persistence enabled (AOF or RDB) to survive queue loss
- Object storage for workflow artifacts (file uploads, large payloads)
- Reverse proxy with TLS termination for webhook endpoints
The missing piece: no built-in multi-tenancy. If you are building a SaaS product on top of Activepieces, you must implement tenant isolation yourself (separate databases, namespaced queues, or row-level security in PostgreSQL).
Comparison with Durable Execution Engines
| Feature | Activepieces | Temporal | Prefect |
|---|---|---|---|
| State model | Checkpointed steps | Event sourcing | Task results |
| Isolation | Process per integration | Workflow per process | Task per process |
| Retry semantics | Per-step exponential backoff | Workflow-level replay | Task-level retry |
| Observability | Logs + step history | Distributed traces | Flow run UI |
| Deployment | Docker Compose | Kubernetes required | Hybrid (cloud + agent) |
| License | MIT | MIT | Apache 2.0 |
Activepieces is simpler to deploy but less durable than Temporal. Temporal can replay an entire workflow from event history if state is corrupted. Activepieces checkpoints after each step, so corruption means you lose progress since the last checkpoint. Prefect sits in the middle: task-level retries with a centralized orchestrator, but no full workflow replay.
For agent orchestration, the choice depends on failure tolerance. If your agents call expensive LLM APIs and you cannot afford to re-execute, use Temporal. If your workflows are short (under 10 steps) and idempotent, Activepieces is easier to operate.
Failure Modes
Watch for these failure patterns:
- Queue backlog: If workers cannot keep up with job creation, the queue grows unbounded. Redis will eventually run out of memory. Set max queue size and implement backpressure at the API layer.
- Poison pills: A step that always fails will retry until max attempts, then move to a dead letter queue. You must monitor the DLQ and manually intervene.
- State bloat: Every step execution writes to PostgreSQL. High-frequency workflows (polling every second) will generate gigabytes of state per day. Implement retention policies and archive old executions.
- Integration timeouts: If an integration hangs, the worker process hangs. BullMQ will eventually mark the job as stalled, but the worker process remains blocked. Use process-level timeouts and health checks.
Technical Verdict
Use Activepieces when you need self-hosted workflow orchestration with minimal operational overhead. It fits teams building agent infrastructure who want to avoid per-execution pricing, need data residency guarantees, or require the ability to fork and modify the orchestration engine.
Avoid it if you need strong multi-tenancy (build your own isolation layer), distributed tracing (integrate OpenTelemetry yourself), or workflow replay from arbitrary points in history (use Temporal instead).
The MIT license and simple deployment model make it a good foundation for custom agent orchestration. The lack of container-based sandboxing and built-in observability means you will need to add those layers yourself for production use.
Source Links
- Hacker News discussion (231 points, 62 comments)
- Activepieces GitHub repository
- Official documentation