Make vs Activepieces: which fits your renewal, residency rules and network
If your Make renewal is driven by rising credit consumption, or your security team needs automations to run inside your own network, Activepieces is the self-hosted option to evaluate first. If your main concern is that Make's US and EU zones do not meet your residency rules, but you are comfortable with a hosted service in one of those zones, Make may still be the right fit for that workload. Make has no self-hosted edition: its scenarios run in the hosted zones it offers, so an on-premises or air-gapped requirement cannot be met by staying on Make alone. The decision turns on three questions. First, where must the runtime and the data sit: in your cloud account, your data center or a zone chosen by a vendor? Second, do you need SCIM, audit logs or Git Sync? According to the Activepieces pricing page, those controls are listed only for the custom-priced Ultimate plan, while the self-hosted Community Edition is the automation core on its own. Third, how many scenarios and AI steps do you run each month, and how many of them depend on credits?
Answer the third question with your own data before you request a quote. Export your scenarios and count modules, routers, iterators and AI steps per scenario, then estimate credit use from your Make usage reports (confirm the current credit rules with Make, since they can change). Activepieces' Free plan lists 1,000 credits a month and up to 5 users, and the Community Edition removes the credit meter when you run it yourself, but the operations work of hosting, patching and backing up PostgreSQL and Redis moves to your team or your implementation partner. Ask the Activepieces sales team or your partner which Ultimate features you actually need, because paying for SCIM or audit logs you do not use is avoidable cost. Confirm the Community Edition's license terms against the LICENSE file before you treat it as MIT-only, since code under packages/ee is commercially licensed.
Finally, check the network path. Activepieces documents Docker Compose and a Helm chart for Kubernetes, which lets you place the runtime next to the systems your scenarios must reach. Test each connection from that network before you commit, and list every Make module that calls an on-premises system. If you need to keep the decision open, plan a pilot that rebuilds your three most credit-heavy scenarios on a self-hosted instance and compare run cost and maintenance effort side by side with Make's renewal terms.
Which scenarios favor Make and which favor Activepieces
This table matches common buyer situations to the platform that fits them better, with one reason tied to the facts we can confirm. Read each row against your own constraints, since the right answer depends on who operates the runtime and which features you must have.
| Scenario | Better fit | Reason |
|---|---|---|
| Small team on managed cloud with no self-hosting staff | Make | Make runs as a managed cloud service, so there is no runtime to install, patch or back up in your own network. |
| Runtime must sit on-premises or in an air-gapped network | Activepieces | Activepieces documents self-hosting with Docker Compose, PostgreSQL and Redis, and a Helm chart for Kubernetes, while Make has no self-hosted edition. |
| Heavy credit consumption across many scenarios | Activepieces | Self-hosting the Community edition moves execution onto infrastructure you pay for directly, instead of Make credit tiers. Confirm your own hosting cost against your credit volume. |
| Need for SCIM provisioning or audit logs | Activepieces | SCIM and audit logs are listed only on the Ultimate plan, so confirm with the vendor whether that tier fits your governance requirements and budget. |
| Building custom pieces for internal or niche apps | Activepieces | Activepieces is MIT licensed in its Community edition and ships more than 280 pieces, so teams can extend and version integrations in their own repository. |
| Need to exercise a managed vendor's SLA and support model | Make | Make's cloud service is operated by Make, so uptime and support obligations sit with the vendor. Confirm the terms in your contract. |
| Need for a choice of US or EU data zones | Make | Make offers US and EU zones, while a self-hosted Activepieces install places data wherever you deploy it, which you must govern yourself. |
Where the data and runtime live under each option
Make runs only in its hosted zones, US or EU, and does not offer a self-hosted edition, so every scenario run, execution log and mapped value passes through Make's infrastructure. Activepieces can run on your own servers. The installation overview recommends Docker Compose with PostgreSQL and Redis, and a Helm chart is available for Kubernetes. Before you choose, confirm with Make which zone your account would use, where its execution logs are stored, and whether that region satisfies your residency rules. Then confirm which Activepieces components your network team would need to host, including the database and Redis tier, and who patches them.
Identity and audit controls are where the editions differ. The Activepieces pricing page starts SSO at the Team plan and lists audit logs, Git sync and releases, SCIM and external secret managers only for Ultimate, the tier that can run in the cloud or on premises. The Community edition is the automation core on its own. If your identity policy requires SSO and provisioning through SCIM, or your compliance program expects audit logs, price the paid tier into the comparison. DeployOpen can prepare the configuration, evidence and operating records for a compliance assessment, but an independent auditor or certification body issues any report or attestation, so confirm the control scope with your auditor first.
Community hosting templates usually ship the Community edition, according to the Activepieces installation documentation. Check which edition a template or Helm values file deploys before assuming SSO or audit logs exist. Once Activepieces runs in your network, your database holds the flows, run history and stored connections, and your team controls its backups, access to the server and the encryption secrets used for stored credentials. Make blueprints do not carry connections, so credentials must be re-entered in the new platform in either case. Ask who will own each of these records, how long run logs are kept, and where backups are stored before migration begins.
What the MIT Community edition covers and what needs a paid tier
Make is sold as a hosted service. Its plans are priced through a credit allowance that scenario runs consume, and the runtime sits in the zone you select, either US or EU. There is no self-hosted edition of Make, so the question for buyers is not which Make tier to pick but whether the workload can stay on a hosted service at all. The decision usually turns on data location, network reach into on-premises systems and how credit consumption trends over a contract year.
- Hosting model: Scenarios run in Make's cloud, in the US or EU zone chosen for the account.
- Billing: Consumption is metered in credits, so cost follows run volume and module count.
- Portability: Scenario blueprints can be exported as JSON, but connections and credentials must be recreated after import.
- Network reach: Systems behind a private network need a route the hosted runtime can reach, which the buyer must design.
- Terms: Plan names, credit allowances and governance features change over time.
Before comparing, ask Make for the current plan matrix in writing and confirm which governance and zone options are included at your contract level.
The Activepieces Community edition is licensed under MIT (Expat) and is the automation core of the product. The LICENSE file in the repository states that the code outside packages/ee and packages/server/api/src/app/ee is MIT licensed, so you can run it, modify it and operate it in your own infrastructure without a license fee from the vendor. The Community edition is what most community-maintained hosting templates ship, and it covers flows, the piece library and self-hosted deployment on Docker Compose or Kubernetes.
- Core automation: Flows, triggers, actions and the 280+ pieces run in the Community code.
- Self-hosting: Docker Compose with PostgreSQL and Redis, or the Helm chart for Kubernetes, are documented in the installation overview.
- Custom pieces: Building pieces for applications that are not yet covered is part of the open-source path.
- No vendor fee for the code: The MIT license removes a license charge for the Community code, but infrastructure, staffing and support remain your costs.
- Scope limit: Features in the enterprise paths are not part of this license.
Confirm which edition your chosen deployment template installs, because community templates typically ship the Community code without the enterprise paths.
The Activepieces pricing page lists Free, Plus, Team and a custom-priced Ultimate plan. SSO starts at Team, while audit logs, Git sync and releases, SCIM and external secret managers appear only under Ultimate. These features sit in the commercial code paths, so they are not included by the MIT license even when you self-host. The pricing page lists Plus at 20 US dollars a month and Team at 200 US dollars a month, and both figures come from that page, so confirm them before budgeting.
- Plus and Team: Plus is listed at 20 US dollars a month and Team at 200 US dollars a month, with Team including 25 users and SSO.
- Ultimate: The custom plan adds audit logs, Git sync, SCIM and external secret managers, and can run in the cloud or on premises.
- Governance gap: If your controls require SCIM provisioning or audit trails, the Community edition alone does not supply them.
- Pricing source: Plan names, inclusions and prices come from the vendor page and may change.
- Quote basis: Ask for a written quote that names the edition, the number of users and whether on-premises delivery is included.
Ask the vendor which governance controls your compliance scope requires and map each one to a specific tier.
The embedding offer, with a white-label builder and SDK for placing Activepieces inside another product, starts at 36,000 US dollars a year according to the pricing page. Embedding is a separate commercial arrangement, not a feature of the Community edition. Code under packages/ee and the server ee path at packages/server/api/src/app/ee falls under a separate commercial license, so any build that includes those paths needs that license regardless of how the rest of the platform is deployed.
- Annual price: The embedding starting price is 36,000 US dollars a year on the pricing page.
- Commercial paths: packages/ee and packages/server/api/src/app/ee are licensed separately from the MIT code.
- Build check: Verify which directories your deployment or fork includes before you claim MIT coverage.
- Redistribution: Embedding inside a product you sell changes the licensing picture, so have counsel review it.
- Current terms: Licensing text and embedding terms can change, so confirm them with Activepieces in writing.
Before signing anything, ask Activepieces to confirm the current license terms for each directory your build uses.
What drives the cost of each option
Make is billed by credits on its hosted service, while Activepieces Community is free software you run yourself. The cost of the self-hosted route sits in the infrastructure, the people who operate it, and the scenario rebuild, and each card below names who pays for each component.
Make credit consumption and AI steps
On Make, Make is the party paid for running your scenarios, and your bill follows the credits those runs consume. Scenarios with many modules, frequent triggers, large iterations or AI steps use more credits, so the monthly cost can rise even when the scenario count stays flat. Before comparing, export your current scenarios and list the operations each one performs per month, then ask Make how credits are counted for each module type you use.
Activepieces Community hosting infrastructure
With the MIT-licensed Community edition, you pay your cloud provider or data center for compute, PostgreSQL and Redis, and storage and backups. Activepieces recommends Docker Compose with PostgreSQL and Redis, or a Helm chart for Kubernetes, so size these components for your run volume and retention needs. Ask your infrastructure team to price a staging and a production environment, including backup storage and network egress.
Paid tier subscription for SCIM and audit logs
The Community edition does not include SCIM, audit logs, Git sync and releases, or external secret managers, which the pricing page lists only for Ultimate. Plus is listed at 20 US dollars a month and Team at 200 US dollars a month, and SSO starts at Team. Activepieces is paid for these subscriptions, and the Ultimate plan is custom-priced and can run on premises, so request a written quote for the exact feature set you need.
Staff time to operate and upgrade
Your platform or automation team pays in hours for patching, upgrades, monitoring, backups and restore tests, which recur every month. Activepieces publishes frequent releases, so plan a repeatable upgrade and rollback process and assign an owner. Ask any implementation partner to estimate these hours in writing, since no supplied figure sets a typical effort.
One-time scenario rebuild effort
Make scenarios do not move to Activepieces automatically. Blueprint exports carry modules, settings and mapped values, but connections must be recreated, so the rebuild is a one-time cost paid by your team or a partner. Count your scenarios, check which Make modules have matching pieces, and budget for custom pieces where an app is missing, since most of this effort is spent on connection and testing work.
Support and retainer coverage
Community editions carry no vendor support contract, so support cost depends on whether you use Activepieces support under a paid plan, your internal team, or an external retainer for upgrades, monitoring and incident response. DeployOpen offers ongoing support and upgrade retainers under a written scope, and fixed-scope implementation is priced from that scope. Ask each option what response times and coverage are included before you compare totals.
What moving from Make to Activepieces involves
The sequence turns each Make scenario into an Activepieces flow running on infrastructure you control, with connections rebuilt, behavior verified and the Make scenarios switched off only after the new flows have proven themselves. Each step ends with a check that tells the team it can move on.
Inventory scenarios and their dependencies
Someone on the platform or integration team lists every Make scenario, its owner, its trigger, its schedule and the systems it touches, and notes which scenarios feed business-critical processes. Scenarios that call webhooks or internal endpoints are flagged for network review. The inventory is done when every active scenario has an owner and a priority, and the team agrees on the rebuild order.
Export blueprints and record connections
For each scenario, export the blueprint as a .json file. A blueprint holds the modules, module settings and mapped values, but not connections or account credentials, so the team also records which app account each connection uses and who can authorize it. The step is complete when every blueprint is archived in version control and each connection has a named owner for re-authorization.
Map modules to Activepieces pieces
Engineers take each module in a blueprint and find the matching Activepieces piece, which the repository lists in more than 280 integrations. They also mark modules that have no piece, plus branching, iteration and aggregation logic that must be expressed as flow steps. The output is a mapping sheet that lists each Make module, its Activepieces equivalent or gap and the owner of that decision.
Build custom pieces for missing apps
Where no piece exists for an internal system or a niche SaaS API, developers write a custom piece in TypeScript that wraps the API with authentication and actions. Teams should confirm current development guidance in the Activepieces documentation before starting. The step is done when each custom piece has been reviewed, tested against a non-production account and documented for the next maintainer.
Set up self-hosted Activepieces
The platform team installs Activepieces in its own network, following the installation overview. The project recommends Docker Compose with PostgreSQL and Redis, and offers a Helm chart for Kubernetes. Confirm which edition the chosen template ships, since community-maintained templates usually ship the Community edition. The step is complete when the instance is reachable only from the networks it should serve, backed up and patched on a documented schedule.
Rebuild, recreate connections and test flows
Engineers rebuild each flow in the new instance, create fresh connections with the owners recorded earlier, and run test data through every path, including error handling and retries. Each result is compared with the output of the Make scenario it replaces. The step ends when every flow passes side-by-side testing and the business owner signs off on the results in writing.
Cut over and retire Make scenarios
The team switches triggers, webhooks and schedules from Make to Activepieces in controlled batches, starting with lower-risk scenarios. Make scenarios are paused rather than deleted at first, so they can be re-enabled if a problem appears. The step is complete when the old scenarios have run without a regression for an agreed observation period and the team deletes them and records the decision.
Confirm licensing and operations ownership
Before go-live, the team confirms which Activepieces edition it runs, since the Community edition is MIT licensed while features under packages/ee are commercially licensed, and it decides whether it needs SSO, SCIM, audit logs or Git sync, which the pricing page places in higher tiers. Ask the vendor to confirm current tier contents in writing. The step is done when a named team owns upgrades, backups and access reviews, and the license position is documented for procurement.
Questions buyers ask before switching from Make to Activepieces
How much does moving from Make to Activepieces cost, and what drives it?
The cost is mostly the people time to rebuild scenarios and run the platform, plus the hosting and the tier you choose. The Community edition is MIT licensed and free to use, so the software line is zero, but the infrastructure, the PostgreSQL and Redis services, and the staff time are not. Scenario count, the number of apps that need a custom piece, and how much logic relies on Make-specific modules drive the rebuild effort up. Ask any provider for a written, itemized quote covering scope, hosting, rebuild and support, and ask which Activepieces tier they assume. Make's credit spend is recurring, while the rebuild is largely one-time.
How long does a Make to Activepieces migration take?
No duration is supplied for this migration, so no timeline can be stated here. The time depends on how many scenarios you run, how many modules have an equivalent piece, how much branching and looping you rely on, and how many custom pieces you need to write. Ask for a timeline that follows from a written scope, and ask the team to list which scenarios are in and which are out. A smaller, well-documented set of scenarios usually moves faster than a broad estate with undocumented dependencies.
Can our internal team migrate Make scenarios to Activepieces alone?
Yes, a team with workflow experience and access to the Activepieces documentation can rebuild simple scenarios in-house. The harder parts are recreating connections, which Make does not export, and building custom pieces for apps without one. Make's blueprint export carries modules, module settings and mapped values, but connections must be recreated after import, so credentials and account access need a deliberate plan. Teams with many business-critical scenarios often bring in an implementation partner for the cutover, while keeping day-to-day ownership internally.
What does running Activepieces require from our engineers?
The Activepieces installation docs recommend Docker Compose with PostgreSQL and Redis for self-hosting, and offer a Helm chart for Kubernetes. Your team needs to run and patch those services, manage backups, monitor the workers, and handle upgrades. Activepieces publishes frequent releases, so a release process and a staging environment matter. Confirm who is on call for workflow failures, how credentials are stored, and how you will test upgrades before they reach production. Community-maintained hosting templates usually ship the Community edition, so check which edition any template installs.
Do SCIM, audit logs and Git sync require the Ultimate plan?
Yes. The Activepieces pricing page lists audit logs, Git sync and releases, SCIM and external secret managers only for the Ultimate plan, which is custom priced and can run in the cloud or on premises. SSO starts at the Team plan. The self-hosted Community edition is the automation core on its own, so a Community install does not include those controls. If your compliance or identity requirements depend on SCIM or audit logs, confirm the current tier details directly with Activepieces before you finalize the design.
Is Activepieces open source under the OSI definition?
The Community edition is open source under the MIT (Expat) license, and the LICENSE file says the rest of the code under packages/ee/ and packages/server/api/src/app/ee is under a separate commercial license. So the core automation engine is MIT licensed, but the enterprise code is not. Legal and procurement teams should read the LICENSE file and confirm which packages your deployment includes. Pieces contributed by the community are a separate question, so review the license of any custom piece you build or adopt.
What should we check before we commit to the switch?
Start with an inventory of scenarios, the apps they connect to, and the data they handle. Check that each app has an Activepieces piece or that you can build one, and test one representative scenario end to end in a staging install. Confirm your hosting and network requirements, who owns backups and upgrades, and which edition and tier you need. Then ask for a written scope with deliverables before work starts.
How DeployOpen helps evaluate and implement the move
DeployOpen plans, implements, hardens, backs up, upgrades and documents self-hosted open-source platforms inside your own cloud accounts, data centers or air-gapped networks. For a Make to Activepieces move, that means working from your inventory of scenarios, connections and data flows to decide which flows can be rebuilt as Activepieces flows, which need custom pieces, and where the Community edition covers your needs without a paid tier. The first deliverable is usually a written assessment of that inventory, not a migration of anything live.
Most engagements are fixed-scope. Before work starts, the scope, deliverables and timelines are agreed in writing, and a quote follows from that scope. The items that usually move the quote are the number of scenarios and their complexity, how many connections must be recreated, whether Activepieces must reach on-premises systems, which Ultimate-only controls such as SCIM, audit logs or Git sync you need, and how much custom piece development is required. Ask for each of these to be listed as a separate line so you can see what is one-time and what recurs.
Once the Activepieces instance is running, the operating work continues: keeping the PostgreSQL and Redis dependencies healthy, applying upgrades, handling backups and documenting who owns each flow. Ongoing support, upgrades and continuous testing are available as retainers, which suits teams that do not want to staff this in-house. Confirm the licensing position with Activepieces before you build on it, because the Community edition is MIT licensed while the enterprise code paths sit under a separate commercial license. DeployOpen does not issue audit reports or certifications, so any compliance evidence you need will come from independent auditors using the controls and records we help prepare.
