Skip to main content

Documentation Index

Fetch the complete documentation index at: https://www.activepieces.com/docs/llms.txt

Use this file to discover all available pages before exploring further.

This page focuses on describing the main components of Activepieces and focus mainly on workflow executions.

​
Components

Architecture Activepieces:
  • App: The main application that organizes everything from APIs to scheduled jobs.
  • Worker: Polls for new jobs, allocates a sandbox from the pool, executes the flows with the engine inside the sandbox, and sends results back to the app.
  • Sandbox: An isolated execution environment that manages process lifecycle, resource limits, and communication with the engine via WebSocket.
  • Engine: TypeScript code that parses flow JSON and executes it. It is compiled into a single JS file and runs inside the sandbox.
  • UI: Frontend written in React.
Third Party:
  • Postgres: The main database for Activepieces.
  • Redis: This is used to power the queue using BullMQ.

​
Reliability & Scalability

Postgres and Redis availability is outside the scope of this documentation, as many cloud providers already implement best practices to ensure their availability.
  • Webhooks: All webhooks are sent to the Activepieces app, which performs basic validation and adds them to the queue. In case of a spike, webhooks will be added to the queue.
  • Polling Trigger: All recurring jobs are added to Redis. In case of a failure, the missed jobs will be executed again.
  • Flow Execution: Workers poll jobs from the queue. In the event of a spike, the flow execution will still work but may be delayed depending on the size of the spike.
To scale Activepieces, you typically need to increase the replicas of either workers, the app, or the Postgres database. A small Redis instance is sufficient as it can handle thousands of jobs per second and rarely acts as a bottleneck.

​
Repository Structure

The repository is structured as a monorepo using Turbo, with TypeScript as the primary language. It is divided into several packages: 
.
├── packages
│   ├── web
│   ├── server
│   │   ├── api
│   │   ├── worker
│   │   ├── engine
│   │   ├── sandbox
│   │   └── common
│   ├── ee
│   ├── pieces
│   └── shared
  • web: This package contains the user interface, implemented using the React framework.
  • api: This package contains the main application written in TypeScript with the Fastify framework.
  • worker: This package contains the logic of accepting flow jobs and executing them using the engine.
  • server-sandbox: This package contains the sandbox execution environment, including process isolation, pool management, and WebSocket communication between the worker and engine.
  • common: This package contains the shared logic between worker and app.
  • engine: This package contains the logic for flow execution within the sandbox. Located under server/engine.
  • pieces: This package contains the implementation of triggers and actions for third-party apps.
  • shared: This package contains shared data models and helper functions used by the other packages.
  • ee: This package contains features that are only available in the paid edition.