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

> Your AI email marketer

- Site: https://hiremara.com
- Category: Marketing Automation & AI Agents
- Verdict: **Solid side project** (64/100 vibecodeable)
- Estimated effort: 3-4 weeks part-time

## Verdict

Build a personal subset for internal automation, but keep paying for the managed deliverability and sending infrastructure unless you enjoy debugging mail servers.

Mara combines a sophisticated multi-stage LLM agent loop with tricky email sending plumbing (Molted). While you canvibecode the Next.js dashboard, event webhooks, and Claude voice-extraction prompt pipelines in a few weeks, handling inbound email parsing, DNS verification for custom subdomains, and deliverability reputation will drain your weekends. If you just want automated founder emails for your side project, building a lightweight version with Resend and Claude is a satisfying side project; replicating the full testing bandit loop and robust inbox plumbing makes paying $99/mo rational.

### What you can't replicate

- Proprietary sending pipeline with warmed IP pools and high inbox placement rates
- Zero-friction onboarding wedge pulling live site context instantly
- Native MCP server tightly integrated with commercial dev tooling ecosystems

## What it does

Autonomous AI email marketing and lifecycle automation agent that drafts in your founder voice, monitors product events, runs multivariate copy tests, and manages two-way conversations.

### Core features

- Voice profile extraction from marketing site, changelogs, and pasted sample emails
- Lifecycle program rule engine (welcome, activation, feature adoption, expansion, churn-save, win-back, re-engagement)
- Product events ingestion API and webhook verification sinks (Stripe, Polar, Clerk, Supabase)
- Multi-variant generative copy testing with automated traffic allocation and agent-driven rewrites
- Inbound email classification and draft generation for founder approval
- Human-in-the-loop approval queue and safety guardrails
- Remote Model Context Protocol (MCP) server exposing granular tool capabilities for coding agents

## The business

### Pricing

- Starter: $99 / month
- Growth: $299 / month

Founded 2026.
Team size: 1 (Solo founder).

## The hard parts

- Reliable email deliverability and sending infrastructure (SPF/DKIM/DMARC, custom subdomain routing, and inbound mail parsing)
- Multi-stage LLM voice extraction and deterministic grading pipelines against 8 founder rules
- Automated multi-armed bandit / optimization loop shifting live send shares based on real conversion telemetry
- Asynchronous stateful lifecycle event graph engine tracking user identity across sessions and external webhooks
- Secure token-authenticated Streamable HTTP MCP server with dozens of read/write tools

## How to vibe code Mara

### Prerequisites

- Node.js (free): Runtime for the Next.js application and background workers.
- GitHub (free): Source control and deployment pipeline connector.
- Resend Account (free tier (3k emails/mo)): Transactional email API for sending verified domain messages.

### Recommended AI tools

- Claude Code: Best-in-class agentic coding tool for building complex multi-step backend pipelines and UI components.
- Cursor: IDE for reviewing UI diffs and tuning prompts interactively.

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui
- Backend: Next.js Server Actions and API Routes
- Database: Turso (SQLite at the edge)
- Auth: better-auth
- Payments: Stripe
- Other: Vercel AI SDK, Anthropic API, Resend, Inngest

### Hosting

- Vercel (Hosting the Next.js dashboard and serverless API endpoints): $0-20/mo
- Turso (Serverless SQLite database for tenants, programs, variants, and logs): $0/mo

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize a Next.js project with Tailwind CSS, shadcn/ui, Turso, and better-auth, setting up tables for tenants, programs, events, and email queues.

```
Scaffold a new Next.js project using App Router, TypeScript, and Tailwind CSS. Integrate better-auth for email/password authentication backed by Turso using @libsql/client. Create a complete database schema with tables for: tenants (id, name, domain, created_at), voice_profiles (id, tenant_id, fingerprint_json, raw_samples), programs (id, tenant_id, type, status, config_json), events (id, tenant_id, user_id, event_name, payload_json, timestamp), and email_queue (id, program_id, variant_id, recipient_email, subject, body_html, status [pending_approval, approved, sent], open_count, click_count, reply_received). Include migrations and a clean landing page dashboard layout.
```

2. **Voice Extraction & Prompt Pipeline** — Build an ingestion service that scrapes a product URL and processes pasted sample emails using the Anthropic API via the Vercel AI SDK to generate a founder voice fingerprint.

```
Implement a voice extraction service using the Vercel AI SDK and Anthropic API. Create an API route at /api/voice/extract that accepts a product URL and 1-3 pasted sample emails. Use fetch or an extraction helper to grab text content from the URL, combine it with the samples, and prompt Claude Sonnet to output a structured JSON voice fingerprint (formality, cadence, sign-off style, sentence length, first-person usage, and verbatim excerpts). Store the result in the voice_profiles table. Build a corresponding React settings component allowing founders to view and update their extracted voice profile.
```

3. **Event Ingestion API & Webhook Sinks** — Expose secure REST endpoints and webhook receivers for product events, Stripe, and Clerk to trigger lifecycle evaluation.

```
Create secure server endpoints for event ingestion and webhooks. Implement POST /api/tenants/[id]/events accepting JSON event payloads with bearer token verification. Implement webhook sinks at /api/webhooks/stripe and /api/webhooks/clerk to normalize events like user.signup, subscription.created, and subscription.cancelled into a unified internal event stream. Write a background dispatcher using Inngest or serverless functions that evaluates active lifecycle programs against incoming events, determining when to trigger draft generation.
```

4. **Autonomous Copy Generation & Grading Loop** — Set up an agentic generation loop that drafts email variants, grades them against founder rules, and populates the approval queue.

```
Build an AI generation pipeline that drafts lifecycle emails when triggered by events. For a given trigger, query the tenant's voice profile and prompt Claude Sonnet to generate 3 competing variants (subject lines and body HTML) adhering to 8 named founder rules (humorous, first person, reader-first, ending on a question). Implement a grading step where a secondary LLM call scores each variant against the rules; if a variant falls short, automatically trigger a single rewrite. Store all generated variants in the email_queue with status 'pending_approval' and link them to the founder's review dashboard.
```

5. **Human-in-the-Loop Approval Queue & Sending Integration** — Build the founder approval dashboard and wire verified sending through Resend with tracking links.

```
Create a React dashboard page for the founder approval queue showing pending email variants with highlighted voice excerpts. Add 'Approve', 'Edit', and 'Reject' actions. When a variant is approved, queue it for dispatch via Resend API using the tenant's verified sending domain. Append tracking pixels and rewrite links to route through an open/click tracking handler at /api/track/[id]. Implement state updates to record delivered, opened, and clicked events back into the database.
```

6. **Multivariate Testing Bandit Loop & Reply Classification** — Implement traffic allocation across variants, automated rewriting of losing variations, and inbound email reply classification.

```
Implement a multivariate testing optimizer and reply classification engine. Write a scheduling worker that evaluates performance metrics (open and click rates) across active variants, shifting send allocation shares toward winning variants and commissioning agent rewrites for losers. Additionally, build an inbound email webhook handler for Resend inbound parse at /api/webhooks/inbound-mail that classifies incoming replies (interested, complaint, support request, question) using Claude, drafts an appropriate response in the founder's voice, and places the draft into the approval queue.
```

### Cost vs paying

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

- Custom domain for email subdomain (optional): $12 one-time
- Initial Anthropic API credits for agent loops: $25 one-time
- Total: ~$37 one-time

**Ongoing costs (monthly):**

- Vercel Hobby / Pro Hosting: $0-20/mo
- Anthropic API LLM usage for drafting and grading: ~$15/mo
- Resend Email API usage: $0/mo (free tier up to 3k)
- Total: ~$15-35/mo

- Paying for the SaaS instead: $99 / mo
- Build time: 45-60 hours
- AI tool credits: ~$20 (Claude Pro / API credits)
- Break-even: 1 month vs Starter plan

## Sources

- [Mara Official Website & Documentation](https://hiremara.com)
- [Mara Pricing & Program Specifications](https://hiremara.com/pricing)