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

> AI-first customer service and employee experience platform

- Site: https://zendesk.com
- Category: Customer Support SaaS
- Platforms: Web app
- Verdict: **Solid side project** (68/100 vibecodeable)
- Estimated effort: 3-4 weeks of focused building

## Verdict

Build a focused subset with core ticketing, a knowledge base, and an AI copilot, but expect a multi-week grind handling email ingestion webhooks and real-time state sync.

Replicating a multi-billion dollar enterprise support desk is an enormous undertaking, but vibecoding a clean internal helpdesk clone with Next.js, Turso, and Claude Code is entirely achievable. The single biggest catch is robust inbound email parsing and IMAP thread reconciliation, which invariably exposes edge cases with MIME parsing, missing headers, and HTML-to-text sanitization. If you need a real omnichannel routing engine with telephony and 1,800 marketplace integrations, pay for Zendesk; if you want a custom internal ticketing tool with AI summaries for your startup, this weekend build project will pay for itself.

### What you can't replicate

- The 1,800+ app marketplace and legacy partner integrations
- Enterprise compliance tiers (SOC2, HIPAA, audit logging)
- Global telecom carrier infrastructure for carrier-grade telephony and IVR voice routing

## What it does

Zendesk unifies multi-channel customer communications including email, live chat, messaging, and knowledge bases into a single intelligent workspace with autonomous AI agents and ticketing.

### Core features

- Omnichannel ticketing ingestion (email parsing via IMAP/SMTP, live chat WebSockets)
- Agent workspace with real-time ticket triage, status management, and internal notes
- AI-powered agent assist and automated response generator using RAG over a knowledge base
- Deterministic routing rules, triggers, automations, and SLA breach monitors
- Self-service customer help center with article management and feedback voting
- Basic quality assurance (QA) scoring rubric for agent interactions
- Role-based access control (RBAC) separating admins, agents, and end-users

## The business

### Pricing

- Support Team: £15/agent/mo
- Suite Team: £45/agent/mo
- Suite Professional: £89/agent/mo
- Suite Enterprise: Custom pricing

### Funding

$145M raised.
- Seed
- Series B
- Series C
- Series D
Investors: Benchmark, Matrix Partners, Devonshire Investors

Founded 2007.
Team size: 5,000 - 7,000.

## The hard parts

- Bi-directional email parsing and reliable IMAP/SMTP webhook loops without dropping inbound attachments or threading replies
- Real-time multi-agent concurrency synchronization for ticket status updates and typing indicators
- Zero-latency RAG vector embedding pipeline for knowledge base retrieval backing autonomous AI agents
- Complex automation engine executing conditional triggers and time-based SLAs in background workers without race conditions

## How to vibe code Zendesk

### Prerequisites

- Node.js (free): Runtime environment for executing the Next.js full-stack application code.
- GitHub (free): Version control repository hosting and deployment hook provider.
- Anthropic API Key (Pay-as-you-go (~$10-20/mo)): Required to power the AI agent assist, auto-summarization, and RAG knowledge base answers.

### Recommended AI tools

- Claude Code: Best-in-class terminal coding agent for scaffolding multi-file relational schemas, api routes, and UI components autonomously.
- Cursor: Ideal AI-native editor for iterative frontend tweaking, managing React components, and reviewing code diffs.

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui
- Backend: Next.js App Router API endpoints and Server Actions
- Database: Turso (SQLite at the edge) with Drizzle ORM
- Auth: better-auth
- Payments: None (Personal use clone)
- Other: Anthropic API for RAG & Copilot, Resend for email parsing webhooks and notifications, Pusher for real-time ticket updates and agent presence

### Hosting

- Vercel (Next.js frontend and serverless API deployment with zero-config GitHub CI/CD.): $0-20/mo
- Turso (Serverless edge SQLite database storing tickets, users, articles, and audit logs.): $0/mo

### Build guide

1. **Scaffold Next.js App, Drizzle Schema & Authentication** — Initialize the Next.js project with Tailwind CSS, configure Drizzle ORM connected to Turso, and set up better-auth with user roles for Admin, Agent, and End-User.

```
Create a new Next.js 16 project with TypeScript, Tailwind CSS, and App Router. Set up Drizzle ORM with Turso as the database driver. Write the complete database schema for users (id, name, email, role: 'admin'|'agent'|'customer'), tickets (id, subject, status: 'open'|'pending'|'solved'|'closed', priority: 'low'|'normal'|'high'|'urgent', assigneeId, customerId, createdAt, updatedAt), ticket_messages (id, ticketId, senderId, body, isInternal), and knowledge_base_articles (id, title, content, authorId, createdAt). Configure better-auth with email/password authentication and role plugin. Ensure database migrations run smoothly against Turso.
```

2. **Build the Unified Agent Workspace Dashboard** — Create the main ticket management dashboard allowing agents to filter, sort, assign, and reply to support tickets in real-time.

```
Build a responsive agent workspace dashboard in Next.js App Router under `/agent/dashboard`. Create a split-pane layout: a left sidebar with filter tabs ('All open', 'Assigned to me', 'Unassigned', 'Pending', 'Solved') and ticket list cards showing subject, priority badge, and customer name; a center pane displaying the conversation timeline with threaded messages and internal notes toggle; and a right sidebar showing customer profile context, ticket tags, and status dropdowns. Implement server actions to update ticket status, assign agents, and post public replies or internal notes. Use shadcn/ui components throughout.
```

3. **Implement RAG Knowledge Base & AI Agent Copilot** — Integrate vector search over knowledge base articles and build an AI Copilot that drafts responses and summarizes long ticket threads using the Anthropic API.

```
Implement a knowledge base article management section under `/kb` with markdown rendering and search. Add vector embeddings support using Turso's vector extension or application-level cosine similarity over article chunks stored in Turso. Build an AI Copilot panel inside the ticket view that uses the Anthropic API to: (1) summarize the conversation thread into 3 bullet points, (2) perform semantic search over KB articles to retrieve relevant troubleshooting steps, and (3) generate a professional draft reply for the agent to review and insert with one click. Handle API errors and streaming responses gracefully.
```

4. **Build Self-Service Customer Portal & Ticket Submission** — Create a customer-facing portal where end-users can browse help articles, submit new support tickets, and track their active request statuses.

```
Create a customer portal at `/portal` where authenticated end-users can view their submitted support tickets, check statuses, and add follow-up replies. Include a clean submission form (`/portal/new`) with fields for subject, category, priority, and description. Implement automatic search suggestions as the user types their subject, recommending relevant KB articles to deflect support volume before ticket creation. Send simulated confirmation notices upon ticket creation.
```

5. **Add Inbound Email Webhook Ingestion** — Configure an API route to receive parsed inbound emails from Resend or Sendgrid webhooks, automatically converting incoming emails into new tickets or appending them to existing threads.

```
Create a secure API webhook endpoint at `/api/webhooks/email` designed to ingest inbound parsed emails from Resend or Sendgrid. Implement robust logic to: (1) extract the sender's email address and match or create a user profile in the database, (2) check the email subject or headers for an existing ticket reference ID to thread the reply, or (3) create a brand new ticket if no reference is found, storing the email body as the initial ticket message. Add signature stripping and basic HTML sanitization. Verify webhook signatures securely and handle parsing edge cases cleanly.
```

6. **Setup Realtime Updates & Polish Workspace** — Integrate Pusher channels to enable live ticket list updates and real-time message broadcasting across active agent browsers without manual refreshes.

```
Integrate Pusher into the Next.js agent workspace to enable real-time collaboration. Whenever a customer submits a ticket, a new reply is added, or an agent updates a ticket status, broadcast an event via Pusher channels. Update the React frontend state instantly so agents see incoming messages and status changes appear live without reloading the page. Add toast notifications for newly assigned tickets and polish UI empty states and loading skeletons.
```

### Cost vs paying

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

- AI Coding Assistant subscription: $20
- Anthropic API credits: $10
- Total: ~$30 one-time

**Ongoing costs (monthly):**

- Vercel Hobby / Turso / Resend free tiers: $0/mo
- Total: $0/mo

- Paying for the SaaS instead: £45 - £89 / agent / mo (Suite Plan)
- Build time: 35-50 hours
- AI tool credits: $20 (Cursor/Claude Pro) + ~$10 API credits
- Break-even: Immediate (saves hundreds per month for small support teams)

## Sources

- [Zendesk Product & AI Platform Overview](https://www.zendesk.com)
- [Zendesk Pricing Plans](https://www.zendesk.com/pricing)
- [Zendesk Developer Documentation - Sunshine Platform](https://developer.zendesk.com)