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

> Automate business & home

- Site: https://ifttt.com
- Category: Workflow Automation
- Platforms: Web app, iOS app, Android app
- Verdict: **Serious undertaking** (45/100 vibecodeable)
- Estimated effort: 6+ weeks of part-time engineering work

## Verdict

Build a personal subset with custom webhooks and simple polling, but keep paying if you need thousands of native third-party API integrations.

While you can scaffold a basic automation runner in Next.js, building a true clone requires maintaining dozens of complex OAuth integrations, handling erratic token expirations, and writing a fault-tolerant worker daemon that polls external APIs every few minutes without melting your database or getting IP-banned. The core loop is straightforward, but dealing with third-party API fragmentation is a relentless maintenance trap.

### What you can't replicate

- Official partnerships and native OAuth scopes for 1,000+ top-tier brands
- Massive ecosystem of millions of community-created Applets
- Native mobile OS integrations across 190+ countries

## What it does

IFTTT is a cloud-based integration and automation platform that connects various web applications, internet-connected smart home devices, and developer APIs using trigger-action workflows called Applets.

### Core features

- User authentication and profile management
- Trigger and Action registry for external services
- Applet visual builder (If This Then That logic)
- Background worker engine for periodic polling
- Webhook receiver endpoints for instant triggers
- Multi-action sequential execution pipeline
- Sandboxed filter code execution (JavaScript/Python)
- Mobile companion app integrations (Location, SMS, Widgets)

## The business

### Pricing

- Free: $0
- Pro: $2.99/mo
- Pro+: $8.99/mo

### Funding

$62.5M raised.
- Seed
- Series A
- Series B
- Series C
Investors: Andreessen Horowitz, New Enterprise Associates (NEA), RRE Ventures, Lerer Hippeau, SV Angel

Founded 2010.
Team size: 51-200.

## The hard parts

- Maintaining hundreds of fractured third-party OAuth2 flows and token refreshes
- Designing a robust, non-blocking polling architecture that scales without hitting rate limits
- Executing user-submitted custom filter code securely without server compromise
- Managing reliable event delivery and idempotency across async webhook pipelines

## How to vibe code IFTTT

### Prerequisites

- Node.js (free): Runtime environment for building and running the TypeScript backend and Next.js frontend.
- GitHub (free): Repository hosting and CI/CD pipelines.

### Recommended AI tools

- Claude Code: Best-in-class terminal agent for scaffolding complex multi-file backend workflows, database schemas, and background job runners.
- Cursor: Ideal for iterative UI work on the dashboard, visual applet builder, and form components.

### Stack

- Frontend: Next.js (React)
- Backend: Next.js API Routes / Node.js background workers
- Database: Neon (Serverless Postgres)
- Auth: better-auth
- Payments: None (Personal use clone)
- Other: Inngest for reliable background workflow execution and polling triggers, Resend for transactional alerts and failure notifications

### Hosting

- Vercel (Hosting the Next.js frontend and serverless API dashboard): $0/mo (Hobby tier)
- Fly.io (Running continuous background worker processes for cron-based service polling): ~$3-5/mo

### Build guide

1. **Project Scaffolding and Database Schema** — Initialize the Next.js project with Tailwind CSS, configure Neon Serverless Postgres, and set up relational tables for users, services, connected accounts, applets, and execution logs.

```
Create a new Next.js project with TypeScript and Tailwind CSS. Connect it to a Neon Postgres database using Drizzle ORM. Define the schema for: 1) users, 2) services (id, name, logo), 3) connected_accounts (storing OAuth tokens and user linkage), 4) applets (id, user_id, trigger_service_id, trigger_event, action_service_id, action_event, is_active), and 5) execution_logs (applet_id, status, error_message, created_at). Ensure strict typing on all relations and include migration scripts.
```

2. **Authentication & Service OAuth Integration** — Implement authentication using better-auth and build an account connection module handling OAuth2 handshakes for selected personal services like GitHub, Google, and Webhooks.

```
Implement better-auth for user sign-up and session management in Next.js. Then, build a modular OAuth2 connection manager. Create a settings page where users can link external services (e.g., GitHub, Google Calendar, and Custom Webhooks). Securely encrypt and store access/refresh tokens in the connected_accounts table. Handle token exchange callbacks, error states, and token refresh logic gracefully.
```

3. **Applet Visual Builder UI** — Build an intuitive multi-step wizard interface allowing users to select a Trigger service/event, an Action service/event, configure parameters, and save the workflow.

```
Create a responsive multi-step Applet builder UI in Next.js. Step 1: Select a trigger from available connected services and configure trigger criteria (e.g., 'New GitHub Star'). Step 2: Select an action service and configure action parameters mapping dynamic variables from the trigger (e.g., 'Send Slack Message'). Step 3: Review and save the Applet. Build a dashboard displaying active applets with toggle switches and recent execution history logs.
```

4. **Background Polling and Webhook Engine** — Implement the core automation engine using Inngest or a Fly.io worker node to process incoming webhooks and poll external APIs on a scheduled interval.

```
Build a robust background automation execution engine in Node.js. Implement two ingestion paths: 1) A public webhook receiver endpoint (/api/v1/webhook/[id]) that immediately fires matching applets, and 2) A cron-based polling worker running every 5 minutes that checks trigger conditions against external APIs (e.g., polling RSS feeds or GitHub repositories). When a trigger condition evaluates to true, fetch the applet configuration, resolve payload templates, and execute the corresponding action request.
```

5. **Action Execution and Sandboxed Filter Code** — Build the action dispatcher that executes HTTP requests for target services and add support for running user-defined JavaScript filter snippets securely.

```
Create an action dispatcher service that handles outbound API requests to third-party services with exponential backoff retry logic and rate-limit handling. Implement a secure sandboxed code execution environment (using vm2 or quickjs) allowing Pro+ users to write custom JavaScript filter code snippets that can modify trigger data payloads or halt execution by returning false before the action fires.
```

6. **Dashboard Polish, Error Handling & Notifications** — Add comprehensive execution history views, real-time UI updates, error alerts via email (Resend), and final polish to complete the personal automation hub.

```
Polish the dashboard UI with real-time status badges for Applet execution runs. Implement an error notification system using Resend that emails the user if an Applet fails repeatedly due to invalid tokens or API timeouts. Add search, pagination, and filtering to the Applet logs page and write comprehensive unit tests for the trigger-action evaluation engine.
```

### Cost vs paying

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

- Custom domain (optional): $12/yr
- AI coding assistant subscription: $20 one-time
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Fly.io worker hosting: $4/mo
- Resend transactional email: $0/mo (Free tier)
- Total: ~$4/mo

- Paying for the SaaS instead: $8.99/mo (Pro+)
- Build time: 40-50 hours
- AI tool credits: $20 (Claude Pro)
- Break-even: Not a business investment — build for personal control and learning

## Sources

- [IFTTT Official Website](https://ifttt.com)
- [GetLatka - IFTTT Company Revenue & Profile Data](https://getlatka.com/companies/ifttt)
- [Crunchbase - IFTTT Company Profile](https://www.crunchbase.com/organization/ifttt)