Every team building with AI hits the same fork in the road. Do you plug in Intercom Fin, Voiceflow, or some "AI chatbot in 5 minutes" SaaS? Or do you build a custom agent on top of the OpenAI/Anthropic APIs, wired into your own stack?
The wrong answer costs you either six months of engineering time or a system that hits a wall the moment you ask it to do something real. Here's the framework I use with clients before writing a line of code.
Start with what the bot actually needs to do
Most "chatbot" projects are secretly two very different problems.
Problem A: Answer questions. "What's your refund policy?" "How do I reset my password?" This is retrieval over a knowledge base. Off-the-shelf tools are excellent here.
Problem B: Take actions. "Reschedule my appointment." "Check my order status, then issue a partial refund and log it in the CRM." This requires the bot to call your systems, chain steps, handle failures, and respect business logic.
If you're 90% Problem A, buy. If you're heavy on Problem B, buying often becomes a trap - you'll spend more fighting the platform's limits than you'd spend building.
The real cost comparison
SaaS chatbots look cheap until you scale. The honest math:
Off-the-shelf: $50-$1,500/month depending on seats and message volume. Fast setup (days). But you pay per resolution or per message, and costs climb non-linearly as usage grows. Customization is capped at whatever the vendor exposes.
Custom agent: Higher upfront (a few weeks of build time or an agency engagement), then you pay raw model tokens - often 5-20x cheaper per interaction at volume. You own the logic, the data, and the roadmap.
The crossover point usually lands around consistent daily volume plus any requirement the platform doesn't natively support. One integration the vendor charges $500/month for, or simply can't do, and the buy option stops being cheap.
Where off-the-shelf breaks
I've watched teams burn months trying to force a no-code platform to do things it was never built for:
- Multi-step workflows that branch on live data
- Writing back to systems (not just reading FAQs)
- Custom auth and per-user context
- Precise control over tone, escalation, and fallback behavior
- Compliance requirements around where data lives
When you hit these, you're either stuck or paying enterprise pricing for a feature that's still someone else's roadmap.
Where custom is overkill
Going custom too early is the opposite mistake. If your use case is a support FAQ bot for a 10-person startup, spinning up your own agent, vector store, eval harness, and monitoring is a waste. Buy the SaaS, ship this week, revisit in six months.
Complexity you don't need is a liability, not a flex.
The middle path most people miss
The interesting option isn't build or buy - it's an orchestration layer that lets you buy the model and build the logic without a full engineering team. This is where a tool like n8n earns its keep.
You get an LLM's reasoning, your own tool integrations, and visual workflow control - a custom agent's flexibility at a fraction of the build cost.
Here's a stripped-down version of an agent node that decides whether to answer directly or call a tool:
// n8n Function node: route the user message
const message = $input.first().json.userMessage;
const response = await this.helpers.httpRequest({
method: 'POST',
url: 'https://api.openai.com/v1/chat/completions',
headers: { Authorization: `Bearer ${$env.OPENAI_API_KEY}` },
body: {
model: 'gpt-4o-mini',
messages: [
{ role: 'system', content: 'You are a support agent. If the user asks about an order, respond with JSON {"action":"lookup_order","orderId":"..."}. Otherwise answer directly.' },
{ role: 'user', content: message }
],
response_format: { type: 'json_object' }
},
json: true
});
const result = JSON.parse(response.choices[0].message.content);
// Branch: hand off to the order-lookup workflow or reply directly
return [{ json: result }];
From there, a Switch node routes lookup_order to your database, formats the result, and feeds it back to the model for a natural reply. You've built Problem B behavior without a bespoke backend.
The decision checklist
Run your project through these questions:
- Is it mostly answering or mostly doing? Answering leans buy. Doing leans build.
- How many systems must it touch? Three or more integrations tilts toward custom or n8n.
- What's your daily volume in 12 months? High volume rewards owning your token costs.
- Do you have data or compliance constraints? Constraints usually kill off-the-shelf.
- How unique is your logic? Generic = buy. Differentiated = build.
- What can you maintain? Be honest about your team's bandwidth.
If you answered "buy" to most: grab a platform and ship. If you answered "build" to most but lack a full dev team, the n8n middle path is your friend. If you're a serious Problem B case at scale, invest in a proper custom agent.
The takeaway
Build vs buy isn't ideology - it's a fit question. Match the tool to the complexity, the volume, and the team you actually have. Start with the cheapest thing that clears your requirements, and only graduate to custom when the platform is the thing holding you back.
The expensive mistake is committing to either extreme before you've defined what the bot needs to do. Define that first. The answer usually writes itself.
Originally published at getmichaelai.com
Top comments (0)