# How to Vibe Code Your Own Tray.ai (and Stop Paying for It)

> Enterprise orchestration for data and AI

- Site: https://tray.ai
- Category: Enterprise Automation & iPaaS
- Verdict: **Don't bother** (18/100 vibecodeable)
- Estimated effort: 6+ months of full-time work for a functional subset

## Verdict

Build a subset for personal productivity — do not attempt to clone the 700-connector enterprise integration engine.

Replicating Tray.ai as a solo developer is fundamentally impractical because its core value is not just a React canvas; it is the immense operational overhead of maintaining 700+ enterprise API integrations, secure OAuth lifecycle management, and a distributed workflow orchestration engine. An AI agent can help scaffold a basic workflow runner and a single LLM agent interface, but you will hit a wall immediately when trying to handle enterprise-grade webhook retries, granular data masking, and MCP tool governance.

### What you can't replicate

- Live maintenance and schema updates for 700+ enterprise connectors
- Enterprise compliance frameworks (HIPAA, SOC 2 Type II, audit log streaming)
- Massive asynchronous execution infrastructure processing billions of events

## What it does

An AI-ready integration and automation platform featuring a low-code iPaaS, Merlin Agent Builder, and an Agent Gateway for Model Context Protocol (MCP) tool governance.

### Core features

- Visual drag-and-drop workflow builder canvas
- Library of 700+ third-party SaaS API connectors
- Merlin Agent Builder for conversational/autonomous AI agents
- Agent Gateway for Model Context Protocol (MCP) governance and tool publishing
- In-flight data transformations and SQL data engineering pipelines
- Guardian Log Masking and execution audit logs
- Tray Headless IDE integration plugins (Claude Code/Codex scaffolding)

## The business

### Pricing

- Pro Plan: Custom / Sales Quoted — Targeted at specific use cases with limited workspaces and log retention.
- Team Plan: Custom / Sales Quoted — Designed for multi-use case adoption within a department.
- Enterprise Plan: Custom / Sales Quoted — Built for organization-wide scaling, regional compliance, and advanced engineering.

### Funding

$150M+ raised.
- Seed & Early Rounds
- Series C Extension ($50M total, $40M announced Sept 2022)
Investors: Spark Capital, True Ventures, GGV Capital, Meritech Capital Partners, Canada Pension Plan Investment Board (CPP Investments), Mosaic Ventures, Redpoint Ventures

Founded 2012.
Team size: 140-240.

## The hard parts

- Maintaining robust OAuth token refresh and schema synchronization across 700+ disparate enterprise APIs
- Building a hyper-scalable, asynchronous fault-tolerant workflow execution engine capable of zero data loss under heavy load
- Designing a secure MCP gateway with dynamic user-level authentication and sandboxed tool execution guardrails
- Executing stateful in-flight data engineering transformations at enterprise speed

## How to vibe code Tray.ai

### Prerequisites

- Node.js (free): Required runtime for the TypeScript full-stack application and CLI tooling.
- GitHub (free): Version control and repository hosting.
- Cursor (free): AI-native code editor to accelerate multi-file scaffolding.

### Recommended AI tools

- Claude Code: Agentic terminal coding tool capable of executing multi-file scaffolding and test loops.
- Cursor: Ideal for iterative UI component building on the workflow canvas.

### Stack

- Frontend: Next.js
- Backend: Next.js API Routes
- Database: Turso
- Auth: better-auth
- Payments: None
- Other: Vercel AI SDK, Tailwind CSS, Inngest

### Hosting

- Vercel (Hosting the Next.js workflow builder frontend and API server): $0-20/mo
- Turso (Serverless SQLite database for workflow configurations and logs): $0/mo

### Build guide

1. **Scaffold Project & Database Schema** — Initialize the Next.js project with TypeScript, Tailwind CSS, and configure Turso with better-auth.

```
Scaffold a Next.js full-stack application using Tailwind CSS and TypeScript. Set up better-auth for single-user authentication. Configure a Turso libSQL database client with tables for workflows (id, name, nodes_json, edges_json, created_at), executions (id, workflow_id, status, logs, executed_at), and mcp_tools (id, name, schema_json, handler_url). Ensure all database interactions use parameterized queries. Verify the setup with a local build command.
```

2. **Build Visual Workflow Canvas** — Implement a drag-and-drop workflow canvas using React Flow or custom SVG nodes to link triggers and actions.

```
Build an interactive visual workflow canvas component using React and Tailwind CSS. Implement a node-based editor where users can drag trigger nodes (e.g., 'Webhook', 'Schedule') and action nodes (e.g., 'Send Slack Message', 'HTTP Request') onto a grid, connect them with directional edges, and configure their parameters via a side drawer. Save the canvas state as a JSON structure to the workflows table.
```

3. **Implement Workflow Execution Engine** — Create a durable background execution engine to process workflow steps sequentially using Inngest.

```
Integrate Inngest into the Next.js application to power workflow execution. Create a background function that receives a workflow ID and execution payload, parses the workflow steps sequentially from the workflow JSON graph, executes each node (handling HTTP requests and mock CRM integrations), captures step logs with timestamp tracking, and updates the execution status in the database. Handle retries for failed steps.
```

4. **Build Merlin Agent & MCP Gateway** — Construct an AI agent builder and MCP tool registry that exposes registered workflows as secure LLM tools via Vercel AI SDK.

```
Build a 'Merlin Agent Builder' interface allowing users to define an AI agent with system prompts, knowledge inputs, and selected tools. Implement an Agent Gateway API endpoint that registers active workflows and custom integrations as Model Context Protocol (MCP) tools. Using the Vercel AI SDK, create a chat interface where the agent can reason, call the registered workflow tools with structured arguments, and log every tool invocation securely with mock log masking.
```

5. **Add Testing, Polish & Observability Dashboard** — Create an execution history dashboard with log streams and audit traces to monitor workflow runs.

```
Build an execution history and observability dashboard page in Next.js. Display a table of recent workflow runs with status badges (success, failed, running), duration metrics, and detailed step execution logs inside an expandable drawer. Add error-state handling and verify responsiveness across standard screen sizes.
```

### Cost vs paying

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

- Domain Name: $12/yr
- Total: ~$12 one-time

**Ongoing costs (monthly):**

- Vercel Hobby/Pro Hosting: $0-20/mo
- Turso DB / Inngest Cloud: $0/mo
- AI API Usage (Anthropic / OpenAI): ~$10/mo
- Total: ~$10-30/mo

- Paying for the SaaS instead: ~$500+/mo (Enterprise Tier)
- Build time: 120+ hours
- AI tool credits: $20/mo (Claude Pro / Cursor)
- Break-even: N/A (Enterprise utility cannot be fully replicated)

## Sources

- [Tray.ai Homepage & Documentation](https://tray.ai)
- [Tracxn: Tray Company Profile 2026](https://tracxn.com)
- [Forge Global: Tray.ai IPO Timeline and Financing](https://forgeglobal.com)