The Build Temptation

Every technical founder has the same thought at some point: "I could build this myself." For AI support specifically, it seems straightforward. Train a classifier on support data, build some routing logic, connect a few APIs. How hard could it be?

I've watched teams go down this path. Here's what actually happens.

What Building Looks Like

Month 1-2: Data collection and model training. You need labeled training data. Thousands of support messages tagged with their intent. If you have historical tickets, great — someone has to label them. If you don't, you're writing synthetic examples or scraping public datasets.

Training a classifier takes ML expertise. Fine-tuning a model on your intent taxonomy, evaluating accuracy, handling edge cases, dealing with class imbalance (some intents are rare), and iterating on the training data. This is 1-2 months of focused engineering time.

Month 3-4: Building the routing layer. The classifier tells you what the message is about. Now you need logic that decides what to do about it. Routing rules, confidence thresholds, fallback behavior, integration with Slack/GitHub/email/whatever. Plus a UI for non-engineers to manage rules without touching code.

Month 5-6: Building the widget and API. You need a way for customers to send messages and receive responses. A chat widget with real-time messaging, session management, conversation history, and mobile responsiveness. An API for programmatic access. Authentication, rate limiting, error handling.

Month 7+: Maintenance, forever. The model drifts as customer language changes. New intents emerge. Integrations break when third-party APIs change. The widget needs design updates. Security patches. Performance optimization. Monitoring.

The Real Cost

Let's add it up for a startup with 2 engineers working on this half-time:

Engineering time: 2 engineers × 50% allocation × 6 months × $150K/year loaded cost = $75,000

Infrastructure: GPU compute for training ($500 to $2,000), cloud hosting for inference ($100 to $500/month), databases, monitoring. Year 1: $5,000 to $10,000.

Opportunity cost: Those 2 engineers spent 6 months not building your actual product. What features, sales, or growth did you miss?

Total year-1 cost: $80,000 to $90,000+ plus opportunity cost.

Ongoing maintenance: 10 to 20% of one engineer's time indefinitely. $15,000 to $30,000/year.

What Buying Looks Like

Day 1: Sign up. Get API key. Install widget. Day 1 (still): Create 5-8 routing rules. Day 1 (still): Connect Slack. Test.

Time to value: 15 minutes to a few hours, depending on how many rules you want.

Cost at 500 messages/month: $75 to $125/month = $900 to $1,500/year.

Maintenance: Zero. The provider handles model updates, infrastructure, and security.

When Building Makes Sense

Building your own AI support makes sense if:

You have genuinely unique classification needs. Your industry has intent categories that no general classifier covers, AND you have the labeled data to train on. This is rare — 315 pre-built intents cover most businesses.

AI support is your product. If you're building a support tool for others to use, obviously you need to build the core yourself.

You have a massive ML team with spare capacity. If you're Google or Stripe and have ML engineers who are between projects, the build cost is lower because the talent is already on payroll.

Compliance requires full data control. Some regulated industries require that no customer data leaves your infrastructure. This rules out SaaS tools unless they offer on-premise deployment.

When Buying Wins (Almost Always)

For 95% of companies, buying is the right call:

• You get 92% accuracy from day one without training a model
• You skip 6 months of build time
• You save $80,000+ in year-1 costs
• You avoid the ongoing maintenance burden
• You can always switch later — the switching cost from one SaaS tool to another is days, not months

The classic mistake is overestimating how unique your support needs are. "Our customers ask very specific technical questions" — sure, but the classification model doesn't need to answer the questions. It just needs to identify the intent (billing, bug, feature request, technical question) and route accordingly. That's a solved problem.

The Hybrid Path

Some teams take a middle road: buy classification for the standard intents and build custom logic for the unique parts. Use an API to classify messages, then run the results through your own routing engine with business-specific rules.

This gives you the classification accuracy of a pre-trained model with the flexibility of custom routing. Build time: days, not months. Cost: the API fees plus your routing logic (which is just application code, not ML).

If you're going to build anything, build the routing and workflow layer — the part that's unique to your business. Buy the classification — the part that's a commodity.

The Decision Framework

Ask yourself two questions:

1. Is AI classification a competitive advantage for our business? If yes, consider building. If no (it almost never is), buy.

1. Do we have 6 months and $80K to invest in something that isn't our core product? If yes and the answer to #1 was also yes, build. Otherwise, buy and ship your actual product instead.