SaaS & Operations

Zendesk charges $49/agent/month (professional plan). Intercom charges $39/user/month (standard plan). HubSpot Service Hub charges $50/user/month. If you've got a three-person support team and each one handles 10–20 tickets per day, you're paying $1,764–$1,800/year just for the right to reply to emails. Scale that to 10 agents and you're at $5,880/year. Add on the fact that most SaaS don't have 10 people doing full-time support (they have 3–4 people managing 50–100 tickets/day), and you're still burning $1,500–$2,000/month on software that does one job: organizing inbound messages and tracking who replied to what.

For teams <50 tickets/day, there's a better way. Build a custom support dashboard on Supabase. One ticket table. One Postgres view for per-agent workload. One React component to drag tickets through a kanban board. Integrate it with Gmail or Plain (a lightweight alternative to Intercom) for richer inbound handling. Costs: $0/month software, 4–8 hours of build time once, 2 hours/month for maintenance. Savings: $15K–$25K/year. This is the pattern Aidxn builds for SaaS teams under 100 employees. Let's walk the trade-offs, the schema, the integration strategy, and when you should still buy SaaS instead.

Why SaaS Support Tools Cost So Much

The per-seat tax is the business model

Zendesk, Intercom, and HubSpot don't charge per ticket. They charge per agent because agents are the variable you can't hide. A support tool is fundamentally a database with user-access controls — the software cost is server infrastructure (almost free at SaaS scale). But agents are humans who need training, management, and oversight. Zendesk and Intercom sell management dashboards, reporting, and escalation workflows that help you hire fewer agents and keep them productive. They're not selling a database; they're selling organizational leverage. For a 50-person company with 10 support agents, that leverage is worth $6K/year. For a 20-person company with 2 support agents, it's not. You're paying Zendesk's enterprise tax because they won't build a 2-agent product.

Most small SaaS don't use 50% of the features

Zendesk Professional includes macros, routing rules, time tracking, canned responses, and a mobile app. Most teams use: ticket assignment, a reply form, and a search. Intercom includes live chat, a knowledge base, and AI bots. Small teams use: email ingest and ticket history. You're paying for automation features designed for teams with 50+ daily tickets and complex escalation workflows. If your average customer question takes 5 minutes to answer and you get 30 tickets/day, you don't need routing rules or SLA tracking. You need a table and a form.

Zendesk vs Intercom vs Plain vs Custom

Zendesk (Professional: $49/agent/month)

Pros: mature, integrates with everything, best-in-class reporting. Cons: overkill for small teams, expensive at scale, steep learning curve, requires dedicated ticket number sequencing. Best for: 10+ support agents, complex routing, high-volume SaaS (Stripe, Twilio, etc.).

Intercom (Standard: $39/user/month)

Pros: modern UI, includes live chat, bot-building, good for product-team integration. Cons: also per-seat, invasive on-page embeds, expensive when you scale. Best for: B2C apps that need in-app messaging, teams wanting omnichannel (chat + email + help center).

Plain (Free tier available, Pro: $99/month)

Pros: delightful UI, best-in-class for email, no per-seat pricing (flat-rate team plan). Cons: no custom integrations yet, smaller ecosystem. Best for: teams wanting email-first support without agent-tax. Halfway between DIY and enterprise.

Custom (Supabase + React: $0/month)

Pros: no recurring cost, you own the data, infinite customization, integrates where you want. Cons: 8–16 hours of build time upfront, you own maintenance, no AI-powered routing (yet), requires dev team. Best for: teams <50 tickets/day, SaaS founders who code, products where support is a strategic advantage (high-touch SaaS).

When Custom Beats SaaS (The Math)

The breakeven point

Zendesk Professional: $49/agent/month. For a 3-person team, that's $1,764/year. Supabase custom build: 8 hours at $150/hr = $1,200 (one-time), then ~$100/year for Supabase usage and Vercel hosting. You break even after year one. In year two, you save $1,664. In year five, you've saved $8,000 without adding agents. Add two more agents and Zendesk costs jump to $2,940/year (still assuming 3 agents; real orgs add people). Custom still costs ~$100/year. The savings multiply as you hire.

Scaling math: 50 to 200 tickets/day

50 tickets/day = 1 agent, full-time. Zendesk: $588/year. Custom: $100/year. Savings: $488/year (small).
100 tickets/day = 2 agents. Zendesk: $1,176/year. Custom: $100/year. Savings: $1,076/year.
200 tickets/day = 4 agents. Zendesk: $2,352/year. Custom: $200/year (higher Supabase usage). Savings: $2,152/year.

The ROI peaks between 2–4 agents. Once you're at 10+ agents, Zendesk's enterprise features (routing, automation, SLA tracking) start justifying the cost, and custom becomes a liability because you're maintaining someone's full-time responsibility.

The Custom Supabase Schema (Email + Tickets)

tickets table

`id` (uuid, primary key)
`ticket_number` (integer, auto-increment) — user-facing #1001, #1002, etc. for email replies
`customer_email` (text) — who is contacting you
`subject` (text) — one-liner
`status` (enum: 'new', 'open', 'replied', 'waiting', 'closed') — kanban column
`priority` (enum: 'low', 'normal', 'high', 'urgent') — visual sorting
`assigned_to` (uuid, foreign key to auth.users) — which agent owns it
`created_at` (timestamp) — inbound time
`updated_at` (timestamp) — last activity
`last_customer_message_at` (timestamp) — when did the customer last write? (if NULL, you're waiting for them)
`resolved_at` (timestamp) — when was it closed

ticket_messages table

`id` (uuid)
`ticket_id` (uuid, foreign key)
`author_type` (enum: 'customer', 'agent') — who wrote this
`author_id` (uuid or text email) — customer email or agent user_id
`body` (text) — the message
`created_at` (timestamp)

Automation: Email ingest via webhook

Use Mailgun or SendGrid webhooks to ingest inbound emails. On new email: create or update ticket, add message, set status to 'new'. Agent replies in your UI, you POST to Mailgun to send the reply, record it in ticket_messages. Alternatively, use Plain's API if you want richer features (thread detection, spam filtering) but need custom UI. The schema stays the same; you're just plugging in a different source.

The Dashboard (React Component)

Build a kanban board: columns for 'new', 'open', 'replied', 'waiting', 'closed'. Drag-drop to change status. Click a ticket to see the thread. Reply field at the bottom posts to ticket_messages and sends via your email provider. That's 80% of what your team needs. Add a search bar, a filter for "assigned_to = me", and a "oldest first" sort for SLA compliance. Total build: 4–6 hours with React + shadcn. Supabase realtime listeners so when one agent closes a ticket, others see it instantly.

Example query structure: `SELECT * FROM tickets WHERE status != 'closed' ORDER BY priority DESC, updated_at ASC`. Render as kanban columns using `group_by(status)`. Each card shows customer name, subject, time since last update, and assigned agent. Click to open a side panel with full thread and reply form.

Integration Strategy (Plain, Front, or Gmail)

Gmail + custom webhook (cheapest, most flexible)

Forward all support emails to a dedicated Gmail address. Set up SMTP forwarding or use Zapier to push inbound emails to your Supabase webhook. When agent replies in your dashboard, POST to Gmail API or Mailgun to send. Cost: $0 extra (you already pay for Gmail). Downside: no read receipts, threading is manual.

Plain (best email experience, no custom work)

Use Plain's API + webhooks. They handle email threading, attachment uploads, and spam filtering. You build the UI on top of their API. Cost: $99/month (flat-rate, not per-seat). For a team of 3, this is cheaper than Zendesk. Their API is a joy compared to Mailgun's complexity.

Supabase + Front (balanced)

Front is the modern Zendesk — team inbox for emails. Their API is solid. Build your dashboard to query Supabase, but use Front's webhooks to ingest. Costs: $99/team/month (Front, flat rate) + $0 (custom Supabase UI). Total: $99/month vs. $147/month (Zendesk + Intercom).

Five Reasons to Buy SaaS Instead

1. Your team isn't technical

If your support team has no developers, custom is a headache. You're dependent on an engineer to deploy. Maintenance becomes a support burden. Buy SaaS.

2. You need AI

Zendesk and Intercom now offer AI ticket classification, suggested responses, and chatbots. Custom integration of AI (Claude API) is possible but requires ongoing tuning. If you want AI routing out of the box, SaaS wins.

3. You're selling to enterprises

Enterprise customers expect SOC2, GDPR compliance, audit logs, and data residency. Supabase supports this, but proving it requires documentation. SaaS tools have the paperwork ready.

4. Your support volume is 500+ tickets/day

At that scale, custom becomes a liability. You need dedicated ops, routing logic, and escalation workflows. Zendesk is cheaper than hiring someone.

5. You want a knowledge base and community forum

Zendesk and Intercom include self-service tools. Building custom is 40+ hours. Not worth it unless your product demands it.

The Bottom Line

Zendesk and Intercom dominate because they sell to enterprises willing to pay per-seat. For SaaS <$500K ARR with 2–4 support agents, they're overpriced. A custom Supabase ticket table + React dashboard + Plain integration saves $15K–$25K/year with zero recurring cost. Build it once, maintain it in 2 hours/month. The tradeoff: you need a developer on staff and you own the tech debt. But if you're reading an Aidxn blog, you probably code. This is where Aidxn builds bespoke support infrastructure — we scaffold the Supabase schema, wire up email ingest via Plain or Mailgun, build the React dashboard, and hand you a maintainable codebase that scales to 500+ tickets/day without adding cost. Clients typically move from $150–200/month SaaS bills to $0/month within 3 months of go-live. If you're paying for Zendesk or Intercom today and handling <50 tickets/day, you're in the zone where custom wins. Read more about scaling your distribution — once your support system is tight, growth stops being a bottleneck.