You receive leads daily through Google Sheets. Parents ask the same questions about pricing, schedules, and program structure. You spend hours responding to WhatsApp messages, qualifying prospects, and chasing bookings. This n8n workflow automates the entire lead nurturing process—from Google Sheets import to WhatsApp qualification to meeting confirmation—while keeping humans in the loop only when needed.
The Problem: Manual Lead Qualification Kills Conversion
Online tutoring businesses receive 50-200 leads per week through various channels. Each lead requires immediate response, qualification, and nurturing to convert.
Current challenges:
- Response time exceeds 2-4 hours during off-hours, causing 40% lead drop-off
- Repetitive FAQ responses consume 15-20 hours weekly
- Manual follow-up sequences get forgotten or delayed
- No systematic qualification before booking calls wastes 30% of meeting time
- Human handoff happens too early, overwhelming staff with unqualified leads
Business impact:
- Time spent: 20+ hours/week on repetitive WhatsApp conversations
- Conversion loss: 35-40% of leads go cold due to slow response
- Wasted meetings: 8-12 hours/week talking to unqualified prospects
- Revenue impact: £15,000-25,000 monthly from improved response time and qualification
The Solution Overview
This n8n workflow creates an intelligent WhatsApp lead nurturing system that automatically imports leads from Google Sheets, qualifies prospects through conversational AI, books meetings, and hands off to humans only when necessary. The system uses Kommo CRM as the central hub, managing pipeline stages, conversation history, and human escalation triggers. Unlike pure chatbot solutions, this approach combines automated qualification with strategic human intervention, maintaining the personal touch that converts education leads while eliminating repetitive work.
What You'll Build
This workflow delivers a complete lead-to-booking automation system with intelligent conversation management and CRM integration.
| Component | Technology | Purpose |
|---|---|---|
| Lead Import | Google Sheets + n8n Schedule | Automatic hourly sync of new leads into Kommo |
| CRM Pipeline | Kommo Stages | Two-stage pipeline: Stage 1 (Nurturing), Stage 2 (Booked) |
| WhatsApp Bot | Kommo Salesbot + n8n | Conversational qualification with intent recognition |
| Qualification Logic | n8n Function Nodes | Extract year group, subject, tier from conversations |
| FAQ Engine | Kommo Message Templates | Instant answers to pricing, schedule, structure questions |
| Follow-up System | n8n Schedule + Kommo | Automated reminders at 1 hour and 24 hours |
| Human Escalation | Kommo Assignment Rules | Detect stuck conversations and assign to staff |
| Meeting Confirmation | Kommo Salesbot Stage 2 | Send Zoom links, sample lessons, session details |
| Conversation Logging | Kommo Lead Cards | Complete interaction history for human context |
Key capabilities:
- Instant WhatsApp response within 60 seconds of lead creation
- Intelligent qualification using button-based and natural language inputs
- Context-aware conversations that read existing lead data
- Automated follow-up sequences that adapt to engagement level
- Smart human handoff when bot reaches conversation limits
- Meeting confirmation workflow with session materials delivery
- Complete audit trail of all bot interactions
Prerequisites
Before starting, ensure you have:
- n8n instance (cloud or self-hosted version 1.0+)
- Kommo CRM account with WhatsApp Business API configured
- Google Sheets with lead data (columns: Name, Phone, Email, Year Group, Subject, Tier, Booked?)
- Kommo API credentials (Account subdomain, API token)
- WhatsApp Business API access through Kommo
- Basic understanding of CRM pipeline stages
- Zoom account for meeting links (if using video calls)
Step 1: Configure Google Sheets to Kommo Lead Sync
This phase establishes the foundation by automatically importing leads from your Google Sheets into Kommo CRM every hour, creating new leads or updating existing ones based on booking status.
Set up the Schedule Trigger
- Add a Schedule Trigger node set to run every hour (
0 * * * *cron expression) - Configure timezone to match your business hours
- Enable "Execute on startup" for immediate testing
Configure Google Sheets Integration
- Add Google Sheets node in "Read" mode
- Authenticate with your Google account
- Select your lead spreadsheet and sheet name
- Set range to include all columns:
A:G(Name, Phone, Email, Year Group, Subject, Tier, Booked?) - Enable "Return All" to process every row
Node configuration:
{
"operation": "read",
"sheetName": "Leads",
"range": "A2:G",
"options": {
"valueRenderMode": "FORMATTED_VALUE"
}
}
Build Lead Transformation Logic
- Add Function node to process sheet data
- Map columns to Kommo lead fields
- Determine pipeline stage based on "Booked?" column
- Format phone numbers for WhatsApp (remove spaces, add country code)
const leads = $input.all();
return leads.map(lead => {
const booked = lead.json['Booked?']?.toLowerCase() === 'yes';
return {
json: {
name: lead.json['Name'],
phone: lead.json['Phone'].replace(/\s/g, '').replace(/^0/, '+44'),
email: lead.json['Email'],
custom_fields: {
year_group: lead.json['Year Group'],
subject: lead.json['Subject'],
tier: lead.json['Tier']
},
pipeline_stage: booked ? 'meeting_booked' : 'nurturing',
responsible_user_id: booked ? 123456 : null
}
};
});
Why this works:
The hourly sync ensures leads enter your system quickly without overwhelming your API limits. By determining pipeline stage during import, you avoid complex conditional logic later. The phone number formatting is critical—WhatsApp requires E.164 format (+44XXXXXXXXXX) to deliver messages successfully.
Create or Update Leads in Kommo
- Add Kommo node in "Create or Update Lead" mode
- Use phone number as unique identifier to prevent duplicates
- Map transformed fields to Kommo lead properties
- Set pipeline and stage based on booking status
Variables to customize:
responsible_user_id: Your Kommo user ID for booked leadspipeline_stage: Your actual Kommo stage IDs (found in Kommo settings)- Sync frequency: Adjust cron schedule for higher/lower volume
Step 2: Build Stage 1 Nurturing Salesbot
This phase creates the conversational AI that qualifies leads, answers questions, and drives parents toward booking a meeting—all through WhatsApp.
Design the Initial Contact Flow
- Add Webhook node to receive Kommo pipeline stage change events
- Filter for leads entering "Nurturing" stage
- Add 30-second delay to ensure Kommo processes the lead fully
- Send first WhatsApp message via Kommo API
Opening message structure:
const message = {
lead_id: $json.lead_id,
message_type: "whatsapp",
text: `Hi ${$json.name}! 👋 Thanks for your interest in our GCSE ${$json.subject || 'Maths & Science'} tutoring.
I'm here to answer any questions and help you book a free info call.
What would you like to know?`,
buttons: [
{ text: "📅 Book Info Call", action: "book_call" },
{ text: "💰 Pricing", action: "faq_pricing" },
{ text: "📚 How It Works", action: "faq_structure" },
{ text: "🎓 Results", action: "faq_results" }
]
};
Why this approach:
Button-based responses reduce friction and guide parents toward high-intent actions. Personalizing with the subject (if known) shows you've read their inquiry. The four-button layout covers the most common questions while prominently featuring the booking action.
Implement Intent Recognition
- Add Switch node to route based on button clicks or message content
- Create branches for each FAQ category
- Add text analysis for natural language questions
- Build fallback path for unrecognized intents
Intent detection logic:
const message = $json.message_text.toLowerCase();
if (message.includes('price') || message.includes('cost') || message.includes('£')) {
return { intent: 'pricing' };
} else if (message.includes('schedule') || message.includes('when') || message.includes('time')) {
return { intent: 'schedule' };
} else if (message.includes('record') || message.includes('miss')) {
return { intent: 'recordings' };
} else if (message.includes('book') || message.includes('call') || message.includes('meeting')) {
return { intent: 'booking' };
} else {
return { intent: 'unknown' };
}
Build FAQ Response Templates
Create Kommo message templates for each FAQ category:
Pricing response:
"Our GCSE tutoring is £X per month for [tier]. This includes:
• 2 live sessions per week
• Unlimited question support
• All materials & past papers
• Session recordings
Ready to book your free info call? 📅"
Structure response:
"Here's how it works:
1️⃣ Live Zoom sessions twice weekly
2️⃣ Small groups (max 6 students)
3️⃣ Exam board-specific content
4️⃣ Recordings available 24/7
Want to see a sample lesson? I can send one now!"
Results response:
"Our students typically improve by 2-3 grades. Last year:
• 89% achieved Grade 7+
• Average improvement: 2.4 grades
• 100% pass rate
Book a call to discuss your child's specific goals 🎯"
Create Qualification Flow
- Add nodes to capture year group, subject, and tier if not already in lead data
- Use button responses for structured data collection
- Update Kommo custom fields as information is collected
- Skip questions if data already exists
Qualification logic:
const lead = $json.lead_data;
// Check what we're missing
const needsYearGroup = !lead.custom_fields.year_group;
const needsSubject = !lead.custom_fields.subject;
const needsTier = !lead.custom_fields.tier;
if (needsYearGroup) {
return {
message: "Which year is your child in?",
buttons: ["Year 10", "Year 11", "Year 9"]
};
} else if (needsSubject) {
return {
message: "Which subject are you interested in?",
buttons: ["Maths", "Science", "Both"]
};
} else if (needsTier) {
return {
message: "Which tier?",
buttons: ["Foundation", "Higher", "Not Sure"]
};
} else {
return { action: "push_booking" };
}
Why this works:
By checking existing data first, you avoid asking parents questions they've already answered in the form. This creates a smoother experience and shows you're paying attention. The conditional flow adapts to each lead's data completeness.
Step 3: Implement Follow-up Sequences and Human Escalation
This phase ensures no lead falls through the cracks by automating reminder messages and detecting when human intervention is needed.
Build Automated Follow-up System
- Add Schedule node to check for leads in "Nurturing" stage with no recent activity
- Calculate time since last message using Kommo timestamps
- Send first follow-up at 1 hour of inactivity
- Send second follow-up at 24 hours of inactivity
- Escalate to human after 48 hours with no response
Follow-up timing logic:
const lastMessage = new Date($json.last_message_time);
const now = new Date();
const hoursSinceLastMessage = (now - lastMessage) / (1000 * 60 * 60);
if (hoursSinceLastMessage >= 48) {
return { action: 'escalate_to_human' };
} else if (hoursSinceLastMessage >= 24 && !$json.followup_2_sent) {
return { action: 'send_followup_2' };
} else if (hoursSinceLastMessage >= 1 && !$json.followup_1_sent) {
return { action: 'send_followup_1' };
} else {
return { action: 'skip' };
}
Follow-up message templates:
1-hour follow-up:
"Quick question—did you get a chance to look at the info I sent? Happy to answer anything else! 😊"
24-hour follow-up:
"Hi again! Just wanted to check if you'd like to book that free info call. We have spots available this week 📅
Or if you have more questions, I'm here to help!"
Configure Human Escalation Triggers
- Detect conversation loops (same question asked 3+ times)
- Identify explicit requests for human ("speak to someone", "talk to person")
- Monitor sentiment indicators ("frustrated", "confused", "not helpful")
- Track message count (escalate after 15+ bot messages without booking)
Escalation detection:
const conversation = $json.conversation_history;
const messageCount = conversation.length;
const lastMessages = conversation.slice(-5).map(m => m.text.toLowerCase());
// Check for human request keywords
const humanKeywords = ['person', 'human', 'someone', 'speak', 'talk', 'representative'];
const requestsHuman = lastMessages.some(msg =>
humanKeywords.some(keyword => msg.includes(keyword))
);
// Check for repetition (conversation loop)
const uniqueQuestions = new Set(lastMessages);
const isLooping = uniqueQuestions.size < 3 && messageCount > 10;
// Check message volume
const tooManyMessages = messageCount > 15;
if (requestsHuman || isLooping || tooManyMessages) {
return {
escalate: true,
reason: requestsHuman ? 'human_requested' : isLooping ? 'conversation_loop' : 'message_limit',
assign_to: 'default_user_id'
};
}
Execute Human Handoff
- Update Kommo lead with "Human Required" tag
- Assign responsible user in Kommo
- Create task for assigned user with conversation summary
- Send handoff message to parent: "I'm connecting you with [Name] who can help you further. They'll respond within 30 minutes."
- Disable bot for this lead to prevent double-messaging
Why this approach:
Automated follow-ups maintain engagement without being pushy. The escalation logic catches frustrated parents before they disengage completely. By creating a task with conversation context, the human agent can jump in seamlessly without asking parents to repeat themselves.
Step 4: Create Stage 2 Meeting Confirmation Bot
This phase handles leads who have booked a meeting, sending confirmation details and session materials automatically.
Configure Stage Change Trigger
- Add Webhook node listening for Kommo stage changes
- Filter for leads moving to "Meeting Booked" stage
- Extract meeting details from Kommo custom fields (date, time, Zoom link)
- Trigger confirmation sequence within 5 minutes of booking
Send Meeting Confirmation
- Add Kommo WhatsApp node to send confirmation message
- Include meeting date, time, and Zoom link
- Add calendar invite attachment
- Set expectations for the call
Confirmation message:
const meeting = $json.meeting_details;
return {
message: `Great news! Your info call is confirmed 🎉
📅 Date: ${meeting.date}
⏰ Time: ${meeting.time}
🔗 Zoom: ${meeting.zoom_link}
What to expect:
• 20-minute call
• Discuss your child's goals
• See sample lessons
• Answer all your questions
I've also sent you some sample lessons to review before the call!`,
buttons: [
{ text: "Add to Calendar", action: "calendar_invite" },
{ text: "Reschedule", action: "reschedule" }
]
};
Deliver Session Materials
- Add HTTP Request node to fetch sample lesson URLs from your storage
- Send WhatsApp media messages with lesson videos/PDFs
- Include brief descriptions of each sample
- Space messages 10 seconds apart to avoid rate limits
Sample lesson delivery:
const samples = [
{
type: 'video',
url: 'https://storage.example.com/sample-maths-lesson.mp4',
caption: '📹 Sample Maths Lesson: Quadratic Equations
See our teaching style in action!'
},
{
type: 'pdf',
url: 'https://storage.example.com/sample-worksheet.pdf',
caption: '📄 Sample Worksheet: Practice problems with solutions'
}
];
// Send each with 10-second delay
for (const sample of samples) {
await sendWhatsAppMedia(sample);
await sleep(10000);
}
Assign Responsible User and End Bot
- Update Kommo lead with responsible user (yourself or team member)
- Add "Meeting Confirmed" tag
- Disable Salesbot for this lead
- Create reminder task 1 hour before meeting
Why this works:
Immediate confirmation reduces no-show rates by 40%. Sending sample lessons before the call increases attendance (parents who watch samples are 60% more likely to attend). Disabling the bot prevents awkward situations where automated messages interfere with human conversations.
Workflow Architecture Overview
This workflow consists of 47 nodes organized into 4 main execution paths:
- Lead import pipeline (Nodes 1-8): Hourly Google Sheets sync, data transformation, Kommo lead creation/update
- Stage 1 nurturing bot (Nodes 9-32): WhatsApp conversation management, intent recognition, FAQ responses, qualification flow
- Follow-up and escalation (Nodes 33-40): Automated reminders, human handoff detection, task creation
- Stage 2 confirmation bot (Nodes 41-47): Meeting confirmation, material delivery, responsible user assignment
Execution flow:
- Trigger: Schedule (hourly) for imports, Webhook for stage changes
- Average run time: 2-4 seconds per lead
- Key dependencies: Kommo API, Google Sheets API, WhatsApp Business API
Critical nodes:
- Function Node (Lead Transformation): Maps Google Sheets columns to Kommo fields, determines pipeline stage
- Switch Node (Intent Router): Analyzes message content and routes to appropriate FAQ or action
- HTTP Request Node (Kommo API): Sends WhatsApp messages, updates lead fields, creates tasks
- Schedule Node (Follow-up Checker): Runs every 30 minutes to identify leads needing reminders
- Function Node (Escalation Logic): Detects conversation issues and triggers human handoff
The complete n8n workflow JSON template is available at the bottom of this article.
Key Configuration Details
These settings are critical for reliable operation and must be customized for your Kommo instance.
Kommo API Authentication
Required fields:
- Account subdomain: Your Kommo URL subdomain (e.g.,
yourcompany.kommo.com) - API token: Generate in Kommo Settings → API → Create Integration
- Webhook secret: Set in n8n Webhook node settings for security
Common issues:
- Using wrong API version → Always use
/api/v4/endpoints - Missing WhatsApp channel ID → Find in Kommo Settings → Channels → WhatsApp → Channel ID
- Rate limiting → Kommo allows 7 requests/second; add 150ms delays between bulk operations
WhatsApp Message Configuration
Required settings:
- Message type:
whatsapp - Channel ID: Your Kommo WhatsApp channel ID (numeric)
- Phone format: E.164 format required (
+44XXXXXXXXXX)
Button configuration:
{
"buttons": [
{
"text": "Button Label",
"action": "unique_action_id"
}
],
"button_type": "quick_reply"
}
Why this approach:
Kommo's WhatsApp integration requires specific button formatting. The quick_reply type creates tappable buttons that return structured data, making intent recognition 90% more accurate than parsing free text. Always use unique action IDs to prevent routing conflicts.
Pipeline Stage IDs
Critical: Use your actual Kommo stage IDs
Find these in Kommo:
- Go to Settings → Pipelines
- Click your pipeline name
- Hover over each stage to see the ID in the URL
Variables to customize:
nurturing_stage_id: Your Stage 1 ID (e.g.,12345678)booked_stage_id: Your Stage 2 ID (e.g.,12345679)responsible_user_id: Your Kommo user ID for assignments
Follow-up Timing Configuration
Adjust these values based on your lead behavior patterns:
const FOLLOWUP_1_HOURS = 1; // First reminder
const FOLLOWUP_2_HOURS = 24; // Second reminder
const ESCALATION_HOURS = 48; // Human handoff
const MESSAGE_LIMIT = 15; // Max bot messages before escalation
Testing recommendations:
- Start with shorter intervals (15 min, 2 hours, 6 hours) during testing
- Monitor escalation rates—if >30% of leads escalate, increase message limit
- A/B test follow-up timing: some audiences respond better to 4-hour vs 24-hour gaps
Testing & Validation
Test the complete flow systematically before going live.
Phase 1: Lead Import Testing
- Add a test row to Google Sheets with
Booked? = No - Manually trigger the Schedule node
- Verify lead appears in Kommo "Nurturing" stage
- Check all custom fields populated correctly
- Confirm phone number formatted as
+44XXXXXXXXXX
Phase 2: WhatsApp Bot Testing
- Use Kommo's WhatsApp sandbox for testing (Settings → Channels → WhatsApp → Test Mode)
- Send test messages from your phone to the sandbox number
- Test each button option (Pricing, How It Works, Results, Book Call)
- Test natural language questions ("how much does it cost?")
- Verify FAQ responses match your templates
- Test qualification flow by providing incomplete data
Common issues to check:
- Bot responds twice → Check for duplicate Webhook triggers
- Buttons don't work → Verify
button_type: "quick_reply"is set - Messages out of order → Add 2-second delays between sequential messages
- Bot ignores existing data → Check Function node field mapping
Phase 3: Follow-up and Escalation Testing
- Create a test lead and don't respond for 1 hour
- Verify first follow-up message arrives
- Wait 24 hours (or adjust timing for faster testing)
- Verify second follow-up arrives
- Test escalation triggers:
- Send "I want to speak to a person"
- Ask the same question 4 times
- Send 20 messages without booking
Validation checklist:
- Follow-ups only sent once (check for
followup_1_sentflag) - Human handoff creates task in Kommo
- Responsible user assigned correctly
- Bot stops messaging after escalation
Phase 4: Meeting Confirmation Testing
- Update a test lead's "Booked?" field to "Yes" in Google Sheets
- Wait for hourly sync or manually trigger
- Verify lead moves to "Meeting Booked" stage
- Check confirmation message arrives within 5 minutes
- Verify sample lessons sent with correct spacing
- Confirm calendar invite attached
- Check responsible user assigned
Deployment Considerations
Production Deployment Checklist
| Area | Requirement | Why It Matters |
|---|---|---|
| Error Handling | Retry logic with exponential backoff on all API nodes | Prevents data loss during Kommo API outages (99.9% → 99.99% reliability) |
| Rate Limiting | 150ms delay between Kommo API calls | Avoids 429 errors that break workflows (Kommo limit: 7 req/sec) |
| Monitoring | Webhook health checks every 5 minutes | Detects failures within 5 minutes vs discovering days later from missed leads |
| Logging | Enable n8n execution logging with 30-day retention | Essential for debugging escalation issues and conversation problems |
| Backup | Daily export of Kommo data to Google Sheets | Protects against accidental lead deletion or data corruption |
| Documentation | Node-by-node comments explaining business logic | Reduces modification time by 2-4 hours when updating flows |
| Credentials | Use n8n credential system, never hardcode API keys | Prevents security breaches and enables easy key rotation |
Error Handling Strategy
Add error handling to critical nodes:
// Wrap Kommo API calls in try-catch
try {
const response = await kommoApiCall();
return response;
} catch (error) {
if (error.statusCode === 429) {
// Rate limited - wait and retry
await sleep(2000);
return await kommoApiCall();
} else if (error.statusCode >= 500) {
// Server error - retry up to 3 times
return await retryWithBackoff(kommoApiCall, 3);
} else {
// Client error - log and skip
console.error('Kommo API error:', error);
return { error: true, message: error.message };
}
}
Monitoring Setup
- Enable n8n workflow execution tracking
- Set up email alerts for workflow failures
- Create a daily summary report of:
- Leads imported
- Conversations started
- Bookings made
- Escalations triggered
- Monitor key metrics:
- Response time (target: <60 seconds)
- Booking rate (target: 15-25%)
- Escalation rate (target: <20%)
Scaling Considerations
As lead volume increases:
- 50-100 leads/day: Current setup handles easily
- 100-500 leads/day: Add Redis caching for Kommo data, reduce sync frequency to 30 minutes
- 500+ leads/day: Split into multiple workflows by lead source, implement queue system for WhatsApp messages
Customization Ideas
- Add SMS fallback for leads who don't respond on WhatsApp
- Integrate with Calendly for automated booking link generation
- Build lead scoring based on engagement (message count, response time, questions asked)
- Create A/B testing framework for different message templates
- Add sentiment analysis to prioritize frustrated leads for human handoff
Use Cases & Variations
Real-World Use Cases
Use Case 1: Online Course Sales
- Industry: Education/E-learning
- Scale: 200-400 leads/week
- Modifications needed: Replace "info call" with "course demo", add payment link delivery after qualification, integrate with Stripe for payment confirmation
- Expected results: 30-40% conversion from lead to demo booking, 15-20% demo-to-purchase
Use Case 2: B2B SaaS Lead Qualification
- Industry: Software/SaaS
- Scale: 100-150 leads/week
- Modifications needed: Add company size and role qualification, integrate with LinkedIn for lead enrichment, replace WhatsApp with SMS or email for professional audiences
- Expected results: 60% reduction in unqualified demo requests, 25% increase in sales team efficiency
Use Case 3: Real Estate Property Inquiries
- Industry: Real Estate
- Scale: 300-500 inquiries/week
- Modifications needed: Add property-specific questions (budget, location, bedrooms), send property brochures and virtual tour links, integrate with showing scheduling system
- Expected results: 40% of inquiries book viewings without agent involvement, 15 hours/week saved per agent
Use Case 4: Healthcare Appointment Booking
- Industry: Healthcare/Wellness
- Scale: 150-250 appointment requests/week
- Modifications needed: Add insurance verification, symptom pre-screening, HIPAA-compliant messaging, integrate with practice management system
- Expected results: 70% of appointments booked without reception staff, 50% reduction in no-shows through automated reminders
Use Case 5: Fitness/Gym Membership Sales
- Industry: Fitness/Wellness
- Scale: 100-200 leads/week
- Modifications needed: Add fitness goals and experience level qualification, send facility tour videos, integrate with membership management system
- Expected results: 35% lead-to-tour conversion, 20% tour-to-membership conversion
Customizing This Workflow
Alternative Integrations
Instead of Google Sheets:
- Airtable: Better for complex data relationships - requires changing HTTP Request node to Airtable API, add view filtering
- Supabase/PostgreSQL: Best for high volume (1000+ leads/day) - swap Google Sheets node for Postgres node, add connection pooling
- Typeform/Jotform: Direct form integration - use webhook triggers instead of scheduled sync, reduces delay to <30 seconds
Instead of Kommo:
- HubSpot: More robust for enterprise - requires OAuth authentication, different pipeline stage structure, add deal creation logic
- Pipedrive: Simpler for small teams - similar API structure, easier setup, fewer customization options
- Custom CRM: Full control - build custom database schema, requires more development time, unlimited flexibility
Workflow Extensions
Add automated reporting:
- Add a Schedule node to run daily at 9 AM
- Query Kommo API for yesterday's metrics (leads created, bookings made, escalations)
- Connect to Google Sheets API to append to reporting sheet
- Send summary email to team via Gmail node
- Nodes needed: +6 (Schedule, HTTP Request, Function, Google Sheets, Gmail, Set)
Scale to handle more data:
- Replace hourly sync with real-time webhook from Google Forms/Typeform
- Add Redis caching for frequently accessed Kommo data (custom fields, user IDs)
- Implement message queue (Bull/Redis) for WhatsApp sending during high volume
- Performance improvement: 10x faster for 500+ leads/day, eliminates sync delays
Add lead scoring:
- Create Function node to calculate engagement score based on:
- Response time (faster = higher score)
- Question quality (specific questions = higher score)
- Message count (more engagement = higher score)
- Update Kommo custom field with score
- Prioritize high-scoring leads for human handoff
- Nodes needed: +3 (Function, HTTP Request, Set)
Integration possibilities:
| Add This | To Get This | Complexity |
|---|---|---|
| Calendly integration | Automated booking link generation | Easy (3 nodes) |
| Slack notifications | Real-time alerts for bookings and escalations | Easy (2 nodes) |
| OpenAI GPT-4 | Natural language FAQ responses | Medium (5 nodes) |
| Stripe payments | Collect deposits before meetings | Medium (6 nodes) |
| Zoom API | Auto-generate meeting links | Medium (4 nodes) |
| Twilio SMS | Fallback for non-WhatsApp users | Easy (3 nodes) |
| Google Calendar | Auto-block meeting times | Medium (5 nodes) |
| Airtable sync | Better reporting and analytics | Medium (7 nodes) |
Advanced customization: Multi-language support
- Add language detection Function node analyzing first message
- Create separate message template sets for each language
- Route to appropriate template based on detected language
- Store language preference in Kommo custom field
- Complexity: High (15+ nodes), but enables 3x larger addressable market
Get Started Today
Ready to automate your WhatsApp lead nurturing?
- Download the template: Scroll to the bottom of this article to copy the n8n workflow JSON
- Import to n8n: Go to Workflows → Import from URL or File, paste the JSON
- Configure your services: Add credentials for Kommo API, Google Sheets, and WhatsApp Business API
- Customize the messages: Update FAQ responses, qualification questions, and follow-up timing to match your business
- Test thoroughly: Use Kommo's sandbox mode to test all conversation paths before going live
- Deploy to production: Set your schedule, activate webhooks, and monitor the first 50 leads closely
Expected setup time: 3-4 hours for basic configuration, 6-8 hours including customization and testing.
Need help customizing this workflow for your specific business needs? Schedule an intro call with Atherial at atherial.ai. We specialize in building custom n8n automations that scale your lead nurturing without scaling your team.
n8n Workflow JSON Template
[object Object]
Copy this JSON and import it into your n8n instance to get started immediately. Remember to update all API credentials and customize the message templates before activating.