# How to Vibe Code Your Own Make (and Stop Paying for It)

> The platform to build and manage all your AI agents and automations

- Site: https://make.com
- Category: Workflow Automation / iPaaS
- Platforms: Web app
- Verdict: **Serious undertaking** (32/100 vibecodeable)
- Estimated effort: 3-6 months of serious part-time work

## Verdict

Build a heavily scoped personal automation subset instead, or keep paying for Make because maintaining thousands of live connectors is an impossible solo feat.

Replicating Make's core value for personal use means building two violently difficult systems from scratch: a high-performance visual graph canvas and a distributed asynchronous queue processor that evaluates complex JSON mapping schemas. While you can build a personal prototype that runs a few custom webhooks and linear steps in a couple of weeks, you will spend all your time writing custom API wrappers rather than using the tool. Given that the paid tier is around $10.59/mo, paying for it is objectively more rational unless your primary goal is an academic exercise in building compiler-like data mappers and workflow orchestrators.

### What you can't replicate

- 3,000+ pre-built, maintained third-party app integrations with auto-updating OAuth schemas
- Enterprise-grade uptime and execution reliability infrastructure

## What it does

A cloud-based visual workflow automation and integration platform that allows users to design, build, and automate complex processes by connecting thousands of apps.

### Core features

- Visual drag-and-drop canvas for workflow scenarios
- Multi-path branching, routers, filters, iterators, and aggregators
- Inline JavaScript/Python-style data mapping and formula evaluation
- Asynchronous job queue execution engine with state management
- Persistent state Data Stores
- Secure credential vault for API keys and OAuth tokens
- Webhook triggers and polling triggers

## The business

### Pricing

- Free: $0/mo — For getting started with simple personal automations.
- Core: ~$10.59/mo — For growing personal automation needs.
- Pro: ~$18.82/mo — For power users requiring deeper logging and speed.
- Teams: ~$34.12/mo — For small teams collaborating on workflows.

Founded 2012.
Team size: 201-500.

## The hard parts

- Building a performant, reactive SVG/canvas graph editor that handles complex nested mapping without UI lag
- Engineering a reliable distributed execution engine with asynchronous queues, rate-limit handling, and retries
- Maintaining thousands of brittle third-party API integrations and distinct authentication handshakes
- Sandboxing user-defined inline transformation scripts safely

## How to vibe code Make

### Prerequisites

- Node.js (free): Required for runtime execution of backend orchestration services and frontend tooling.
- GitHub (free): Source code repository hosting and CI/CD triggers.

### Recommended AI tools

- Claude Code: Best-in-class agentic coding tool for scaffolding complex backend state engines and canvas node editors across multiple files.
- Cursor: Ideal for fine-tuning the reactive UI canvas components and writing precise data mapping parser logic.

### Stack

- Frontend: Next.js with React Flow or custom SVG canvas rendering
- Backend: Node.js with TypeScript and BullMQ for distributed job queues
- Database: Turso for edge-friendly SQLite state and scenario storage
- Auth: better-auth for self-hosted single-user session security
- Payments: None
- Other: Tailwind CSS for styling, Zod for JSON schema validation and data mapping type safety

### Hosting

- Railway (Running the Next.js web application alongside persistent background workers for asynchronous scenario execution queues): ~$5/mo

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize the Next.js project with TypeScript, configure Tailwind CSS, and set up the Turso SQLite database schema for users, scenarios, modules, and execution logs.

```
Initialize a full-stack Next.js project with TypeScript and Tailwind CSS. Configure Turso (libSQL) as the database with Drizzle ORM. Create database tables for users, scenarios (storing the workflow JSON graph structure), scenario_runs (execution logs with status, start time, end time, and step payload logs), and data_stores (key-value persistent storage per user). Implement a basic local authentication layout using better-auth to secure the personal workspace. Ensure proper error handling and environment variable structure for local development.
```

2. **Visual Scenario Canvas & Node Editor** — Build an interactive drag-and-drop canvas interface using React Flow or custom SVG rendering where users can place triggers, routers, filters, and action nodes, connecting them into a directed acyclic graph.

```
Build a visual scenario editor page using React Flow or a custom SVG canvas engine. Allow users to drag and drop nodes from a sidebar onto the canvas, connect nodes with directional edges, and configure node properties via an inspector panel on the side. Define node types for Webhook Trigger, HTTP Request Action, JSON Filter, Router (multi-path branching), and Data Store Operations. Store the complete graph state (nodes, edges, configuration parameters) as a JSON object in the scenarios database table whenever the user clicks Save.
```

3. **Data Mapping & Formula Evaluation Engine** — Implement a parsing engine that maps data tokens from preceding nodes into subsequent node parameters using inline dot-notation and basic transformation functions.

```
Implement a TypeScript data mapping and formula evaluation engine. When configuring a downstream node, users should be able to select output fields from upstream nodes using token pills or dot-notation (e.g., `1.body.email`). Build a secure expression parser that resolves these tokens against runtime execution context payloads, supporting basic string operations, math, and JSON path lookups. Ensure invalid token references throw descriptive evaluation errors.
```

4. **Asynchronous Queue & Execution Engine** — Set up a background worker queue using BullMQ and Redis to execute scenarios step-by-step asynchronously, handling routers, filters, and error paths.

```
Build an asynchronous execution engine using BullMQ backed by Redis. When a scenario is triggered (either via an incoming webhook endpoint or a manual run click), dispatch a background job that loads the scenario graph, topologically sorts or traverses the execution path, evaluates filters, executes routers to split execution into multiple branches, and performs HTTP requests or data store mutations. Log every step's input, output, and execution status into the scenario_runs table so it can be viewed in real-time on the frontend canvas.
```

5. **Connectors & Credential Vault** — Create custom integration modules for common APIs (e.g., Slack, GitHub, Custom Webhooks) and a secure credential vault for storing API keys.

```
Implement a secure credential vault module using AES-256 encryption to store third-party API keys and OAuth tokens per user. Build modular integration connectors for Custom Webhook Triggers, HTTP Request Actions (supporting custom headers, query params, and body mapping), and Data Store CRUD actions (Insert, Update, Get, Delete record). Connect these modules directly into the execution engine so worker nodes can securely authenticate against external APIs during scenario runs.
```

6. **Execution History & Dashboard Polish** — Build the execution history inspector UI to inspect past scenario runs, view detailed step inputs and outputs, and polish the dashboard experience.

```
Build a comprehensive execution history dashboard view. Display a paginated list of scenario runs with status badges (Success, Error, Running), execution duration, and timestamp. Clicking a run should open an inspection modal or split-pane view that visually highlights the scenario graph nodes and displays the exact JSON payload input and output for every single step executed. Add real-time polling or WebSocket updates so active runs animate on the canvas.
```

### Cost vs paying

**Starting costs (one-time):**

- Custom domain (optional): $12/year
- Total: ~$12 one-time

**Ongoing costs (monthly):**

- Railway hosting & Redis worker queue: $5/mo
- Total: ~$5/mo

- Paying for the SaaS instead: ~$10.59/mo (Core plan)
- Build time: 60-90 hours
- AI tool credits: $20/mo (Claude Pro / Cursor Pro)
- Break-even: Never (purely an engineering challenge; paying $10.59/mo is vastly more efficient)

## Sources

- [Make: AI Workflow Automation Software & Tools](https://make.com)
- [Make.com Pricing: Full Cost Breakdown (2026)](https://emergent.sh/blog/make-com-pricing-full-cost-breakdown-2026/)
- [Make (Integromat) Review 2026: Pricing, Features, Pros & Cons](https://www.saleshive.com/blog/make-integromat-review-pricing-features-pros-cons)