How to Build a Customer Support Portal with Greta

TL;DR: Building a customer support portal with Greta is achievable in 4--6 days. Core scope: ticket submission, status tracking for customers, agent inbox, knowledge base with search, customer-agent messaging, SLA tracking. Replaces $50--$500/month spent on Zendesk, Intercom, Freshdesk for indie SaaS that want owned infrastructure and customization. This guide covers the data model, the build sequence, the AI-powered automation that genuinely helps (auto-categorization, suggested replies, knowledge base search), integration with email and existing tools, and the operational discipline that determines whether your support portal is helpful or another forgotten tool.

Introduction

Customer support tools dominate SaaS tool stacks. Zendesk at $55--$215/user/month. Intercom at $39--$139/user/month plus AI features. Freshdesk at $15--$79/user/month. HelpScout at $20--$50/user/month. For indie SaaS with 1--3 support people, these tools represent significant cost and lock-in to generic workflows that often don't match how the founder actually wants to handle support.

Building a custom customer support portal with Greta takes 4--6 days for the core technical build. You get ticket submission, status tracking for customers, agent inbox, knowledge base with search, customer-agent messaging, SLA tracking, and AI-powered automation. Operational cost drops to $30--$80/month in hosting and AI API costs. More importantly, the workflow fits your actual support process instead of forcing your process to fit Zendesk's.

This guide covers the realistic build. The data model, the build sequence, the AI-powered features that genuinely help, email integration, and the operational discipline that determines whether your portal becomes a real support system or another tool that fades into disuse.

Why build vs buy

Reasons to build

• Workflow fit --- Generic tools force generic processes; custom builds match yours
• Cost at indie scale --- $30--$80/month vs $200--$1,000/month for commercial tools
• Code ownership --- Real Next.js/React code in GitHub; no platform lock-in
• Integration freedom --- Connect to your existing product database for context
• AI customization --- Train AI on your specific knowledge base
• Customer experience match --- Portal feels like part of your product, not third-party

Reasons to buy

• Mature support workflows you don't want to design from scratch
• Need omnichannel from day one (email + chat + phone + social)
• Enterprise compliance requirements (SOC 2, HIPAA, etc.) with audit trails
• Team larger than 5 agents
• Need advanced reporting and analytics

Honest framing: most indie SaaS at $0--$50K MRR benefit from custom builds. Above $50K MRR, the decision depends on support volume and team size. Above $200K MRR with 5+ support agents, commercial tools often win on scale economics.

Core v1 scope

• Customer ticket submission (web form, with optional email-in)
• Customer portal showing their tickets and status
• Agent inbox with all tickets, filters by status/priority/category
• Ticket detail with conversation thread
• Knowledge base with article CRUD and search
• Public-facing help center (knowledge base + ticket submission)
• Customer-agent messaging within ticket
• Ticket status workflow (open → in progress → resolved → closed)
• SLA timers based on priority
• Email notifications (to customer and agent)

What to skip in v1

• Live chat (defer to v1.1; email-style messaging suffices for v1)
• Multi-channel intake (email + web in v1; phone/social later)
• Team-based assignment with round-robin (single-agent or manual assignment v1)
• Custom ticket forms per category (single form v1)
• Advanced reporting (basic metrics v1)
• Customer satisfaction surveys (defer to v1.1)
• Macros and canned responses (AI suggested replies cover most of this in v1)
• Workflow automation rules engine (simple status flows v1)

The data model

• Customer (id, user_id, email, name, subscription_tier, lifetime_value)
• Ticket (id, customer_id, subject, description, status, priority, category, assigned_to, created_at, first_response_at, resolved_at)
• Message (id, ticket_id, sender_id, sender_type, body, created_at)
• Agent (id, name, email, role)
• Article (id, title, slug, body, category, tags, published_at, view_count)
• Category (id, name, parent_id, description)
• TicketTag (ticket_id, tag) --- many-to-many tags for tickets
• SLAConfig (priority, first_response_minutes, resolution_minutes)

The 4--6 day build sequence

Day 1: Scaffolding, customer portal, ticket submission

• Hour 1: PRD (workflow specifics, priority levels, SLA targets)
• Hour 2--3: Data model setup (Customer, Ticket, Message, Agent)
• Hour 4--5: Customer portal layout (auth, navigation)
• Hour 6--8: Ticket submission form (subject, description, category, priority, attachments)

Day 2: Customer-side ticket viewing

• Hour 1--3: Customer ticket list with status filter
• Hour 4--5: Ticket detail with conversation thread
• Hour 6--7: Customer reply functionality
• Hour 8: Status indicators and SLA visibility

Day 3: Agent inbox and ticket management

• Hour 1--3: Agent inbox UI (all tickets, filters, sort)
• Hour 4--5: Ticket detail for agent view with full customer context
• Hour 6--7: Status workflow controls (assign, change priority, change status)
• Hour 8: Internal notes (agent-only messages on ticket)

Day 4: Knowledge base

• Hour 1--3: Article CRUD for admin (create, edit, publish, categorize)
• Hour 4--5: Public help center (article browsing and search)
• Hour 6--7: Search using Postgres full-text search or Algolia
• Hour 8: Article display with related articles

Day 5: AI features and email integration

• Hour 1--3: AI auto-categorization on ticket submission
• Hour 4--5: AI suggested replies for agents using knowledge base context
• Hour 6--7: Email integration (incoming tickets via email; outgoing notifications)
• Hour 8: SLA timer logic and breach alerts

Day 6: Polish, harden, soft launch

• Hour 1--3: Basic metrics dashboard (open tickets, average response time, SLA compliance)
• Hour 4--5: Empty states, error handling, mobile responsive
• Hour 6--7: RLS and security review (customer can only see own tickets; agents see all)
• Hour 8: Soft launch --- redirect support emails to portal

AI features that genuinely help

Auto-categorization

• On ticket submission, classify by category (billing, technical, feature request, etc.)
• Pass ticket description to LLM with category list
• Returns category; saves on ticket record
• Reduces manual triage time significantly
• Cost: ~$0.001 per ticket; negligible at indie scale

Suggested replies for agents

• When agent opens ticket, AI retrieves relevant knowledge base articles via embedding search
• AI generates suggested reply incorporating article content
• Agent reviews, edits, sends (don't auto-send AI replies)
• Significantly reduces typing time; consistent answers across team

Smart article suggestions to customer

• On ticket submission, search knowledge base for related articles
• Show "You might find these helpful" before submission
• Deflects significant percentage of tickets
• Customer self-serves; ticket volume decreases

Ticket summarization

• Long ticket threads summarized for new agents picking up the case
• Especially helpful for handoffs and escalations
• Generated on demand; not pre-computed

Sentiment detection

• Flag tickets with frustrated customer language
• Prioritize emotional escalations
• Use sparingly --- false positives create noise

Email integration patterns

Inbound: ticket-from-email

• Set up support@yourcompany.com forwarded to webhook (use Resend inbound, Postmark inbound, or AWS SES)
• Webhook receives email payload
• Parse sender, subject, body; create new ticket or append to existing thread
• Match by ticket ID in subject line (for replies)
• Handle attachments (store in Supabase Storage)

Outbound: notifications via email

• Customer receives email when ticket status changes
• Customer receives email when agent replies
• Agent receives email for high-priority tickets
• Reply-to address routes back to ticket via parsing

Email thread management

• Include ticket ID in subject (e.g., "[Ticket #1234] Your subject")
• Strip quoted reply content when appending to thread
• Handle email signatures (don't include in ticket display)

SLA tracking

• Define SLA targets per priority (e.g., urgent: 1 hour first response; normal: 24 hours)
• First response SLA --- time from ticket creation to first agent message
• Resolution SLA --- time from ticket creation to status = resolved
• Display SLA timer on ticket for agent visibility
• Alert on breach (Slack, email to manager)
• Pause SLA timers when waiting on customer (status = pending customer)
• Track SLA compliance metrics over time

Metrics that matter

Common Mistakes Building Support Portals

• Skipping the knowledge base --- KB is your ticket deflection. Build it from day one, even with 3 articles.
• Building chat in v1 --- Chat changes operational model significantly. Email-style messaging is simpler and effective.
• Not tracking SLAs --- Without measurement, response times drift. Track from day 1.
• Auto-sending AI replies --- AI suggests; humans send. Auto-send produces embarrassing edge cases.
• Ignoring email integration --- Most customers prefer email over portals. Email-in is non-optional.
• Generic ticket categories --- Categories specific to your product yield better triage.
• Skipping customer context in agent view --- Show subscription tier, recent activity, account age. Context = better support.
• Treating support as separate from product --- Support reveals product issues. Connect ticket data to product analytics.
• Hiring support before measuring --- Measure ticket volume; calibrate hiring to actual demand.
• Overpolishing the portal --- Customers care about getting help, not UI polish. Function over form.

Frequently Asked Questions

Q1: Should I really build this instead of using Zendesk? Depends on volume and team size. Indie SaaS at $0--$50K MRR with 1--2 support people benefit from custom builds. Above $50K MRR with 3+ support agents, evaluate honestly.

Q2: How do I handle attachments in tickets? Supabase Storage for file uploads. Validate file types and size limits server-side. Display attachments inline (images) or with download link (other files).

Q3: What about live chat? Defer to v1.1 or skip entirely. Live chat changes operational model --- requires staffing during business hours. Email-style messaging via portal is asynchronous and works fine for most indie SaaS.

Q4: Can the AI features handle multiple languages? Yes --- LLMs are multilingual. Auto-categorization and suggested replies work across languages. Knowledge base articles need translation if you support multiple languages.

Q5: What about phone support? Most indie SaaS skip phone. If required, integrate with a service like Twilio Voice or stick with commercial tools. Phone adds significant operational burden.

Q6: How do I handle escalations? Define escalation criteria (priority, age, customer tier). Notify designated escalation contact (often founder for early-stage SaaS). Track escalation rate as separate metric.

Q7: What if customers don't use the portal and just email? Support email forwarded to portal webhook captures all emails as tickets. Customers don't need to know about the portal; the portal is your back-office tool.

Conclusion

• Customer support portal with Greta: 4--6 days for core build. Replaces $50--$500/month of commercial tooling for indie SaaS scale teams.
• Core scope: ticket submission, status tracking, agent inbox, knowledge base, customer-agent messaging, SLA tracking, AI features (auto-categorization, suggested replies, article suggestions).
• AI features genuinely help. Auto-categorization saves triage time. Suggested replies speed responses. Smart article suggestions deflect tickets. Cost: pennies per ticket at indie scale.
• Email integration is non-optional. Most customers prefer email. Inbound parsing via Resend/Postmark/SES; outbound notifications via Resend. Email + portal coexist.

If you're an indie SaaS founder and your support is currently in shared Gmail/email, a custom support portal is a high-ROI build. Start with 4--6 days to ship core functionality. Migrate support email to portal webhook in week 2. Add AI features in week 3. By month 2, your team operates in a system that fits your workflow at a fraction of commercial cost. The investment pays back in 3--6 months through subscription savings; the workflow fit pays back forever in support team efficiency and customer satisfaction. The custom support portal is one of the highest-ROI internal builds for indie SaaS in 2026 --- execute deliberately.