Choosing between Make and custom development is not a budget decision. It's an architecture decision that determines how easy it will be to scale and maintain your operation in the coming years.
The myth of "automating with Make is faster"
Make (formerly Integromat) is a powerful tool for connecting applications without code. But "no-code" doesn't mean "no architecture." A poorly designed Make scenario can be just as fragile and hard to maintain as poorly written code.
The right question isn't "do I use Make or code?" but "what does this specific logic require?"
When Make is the right answer
Make has a clear advantage when:
- The logic is linear: event A → transformation B → result C.
- The applications already have native integrations in Make (Shopify, Airtable, Gmail, Slack, HubSpot).
- Volume doesn't exceed plan limits and cost is predictable.
- The team doesn't have developers available for continuous maintenance.
Ideal examples: new order notification to the team's WhatsApp, Shopify customer sync to HubSpot, weekly sales report by email.
When you need custom development
Direct code is necessary when:
- The logic involves complex conditions or non-linear branches.
- You need full control over error handling and retries.
- Operation volume makes Make more expensive than your own server.
- You need data transformations that Make can't handle natively.
Make vs. Custom vs. Hybrid, side by side
No single option wins on everything. It comes down to five concrete criteria:
| Criterion | Make | Custom | Hybrid |
|---|---|---|---|
| Operation volume | Low–medium | High | Medium–high |
| Logic complexity | Linear | Branching | Mixed |
| Maintenance | Anyone on the team | Requires a dev | Dev + operator |
| Cost at scale | Rises with volume | Fixed (server) | Optimized |
| Implementation speed | Fast | Slow | Medium |
The hybrid model that works in practice
The most robust architecture we implement for mid-volume e-commerces combines both approaches:
Make handles orchestration and third-party integrations. Custom code handles business logic and complex transformations. Each tool does what it does best.
For example: Make captures a new Shopify order webhook and calls a serverless function (Vercel, AWS Lambda) that applies the specific business logic. The function processes and returns the result, which Make distributes to the destination systems.
At El Zarco we implemented exactly this model: Make captures new-order webhooks and calls a serverless function that applies tier-based pricing logic before returning the result to the operation. See the full case →
The question you must ask first
Before choosing the tool: if this automation fails at 3am on a Sunday, who can fix it? The answer determines which tool to use. If only your senior developer can, maybe Make is the answer. If anyone on the team can follow an error log, also.
High-performance automation is not built by choosing the most expensive or most popular tool. It's built by precisely understanding which part of the operation needs to scale and designing accordingly.