How to vibe codeMake
The platform to build and manage all your AI agents and automations
make.com ↗Workflow Automation / iPaaS
The verdict: can you vibe code Make?
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.
Estimated effort: 3-6 months of serious part-time work
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
Founded
2012
Raised
—
Team
201-500
Cheapest paid tier
$0/mo
What Make 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
- Core~$10.59/mo
- Pro~$18.82/mo
- Teams~$34.12/mo
Funding
Unknown / bootstrapped
Pay vs build, cumulative
Break-even at month 3 — after that, every month is money kept.
The hard parts of vibe coding Make
- 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 vibecode Make
Prerequisites
Node.jsfree
Required for runtime execution of backend orchestration services and frontend tooling.
GitHubfree
Source code repository hosting and CI/CD triggers.
AI coding tools
Recommended 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 & infrastructure
| Railway | Running the Next.js web application alongside persistent background workers for asynchronous scenario execution queues | ~$5/mo |
Build guide
01Project 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.02Visual 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.03Data 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.04Asynchronous 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.05Connectors & 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.06Execution 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 for Make
What will you build it with?
Starting total with Claude Code$0 one-time
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 Make
~$10.59/mo (Core plan)
Your time to build
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)
Vibe code Make: FAQ
- Can you vibe code Make yourself?
- Serious undertaking — 32/100 vibecodeable. Build a heavily scoped personal automation subset instead, or keep paying for Make because maintaining thousands of live connectors is an impossible solo feat.
- How long does it take to vibe code Make?
- 3-6 months of serious part-time work — roughly 60-90 hours of hands-on time with an AI coding agent.
- How do you build your own Make?
- Scoped to personal use: Next.js with React Flow or custom SVG canvas rendering on the front, Node.js with TypeScript and BullMQ for distributed job queues behind it, Turso for edge-friendly SQLite state and scenario storage for data. Follow the 6-step build guide on this page — each step has a paste-ready prompt for an AI coding agent.
- How do you code your own Make without being an expert?
- Use an AI coding tool (Claude Code or Cursor) and work in small steps: scaffold, data model, core screens, then deploy. Realistic effort: 3-6 months of serious part-time work. The prompts on this page are written so the AI does the heavy lifting.
- How much does it cost to vibe code Make instead of paying?
- About ~$12 one-time to start and ~$5/mo to run, versus ~$10.59/mo (Core plan) for Make. Break-even: Never (purely an engineering challenge; paying $10.59/mo is vastly more efficient).
- What stack should you use to vibe code Make?
- Next.js with React Flow or custom SVG canvas rendering; Node.js with TypeScript and BullMQ for distributed job queues; Turso for edge-friendly SQLite state and scenario storage; plus Tailwind CSS for styling, Zod for JSON schema validation and data mapping type safety.