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

> Your Team's AI-Powered Inbox for Gmail

- Site: https://gmelius.com
- Category: SaaS / Email Collaboration
- Verdict: **Serious undertaking** (42/100 vibecodeable)
- Estimated effort: 6-8 weeks of full-time development

## Verdict

You can build a standalone web app clone of the shared inbox and AI assistant features, but fighting the Gmail DOM extension layer makes it a serious undertaking.

Building a clone that mimics the shared inbox, AI drafting, and kanban features as a standalone SaaS dashboard is entirely feasible with AI coding agents. However, replicating it as a true overlay inside Gmail via a browser extension means constantly wrestling with Google's obfuscated React DOM structure, strict OAuth verification quotas, and fragile content scripts that break whenever Google pushes a UI update. Furthermore, keeping real-time shared draft states synchronized across team members without race conditions requires solid backend infrastructure.

### What you can't replicate

- The official Google Partner relationship and frictionless installation footprint inside native Gmail
- Enterprise security compliance certifications (SOC 2 Type II, HIPAA BAA)
- The massive historical user trust and existing 10,000+ team customer base

## What it does

Gmelius turns standard Gmail into a collaborative workspace with shared inboxes, AI draft assistants, automation rules, and team analytics.

### Core features

- Gmail DOM injection & overlay extension
- AI reply generation and context indexing via Gemini
- Real-time shared inboxes and synchronized Gmail labels
- Internal collaboration (shared drafts, email notes, @mentions)
- Automation rules engine (round-robin assignment, SLA tracking)
- Team workload and performance analytics dashboards

## The business

### Pricing

- Meli: $19/mo — AI personal assistant for Gmail & Google Workspace
- Growth: $25/mo — AI assistants and collaboration for small teams
- Pro: $40/mo — Inboxes on autopilot with higher usage caps
- Enterprise: Custom — Bespoke AI and integrations with no usage caps

### Funding

$2.35M raised.
- Seed Round (2019)
Investors: Y Combinator, Fongit Seed Invest, ACE Investment Partners, Swiss ICT Investor Club (SICTIC)

Founded 2016.
Team size: ~18.

## The hard parts

- Maintaining a browser extension overlay against frequent breaking Gmail DOM updates
- Deep Google Workspace OAuth integration and complying with strict verification scopes
- Real-time synchronization of shared email threads and presence without race conditions
- Securely indexing massive historical email context into LLMs while keeping token costs low

## How to vibe code Gmelius

### Prerequisites

- Node.js (free): Required runtime for the Next.js and TypeScript full-stack environment.
- Google Cloud Console Account (free): Required to configure OAuth credentials and Gmail API access scopes.
- GitHub (free): Source control and automated deployment pipeline integration.

### Recommended AI tools

- Claude Code: Best-in-class agentic coding tool for scaffolding complex multi-file Next.js apps, setting up database schemas, and writing intricate API integrations.
- Cursor: Ideal for iterative UI work, reviewing component diffs, and refining Tailwind styling across dashboard views.

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui
- Backend: Next.js App Router API Routes
- Database: Supabase (PostgreSQL with real-time subscriptions)
- Auth: better-auth
- Payments: Stripe
- Other: Gemini API for AI drafting and triage, Google APIs for email ingestion and sync

### Hosting

- Vercel (Hosting the Next.js web application dashboard and serverless API endpoints): $0-20/mo
- Supabase (Hosting PostgreSQL database, user profiles, and real-time thread synchronization): $0-25/mo

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize the Next.js project with Tailwind CSS, configure Supabase PostgreSQL tables for users, workspaces, shared inboxes, threads, messages, and automation rules.

```
Initialize a new Next.js project with TypeScript, Tailwind CSS, and App Router. Set up Supabase client connections and create a robust database schema using SQL migrations for: users, workspaces, workspace_members, shared_inboxes, threads (id, subject, snippet, status, assigned_to_id, workspace_id), messages (id, thread_id, sender, recipient, body, timestamp), shared_labels, and automation_rules. Include foreign key constraints, indexes on thread status and workspace_id, and Row Level Security (RLS) policies ensuring users only access workspaces they belong to. Provide complete SQL files and TypeScript type definitions.
```

2. **Authentication & Workspace Management** — Implement authentication via better-auth and build multi-tenant workspace creation, team member invitations, and role management.

```
Implement better-auth inside the Next.js app supporting email/password and Google OAuth login. Build workspace onboarding flows where a user can create a team, invite members via email, and assign roles (admin, agent). Create middleware to protect dashboard routes and verify workspace membership before serving data. Include React components for the login page, signup page, team settings, and member management table with shadcn/ui.
```

3. **Google Workspace & Gmail API Ingestion** — Build backend sync services to connect user Gmail accounts via OAuth, ingest email threads, and mirror them into the shared inbox database.

```
Build a secure Google OAuth integration that requests Gmail read/write/modify scopes (https://www.googleapis.com/auth/gmail.modify). Implement server-side API routes to fetch user threads, parse message payloads (headers, body, snippets), and store them into the Supabase threads and messages tables. Set up a webhook or polling mechanism to ingest new incoming emails in real time. Handle token refreshing securely and store encrypted refresh tokens in the database.
```

4. **AI Reply Assistant & Sorting Engine** — Integrate the Gemini API to analyze incoming messages, generate contextual draft replies based on tone, and auto-classify emails into shared labels.

```
Integrate the Google Gemini API (via @google/genai) to build an AI assistant service. Create server actions that analyze incoming thread messages, extract intent, classify them into appropriate categories/labels, and generate contextual draft replies in the user's tone. Build a UI component inside the thread view allowing users to click 'Generate with Meli', review the AI draft in real time, and insert it into the reply box.
```

5. **Real-time Collaboration & Shared Inbox UI** — Develop the core shared inbox dashboard featuring real-time thread synchronization, assignment dropdowns, inline email notes, and @mentions.

```
Build a polished Gmail-style shared inbox dashboard in Next.js using shadcn/ui. Implement a three-pane layout: sidebar for shared inboxes and labels, middle pane for thread list with real-time Supabase subscriptions, and right pane for the active thread view. Add features for one-click assignment of threads to team members, status toggling (open, pending, closed), shared email drafts, and inline @mention notes that update in real time across connected clients.
```

6. **Automation Rules & SLA Analytics** — Create an automation rules engine for round-robin assignment and build performance analytics dashboards tracking response times and resolution SLAs.

```
Build an automation rules engine that evaluates incoming threads against user-defined conditions (e.g., if subject contains 'Billing', auto-assign to finance team using round-robin distribution and apply the 'Billing' label). Implement a background cron job or API endpoint to evaluate SLA response times and flag breached threads. Build an Analytics dashboard page with charts (using Recharts) displaying team workload, average response times, resolution rates, and conversation volume over customizable date windows.
```

### Cost vs paying

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

- AI Coding Assistant Subscriptions: $40
- Custom Domain: $12/yr
- Total: ~$52 one-time

**Ongoing costs (monthly):**

- Vercel Hobby/Pro Hosting: $0-20/mo
- Supabase Database: $0-25/mo
- Gemini API Usage: $5-15/mo
- Total: ~$5-60/mo

- Paying for the SaaS instead: $25/mo per user (Growth plan)
- Build time: 80-120 hours
- AI tool credits: $40 (Claude Pro / Cursor)
- Break-even: 2 months for a small team of users

## Sources

- [Gmelius Official Website & Pricing](https://gmelius.com)
- [Gmelius Pricing and Plans Page](https://gmelius.com/pricing)