Last Wednesday, I opened my Zendesk invoice and nearly spit out my coffee. $847 for the month. Our AI chatbot had resolved 652 tickets, which sounds great until you realize we were paying $1.30 per resolution. And that was on top of the $299 base subscription for our 3-seat team.
The kicker? Most of those conversations were dead simple. "What are your hours?" "How do I reset my password?" "Where's my order?" Questions that any decent AI could handle for pennies, not dollars.
So I spent the weekend building our own chatbot using AWS's new Amazon Nova models, Lambda, and DynamoDB. The result? A chatbot that handles the same workload for $12.47 per month. Not per seat. Total.
Let me show you exactly how I did it—and why you probably should too.
The Problem Nobody Talks About: SaaS Chatbots Are Outrageously Expensive
Here's what happened to our costs over 18 months with traditional chatbot solutions:
Month 1-6 (Intercom Fin):
- Base plan: $39/seat × 2 = $78
- AI resolutions: ~400/month × $0.99 = $396
- Monthly total: $474
Month 7-12 (Zendesk Answer Bot):
- Suite Professional: $99/agent × 3 = $297
- Advanced AI add-on: $50/agent × 3 = $150
- AI resolutions beyond included: ~500 × $1.50 = $750
- Monthly total: $1,197
Month 13-18 (Custom AWS Solution):
- Lambda invocations: ~50,000/month = $0.20
- Amazon Nova Lite tokens: ~30M input + 12M output = $9.68
- DynamoDB: Conversation history storage = $2.15
- API Gateway: 50,000 requests = $0.05
- Monthly total: $12.08
That's a 99% cost reduction. And honestly? The AWS version is better. Let me show you why.
The Architecture: Dead Simple, Surprisingly Powerful
I'm not going to lie to you—this isn't a drag-and-drop solution. You need to write some code. But if you can handle basic Python and AWS, you'll have this running in an afternoon.
Here's the full stack:
- Amazon Nova Lite for AI inference ($0.00006 per 1K input tokens, $0.00024 per 1K output)
- Lambda for request handling (first 1M requests free, then $0.20 per 1M)
- DynamoDB for conversation history (25GB free tier, then $0.25 per GB)
- API Gateway for REST API (first 1M requests free, then $3.50 per 1M)
- S3 for knowledge base storage (essentially free at our scale)
The flow is straightforward: User sends message → API Gateway → Lambda → Retrieves context from DynamoDB → Queries Nova with RAG context from S3 → Stores conversation → Returns response.
Real Implementation: Copy-Paste-Customize
Let me give you the actual code I'm running in production. This isn't theoretical—this is what handles our 500+ conversations per month.
Step 1: Lambda Function Handler
import json
import boto3
import os
from datetime import datetime
from decimal import Decimal
bedrock = boto3.client('bedrock-runtime', region_name='us-east-1')
dynamodb = boto3.resource('dynamodb')
conversations_table = dynamodb.Table(os.environ['CONVERSATIONS_TABLE'])
knowledge_base_id = os.environ['KNOWLEDGE_BASE_ID']
def lambda_handler(event, context):
try:
body = json.loads(event['body'])
user_message = body['message']
conversation_id = body.get('conversation_id', generate_conversation_id())
# Retrieve conversation history
history = get_conversation_history(conversation_id)
# Retrieve relevant knowledge base context (RAG)
kb_context = retrieve_knowledge_context(user_message)
# Build prompt with context
system_prompt = f"""You are a helpful customer service assistant for our company.
Context from our knowledge base:
{kb_context}
Conversation history:
{format_history(history)}
Provide helpful, accurate responses based on the context above. If you don't have enough information, offer to escalate to a human agent."""
# Call Amazon Nova Lite via Bedrock
response = bedrock.converse(
modelId="amazon.nova-lite-v1:0",
messages=[
{"role": "user", "content": [{"text": user_message}]}
],
system=[{"text": system_prompt}],
inferenceConfig={
"maxTokens": 500,
"temperature": 0.7,
"topP": 0.9
}
)
assistant_message = response['output']['message']['content'][0]['text']
# Store conversation
store_conversation_turn(conversation_id, user_message, assistant_message)
return {
'statusCode': 200,
'headers': {
'Content-Type': 'application/json',
'Access-Control-Allow-Origin': '*'
},
'body': json.dumps({
'response': assistant_message,
'conversation_id': conversation_id
})
}
except Exception as e:
print(f"Error: {str(e)}")
return {
'statusCode': 500,
'body': json.dumps({'error': 'Internal server error'})
}
def retrieve_knowledge_context(query):
"""Retrieve relevant context from knowledge base using embeddings"""
# In production, I use Amazon Titan Embeddings for semantic search
# For this example, simplified version
bedrock_agent = boto3.client('bedrock-agent-runtime')
response = bedrock_agent.retrieve(
knowledgeBaseId=knowledge_base_id,
retrievalQuery={'text': query},
retrievalConfiguration={
'vectorSearchConfiguration': {
'numberOfResults': 3
}
}
)
contexts = [result['content']['text'] for result in response['retrievalResults']]
return "
".join(contexts)
def get_conversation_history(conversation_id):
"""Retrieve last 5 conversation turns for context"""
response = conversations_table.query(
KeyConditionExpression='conversation_id = :cid',
ExpressionAttributeValues={':cid': conversation_id},
ScanIndexForward=False,
Limit=10 # Last 5 turns = 10 messages
)
return response['Items']
def store_conversation_turn(conversation_id, user_msg, assistant_msg):
"""Store conversation for context and analytics"""
timestamp = datetime.now().isoformat()
# Store user message
conversations_table.put_item(Item={
'conversation_id': conversation_id,
'timestamp': timestamp,
'role': 'user',
'message': user_msg
})
# Store assistant message
conversations_table.put_item(Item={
'conversation_id': conversation_id,
'timestamp': timestamp + '_assistant',
'role': 'assistant',
'message': assistant_msg
})
def format_history(history):
"""Format conversation history for prompt"""
formatted = []
for item in reversed(history):
role = item['role'].capitalize()
message = item['message']
formatted.append(f"{role}: {message}")
return "
".join(formatted)
def generate_conversation_id():
"""Generate unique conversation ID"""
import uuid
return str(uuid.uuid4())
Step 2: DynamoDB Table Schema
# Create with AWS CDK or CloudFormation
# Table: chatbot-conversations
# Partition Key: conversation_id (String)
# Sort Key: timestamp (String)
# TTL: enabled on 'expiry_time' attribute (conversations auto-delete after 90 days)
# GSI for analytics (optional):
# - Index name: timestamp-index
# - Partition key: date (String)
# - Sort key: timestamp (String)
Step 3: Frontend Integration (React)
// Simple chat widget implementation
import React, { useState, useEffect } from 'react';
const ChatWidget = () => {
const [messages, setMessages] = useState([]);
const [input, setInput] = useState('');
const [conversationId, setConversationId] = useState(null);
const [loading, setLoading] = useState(false);
const sendMessage = async () => {
if (!input.trim()) return;
const userMessage = { role: 'user', content: input };
setMessages([...messages, userMessage]);
setInput('');
setLoading(true);
try {
const response = await fetch('https://your-api-gateway-url.execute-api.us-east-1.amazonaws.com/prod/chat', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
message: input,
conversation_id: conversationId
})
});
const data = await response.json();
if (!conversationId) {
setConversationId(data.conversation_id);
}
setMessages([...messages, userMessage, {
role: 'assistant',
content: data.response
}]);
} catch (error) {
console.error('Error:', error);
setMessages([...messages, userMessage, {
role: 'assistant',
content: 'Sorry, I encountered an error. Please try again.'
}]);
} finally {
setLoading(false);
}
};
return (
<div className="chat-widget">
<div className="messages">
{messages.map((msg, idx) => (
<div key={idx} className={`message ${msg.role}`}>
{msg.content}
</div>
))}
{loading && <div className="message assistant loading">Typing...</div>}
</div>
<div className="input-area">
<input
value={input}
onChange={(e) => setInput(e.target.value)}
onKeyPress={(e) => e.key === 'Enter' && sendMessage()}
placeholder="Type your message..."
/>
<button onClick={sendMessage} disabled={loading}>Send</button>
</div>
</div>
);
};
export default ChatWidget;
The Numbers: Why This Actually Works at Scale
I tracked our costs meticulously for 3 months. Here's the real breakdown at different conversation volumes:
At 500 conversations/month (our current volume):
- Average conversation: 4 turns (8 messages total)
- Average tokens per message: 400 input, 200 output
- Total monthly tokens: 500 × 4 × (400 + 200) = 1.2M input, 0.6M output
- Nova Lite cost: (1.2M × $0.00006) + (0.6M × $0.00024) = $0.21
- Lambda invocations: 4,000 × $0.0000002 = $0.0008
- DynamoDB: ~5GB storage + reads = $1.85
- API Gateway: 4,000 requests = $0.014
- Total: $2.07/month
Wait, that's not $12. Here's what I was actually paying for:
- Knowledge Base Retrieval (Bedrock): $8.00
- CloudWatch Logs: $1.50
- S3 for knowledge base: $0.23
- Lambda cold start optimization (provisioned concurrency): $2.00
- Actual monthly bill: $12.03
At 5,000 conversations/month (10x scale):
- Nova Lite cost: $2.10
- Everything else: ~$15.00
- Total: ~$17/month
At 50,000 conversations/month (100x scale):
- Nova Lite cost: $21.00
- Lambda at scale: $4.50
- DynamoDB: $8.50
- Everything else: $12.00
- Total: ~$46/month
Compare this to traditional solutions at these scales:
- Intercom: $39/seat + ($0.99 × 50,000) = $49,539/month
- Zendesk: $297 base + ($1.50 × 48,000) = $72,297/month
The math is absurd. Even at 100x our current scale, we'd pay less than most companies pay for a single seat.
Performance: It's Actually Faster
I ran head-to-head tests against our old Zendesk setup:
Response Times (P95):
- Zendesk Answer Bot: 3.2 seconds
- Our AWS setup: 1.8 seconds
Accuracy (measured by escalation rate):
- Zendesk Answer Bot: 37% escalated to humans
- Our AWS setup: 29% escalated to humans
Why is it faster and more accurate? Two reasons:
- No multi-tenant bottlenecks: We're not sharing compute with thousands of other companies
- Optimized context: We control exactly what context gets fed to the model, so responses are more relevant
The only metric where Zendesk won was time-to-deploy: Their GUI setup took 2 hours. Our custom build took about 6 hours. But that's a one-time cost.
When This Approach Makes Sense (And When It Doesn't)
Let me be honest about the limitations.
Use this approach if:
- You have basic Python/AWS skills or a dev on your team
- You want full control over your AI chatbot behavior
- You're processing 200+ conversations/month (cost breakeven point)
- You need custom integrations with your existing systems
- You're comfortable with some maintenance work
Stick with SaaS if:
- You need a chatbot running tomorrow with zero dev work
- Your team has no technical resources whatsoever
- You're processing fewer than 200 conversations/month
- You want visual analytics dashboards out of the box
- You need multi-language support beyond what Nova provides
The biggest gotcha I've encountered: You're responsible for uptime. With Zendesk, if the chatbot goes down, you call support. With this approach, you're on the hook. I handle this with:
- Lambda monitoring via CloudWatch
- Dead Letter Queues for failed messages
- Fallback to "Let me connect you to a human" for any errors
Migration Guide: From SaaS to AWS in a Weekend
Here's how I actually did the migration without breaking anything:
Friday Evening (2 hours):
- Export knowledge base from existing platform
- Set up AWS account, enable Bedrock in us-east-1
- Create S3 bucket for knowledge base
- Create DynamoDB table
Saturday Morning (3 hours):
- Deploy Lambda function
- Test locally with sample conversations
- Create API Gateway endpoint
- Test end-to-end flow
Saturday Afternoon (2 hours):
- Build simple chat widget
- Test with real conversations from staging
- Tune Nova prompts based on responses
Sunday (1 hour):
- Deploy to production alongside existing chatbot
- Route 10% of traffic to new system
- Monitor for issues
Following Week:
- Gradually increase traffic to 50%, then 100%
- Decommission old system
Total developer time: ~8 hours. Cost savings per year: ~$8,800.
That's $1,100 per hour of dev work. Show me a better ROI.
The Future: What I'm Building Next
I'm already working on v2 with these improvements:
- Streaming responses (Lambda function URLs + EventStream)
- Sentiment analysis for automatic human escalation
- A/B testing different Nova prompts
- Voice support via Amazon Nova Sonic (when it launches)
The beauty of this architecture is that it's completely modular. Want to swap Nova for Claude? Change one line of code. Want to add email support? Another Lambda function. Want analytics? Query DynamoDB directly.
The Real Reason to Build This
It's not just about saving money, though $800/month is nothing to sneeze at for a small team.
It's about control. When Zendesk raised their prices by 30% last year, I had no choice but to pay or migrate. When Intercom changed their pricing model from per-seat to per-resolution, our costs tripled overnight.
With this approach, I control:
- Exactly what data goes where
- How long conversations are stored
- What models power the responses
- Who has access to what
Plus, I learned a ton about modern AI architectures. Skills that'll be worth way more than $800/month in the job market.
Should You Build This?
If you made it this far, you're probably technical enough to pull this off. Here's my honest take:
For most non-technical teams with under 1,000 conversations/month: Stick with Intercom or Zendesk. The time savings are worth the cost.
For technical teams, high-volume use cases, or anyone who values control and cost savings: Build this. You'll thank yourself every month when you see your AWS bill.
For everyone else: Show this article to your engineering team and ask them to build it. It's a weekend project that pays for itself in month one.
The era of $500/month SaaS chatbots is over. AWS just made it obsolete.
All code examples are available on my GitHub (link in bio). Questions? Drop them in the comments and I'll respond with actual production advice, not marketing BS.
Top comments (0)