Trades businesses lose 15-20 hours weekly managing customer communications manually. This n8n workflow automates ServiceM8 customer inquiry responses, appointment confirmations, and quote follow-ups, eliminating the owner bottleneck. You'll learn how to build a complete customer communication system that handles everything from initial contact to job conversion without human intervention.
The Problem: Manual Customer Communication Kills Profitability
UK plumbing and heating businesses face a critical operational challenge. The owner handles customer inquiries, appointment scheduling, quote follow-ups, and payment reminders personally. This creates a bottleneck that prevents business growth.
Current challenges:
- Owner spends 3-4 hours daily responding to customer inquiries and scheduling appointments
- Quote follow-ups happen inconsistently, reducing conversion rates by 30-40%
- No standardized response templates lead to inconsistent customer experience
- VA cannot handle communications without clear workflows and decision trees
- Missing appointments cost £200-500 per occurrence in lost revenue
Business impact:
- Time spent: 15-20 hours per week on repetitive communication tasks
- Lost revenue: 30-40% of quotes never convert due to poor follow-up
- Customer satisfaction: Delayed responses create negative first impressions
- Scaling limitation: Owner cannot step away without communication breakdown
The Solution Overview
This n8n workflow integrates ServiceM8's API with automated communication channels to handle the complete customer lifecycle. The system monitors ServiceM8 for new jobs, quotes, and bookings, then triggers appropriate email sequences, SMS reminders, and follow-up workflows. Key components include webhook listeners for ServiceM8 events, conditional logic for customer segmentation, and multi-channel communication nodes. This approach eliminates manual touchpoints while maintaining personalized customer experiences through templated responses and smart scheduling.
What You'll Build
This automation system handles every customer communication touchpoint from inquiry to payment collection. The workflow processes ServiceM8 events in real-time and executes appropriate communication sequences based on job status, customer type, and response history.
| Component | Technology | Purpose |
|---|---|---|
| Event Listener | ServiceM8 Webhooks | Capture job creation, quote sent, booking confirmed events |
| Customer Database | ServiceM8 API + Airtable | Store customer communication history and preferences |
| Logic Engine | n8n Switch & IF Nodes | Route communications based on job type, value, urgency |
| Email Delivery | Gmail/SendGrid Node | Send appointment confirmations, quote follow-ups, invoices |
| SMS Notifications | Twilio Node | Deliver appointment reminders 24 hours before scheduled time |
| Follow-up Scheduler | n8n Schedule Trigger | Trigger quote follow-ups at 3, 7, and 14 day intervals |
| Response Tracking | HTTP Request Nodes | Update ServiceM8 job notes with communication timestamps |
Prerequisites
Before starting, ensure you have:
- n8n instance (cloud or self-hosted version 1.0+)
- ServiceM8 account with API access enabled (Admin permissions required)
- Gmail account with App Password configured OR SendGrid API key
- Twilio account with active phone number for SMS (optional but recommended)
- Airtable account for customer communication tracking (free tier works)
- Basic JavaScript knowledge for Function nodes and data transformation
Step 1: Configure ServiceM8 Webhook Integration
This phase establishes the connection between ServiceM8 and n8n, enabling real-time event capture when customers interact with your business.
Create ServiceM8 API credentials
- Log into ServiceM8 as admin user
- Navigate to Settings → API & Integrations → API Access
- Generate new API key and secret (save these immediately)
- Enable webhook permissions for Job Created, Quote Sent, Booking Confirmed events
- Set webhook URL to your n8n instance:
https://your-n8n-instance.com/webhook/servicem8
Configure n8n Webhook node
{
"authentication": "headerAuth",
"httpMethod": "POST",
"path": "servicem8",
"responseMode": "responseNode",
"options": {
"rawBody": true
}
}
Add ServiceM8 credential in n8n
- Go to Credentials → Add Credential → ServiceM8 API
- Enter API Key and Secret from ServiceM8
- Test connection by making sample API call to
/job.jsonendpoint - Verify response returns job data successfully
Why this works:
ServiceM8's webhook system pushes events to n8n instantly rather than polling every few minutes. This reduces API calls by 95% and ensures customers receive responses within 60 seconds of inquiry. The raw body option preserves ServiceM8's signature for webhook verification.
Step 2: Build Customer Inquiry Response System
This section creates automated responses for new customer inquiries, eliminating the 2-4 hour response delay that kills 40% of potential bookings.
Set up inquiry detection logic
- Add Switch node after Webhook to route based on
event_typefield - Create case for
job.createdevents wherejob_status = "Quote" - Add HTTP Request node to fetch complete job details from ServiceM8API
- Use Function node to extract customer name, email, phone, job description
Node configuration:
// Function node: Extract Customer Data
const jobData = $input.item.json;
return {
json: {
customerName: jobData.contact_first + ' ' + jobData.contact_last,
customerEmail: jobData.contact_email,
customerPhone: jobData.contact_mobile,
jobType: jobData.job_description,
jobValue: jobData.quote_total,
urgency: jobData.custom_field_urgency || 'standard',
jobUUID: jobData.uuid
}
};
Create response templates
- Add IF node to check urgency level (emergency vs standard)
- For emergency jobs: Send immediate SMS + email with 2-hour response promise
- For standard jobs: Send email acknowledgment with 24-hour response timeline
- Include FAQ links and booking calendar in all responses
Gmail node configuration for standard inquiry:
{
"resource": "message",
"operation": "send",
"to": "={{$json.customerEmail}}",
"subject": "We've Received Your Plumbing Inquiry - {{$json.customerName}}",
"message": "Hi {{$json.customerName}},
Thank you for contacting us about {{$json.jobType}}.
We'll review your request and send a detailed quote within 24 hours.
In the meantime, you can view our pricing guide here: [link]
For emergencies, call us directly at 020-XXXX-XXXX.
Best regards,
[Business Name]",
"options": {
"ccList": "office@yourcompany.com"
}
}
Why this works:
Immediate acknowledgment reduces customer anxiety and prevents them from calling competitors. The urgency-based routing ensures emergency jobs get prioritized attention. CCing the office email creates a paper trail for the VA to follow up with detailed quotes.
Variables to customize:
response_timeline: Adjust from 24 hours to your actual quote turnaround timeemergency_threshold: Set job value or keywords that trigger emergency routingfaq_link: Point to your actual FAQ page or pricing guide
Step 3: Automate Appointment Confirmations and Reminders
This phase eliminates no-shows by sending multi-channel confirmations and timely reminders for scheduled appointments.
Configure booking confirmation workflow
- Add Switch case for
booking.confirmedwebhook event - Extract appointment date, time, engineer name, job address from ServiceM8
- Send immediate email confirmation with calendar invite attachment
- Schedule SMS reminder for 24 hours before appointment
- Update ServiceM8 job notes with "Confirmation sent" timestamp
Function node: Calculate reminder timing
// Calculate 24 hours before appointment
const appointmentDate = new Date($json.job_start_date);
const reminderDate = new Date(appointmentDate.getTime() - (24 * 60 * 60 * 1000));
return {
json: {
appointmentTime: appointmentDate.toISOString(),
reminderTime: reminderDate.toISOString(),
engineerName: $json.assigned_staff_name,
customerPhone: $json.contact_mobile,
jobAddress: $json.job_address
}
};
Set up SMS reminder with Twilio
- Add Schedule Trigger node set to check every hour
- Query Airtable for appointments with reminder_time in next 60 minutes
- Send SMS via Twilio node with appointment details
- Mark reminder as sent in Airtable to prevent duplicates
Twilio SMS node configuration:
{
"resource": "message",
"operation": "send",
"from": "+44XXXXXXXXXX",
"to": "={{$json.customerPhone}}",
"message": "Reminder: {{$json.engineerName}} will arrive tomorrow at {{$json.appointmentTime}} for your plumbing job at {{$json.jobAddress}}. Reply CONFIRM or call 020-XXXX-XXXX if you need to reschedule."
}
Why this approach:
The two-stage confirmation (immediate email + 24-hour SMS) reduces no-shows by 60-70%. Email confirmations provide detailed information customers can reference. SMS reminders catch people who don't check email regularly. The hourly schedule check ensures reminders go out within 60 minutes of the target time without overwhelming the system.
Step 4: Build Quote Follow-Up Sequences
This section automates the quote follow-up process that converts 30-40% more quotes into booked jobs through persistent, timely communication.
Create multi-touch follow-up sequence
- When ServiceM8 sends quote (webhook event
quote.sent), store quote details in Airtable - Schedule three follow-up touchpoints: Day 3, Day 7, Day 14
- Each touchpoint checks if quote was accepted before sending
- Escalate to phone call task for VA after Day 14 if no response
Airtable schema for quote tracking:
| Field Name | Type | Purpose |
|---|---|---|
| quote_uuid | Text | ServiceM8 quote identifier |
| customer_email | Contact for follow-ups | |
| quote_value | Currency | Job value for prioritization |
| sent_date | Date | When quote was originally sent |
| status | Single Select | Pending/Accepted/Declined/Expired |
| followup_3_sent | Checkbox | Track Day 3 email sent |
| followup_7_sent | Checkbox | Track Day 7 email sent |
| followup_14_sent | Checkbox | Track Day 14 email sent |
Schedule Trigger configuration:
{
"rule": {
"interval": [
{
"field": "cronExpression",
"expression": "0 9 * * *"
}
]
}
}
This runs daily at 9 AM to check for quotes needing follow-up.
Follow-up logic in Function node:
// Determine which follow-up to send
const sentDate = new Date($json.sent_date);
const today = new Date();
const daysSince = Math.floor((today - sentDate) / (1000 * 60 * 60 * 24));
let followupStage = null;
if (daysSince >= 3 && !$json.followup_3_sent) {
followupStage = 'day3';
} else if (daysSince >= 7 && !$json.followup_7_sent) {
followupStage = 'day7';
} else if (daysSince >= 14 && !$json.followup_14_sent) {
followupStage = 'day14';
}
return {
json: {
...$json,
followupStage,
shouldSend: followupStage !== null
}
};
Email templates for each stage:
Day 3: "Just checking in on the quote we sent for [job type]. Do you have any questions about our pricing or approach?"
Day 7: "We're holding your preferred time slot for [date]. Would you like to move forward with booking, or do you need any clarifications?"
Day 14: "This is our final follow-up on your quote. If you've decided to go another direction, we'd appreciate knowing so we can improve. Otherwise, we'd love to earn your business."
Why this works:
The spaced repetition (3-7-14 days) catches customers at different decision stages without being pushy. Checking quote status before each send prevents annoying customers who already booked. The escalation to human contact after Day 14 ensures high-value quotes don't slip through automated cracks.
Workflow Architecture Overview
This workflow consists of 23 nodes organized into 4 main execution paths:
Event ingestion (Nodes 1-5): ServiceM8 webhook receives events, validates signatures, routes to appropriate handler based on event type (job created, quote sent, booking confirmed, invoice paid)
Communication logic (Nodes 6-15): Switch nodes route events to specific workflows, Function nodes transform ServiceM8 data into email/SMS templates, IF nodes check conditions before sending (customer preferences, time of day, previous communication history)
Multi-channel delivery (Nodes 16-20): Gmail nodes send detailed emails with attachments, Twilio nodes deliver SMS for time-sensitive reminders, HTTP Request nodes update ServiceM8 with communication timestamps
Follow-up scheduling (Nodes 21-23): Airtable stores quote/job data for future follow-ups, Schedule Trigger runs daily checks, Loop nodes process multiple pending follow-ups in batch
Execution flow:
- Trigger: ServiceM8 webhook fires on customer events (real-time)
- Average run time: 3-8 seconds per event
- Key dependencies: ServiceM8 API, Gmail/SendGrid, Twilio (optional), Airtable
Critical nodes:
- Switch Node (Event Router): Directs traffic based on
event_typefield from ServiceM8 webhook payload - HTTP Request (ServiceM8 API): Fetches complete job/quote details that webhooks don't include
- Function Node (Template Builder): Constructs personalized email/SMS content using customer data
- Airtable Node: Logs all communications for audit trail and prevents duplicate sends
The complete n8n workflow JSON template is available at the bottom of this article.
Critical Configuration Settings
ServiceM8 API Integration
Required fields:
- API Key: Your ServiceM8 API key from Settings → API Access
- API Secret: Paired with API key for authentication
- Webhook URL:
https://your-n8n.com/webhook/servicem8 - Webhook Events: Enable job.created, quote.sent, booking.confirmed, invoice.paid
Common issues:
- Using HTTP instead of HTTPS for webhook URL → ServiceM8 rejects non-SSL endpoints
- Not enabling webhook events in ServiceM8 → No events fire to n8n
- Incorrect API credentials → Returns 401 Unauthorized errors
Gmail/SendGrid Configuration
For Gmail:
- Enable 2-factor authentication on Google account
- Generate App Password at myaccount.google.com/apppasswords
- Use App Password in n8n credential, not regular password
- Set "From" address to match Gmail account exactly
For SendGrid:
- Create API key with "Mail Send" permissions only
- Verify sender email address in SendGrid dashboard
- Use dynamic templates for better deliverability
- Monitor bounce rates (keep below 5%)
Twilio SMS Setup
Required fields:
- Account SID: Found in Twilio console dashboard
- Auth Token: Also in console (click "show" to reveal)
- From Number: Must be Twilio number in E.164 format (+44XXXXXXXXXX)
Why this approach:
Twilio's E.164 format ensures international compatibility. Using a dedicated Twilio number (not your business line) prevents SMS/call conflicts. The Auth Token acts as password - never commit to version control.
Variables to customize:
reminder_hours_before: Change from 24 to 48 hours for longer lead time jobsfollowup_intervals: Adjust [3,7,14] to [2,5,10] for faster sales cyclesemergency_keywords: Add trade-specific terms like "burst pipe", "no heat", "leak"
Testing & Validation
Test each communication path:
- Create test job in ServiceM8 with your email
- Verify webhook fires to n8n (check Executions tab)
- Confirm email arrives within 60 seconds
- Check ServiceM8 job notes updated with "Email sent" timestamp
Review inputs and outputs:
- Webhook node: Inspect raw payload to verify all expected fields present
- Function nodes: Use "Run Node" to test data transformations with sample data
- Email nodes: Send to test address first, check spam folder and formatting
- Airtable nodes: Verify records created with correct field mappings
Common troubleshooting:
| Issue | Cause | Solution |
|---|---|---|
| Webhook not firing | ServiceM8 events not enabled | Re-save webhook URL in ServiceM8 settings |
| Emails not sending | Gmail App Password wrong | Regenerate App Password, update credential |
| Duplicate SMS sent | Airtable flag not updating | Add error handling to mark sent even if SMS fails |
| Missing customer data | ServiceM8 custom fields empty | Add IF node to check field exists before using |
Running evaluations:
Set up a test customer in ServiceM8 and run through complete lifecycle:
- Create quote → Verify inquiry response received
- Send quote → Verify quote email delivered
- Wait 3 days → Verify Day 3 follow-up sent
- Book appointment → Verify confirmation + calendar invite
- 24 hours before → Verify SMS reminder delivered
Deployment Considerations
Production Deployment Checklist
| Area | Requirement | Why It Matters |
|---|---|---|
| Error Handling | Retry logic with exponential backoff on API nodes | Prevents data loss when ServiceM8 API has temporary outages |
| Monitoring | Webhook health check every 5 minutes | Detects ServiceM8 webhook failures within 5 minutes vs discovering days later |
| Rate Limiting | Throttle to 10 emails per minute | Prevents Gmail/SendGrid from flagging account as spam |
| Data Backup | Daily Airtable export to Google Drive | Preserves communication history if Airtable account issues occur |
| Credential Security | Use environment variables for API keys | Prevents accidental exposure in workflow exports |
| Logging | Store all webhook payloads in Airtable | Enables debugging of edge cases and audit compliance |
Error handling strategy:
Add Error Trigger node connected to Slack/email notification:
- Captures any workflow failures
- Sends alert with error message and failed node name
- Includes link to execution in n8n for quick debugging
Monitoring recommendations:
Set up these alerts:
- No webhooks received in 24 hours (ServiceM8 connection issue)
- Email bounce rate exceeds 5% (list hygiene problem)
- SMS delivery failure rate above 2% (phone number quality issue)
- Airtable record count not increasing (data logging failure)
Use Cases & Variations
Use Case 1: HVAC Emergency Response
- Industry: Heating/Cooling service companies
- Scale: 50-100 emergency calls per week
- Modifications needed: Add priority routing for "no heat" keywords, integrate with on-call engineer schedule API, send ETA updates via SMS every 30 minutes
Use Case 2: Electrical Contractor Quoting
- Industry: Commercial electrical work
- Scale: 20-30 quotes per week, average value £5,000-15,000
- Modifications needed: Replace 3-tier pricing with custom quote builder, add PDF quote generation node, include compliance documentation attachments, extend follow-up to 30 days for longer sales cycles
Use Case 3: Multi-Location Plumbing Franchise
- Industry: Residential plumbing franchise with 5 locations
- Scale: 200+ jobs per week across locations
- Modifications needed: Add location detection based on postcode, route to location-specific email addresses, customize engineer assignment logic per territory, aggregate reporting across all locations
Use Case 4: Preventive Maintenance Programs
- Industry: Annual service contracts for boilers/heating systems
- Scale: 500+ active maintenance contracts
- Modifications needed: Add annual service reminder sequence starting 60 days before due date, integrate with ServiceM8 recurring job feature, track contract renewal rates in Airtable
Customizations & Extensions
Alternative Integrations
Instead of Gmail:
- SendGrid: Best for high-volume sending (1000+ emails/day) - requires changing credential type and adding template IDs
- Mailgun: Better deliverability for transactional emails - swap Gmail node for HTTP Request to Mailgun API
- Microsoft 365: Use when company uses Outlook - requires OAuth2 credential setup
Instead of Airtable:
- Google Sheets: Simpler setup, no API limits on free tier - replace Airtable nodes with Google Sheets nodes (same operations)
- PostgreSQL: Better for 10,000+ records - requires database hosting, use Postgres node instead of Airtable
- Notion: If team already uses Notion - swap for Notion API nodes, similar database structure
Workflow Extensions
Add automated reporting:
- Add Schedule node to run Monday 9 AM weekly
- Query Airtable for previous week's communication metrics
- Calculate: emails sent, quotes followed up, conversion rate, response times
- Generate summary email to owner with key metrics
- Nodes needed: +6 (Schedule, Airtable query, Function for calculations, Gmail)
Scale to handle more data:
- Replace Airtable with Supabase (PostgreSQL backend)
- Add batch processing for quote follow-ups (process 50 at a time instead of one-by-one)
- Implement Redis caching for frequently accessed ServiceM8 data
- Performance improvement: Handles 500+ jobs per day vs 50-100 with current setup
Add customer satisfaction tracking:
- Send post-job survey via SMS 24 hours after completion
- Collect 1-5 star rating via reply or link
- Store ratings in Airtable linked to job UUID
- Alert owner when rating below 4 stars for immediate follow-up
- Nodes needed: +8 (Schedule, Twilio, Webhook for responses, IF for rating check, Airtable update)
Integration possibilities:
| Add This | To Get This | Complexity |
|---|---|---|
| Xero/QuickBooks | Automated invoice creation and payment tracking | Medium (5 nodes) |
| Google Calendar | Engineer schedule sync and availability checking | Easy (3 nodes) |
| Slack | Real-time notifications for high-value quotes | Easy (2 nodes) |
| Zapier/Make | Connect to 1000+ other apps ServiceM8 doesn't support | Medium (4 nodes) |
| Stripe | Direct payment collection links in invoices | Medium (6 nodes) |
| WhatsApp Business | Customer communication via WhatsApp instead of SMS | Hard (10 nodes, requires Meta approval) |
Get Started Today
Ready to automate your customer communication system?
- Download the template: Scroll to the bottom of this article to copy the n8n workflow JSON
- Import to n8n: Go to Workflows → Import from File, paste the JSON
- Configure your services: Add credentials for ServiceM8, Gmail/SendGrid, Twilio, and Airtable
- Test with sample data: Create a test job in ServiceM8 and verify the complete workflow executes
- Deploy to production: Activate the webhook, enable the schedule trigger, and monitor the first week closely
Need help customizing this workflow for your specific trade business? Schedule an intro call with Atherial at https://atherial.com/contact to discuss your systematization needs.