Implementation Guide: Draft service follow-up communications and maintenance reminder campaigns

# Install Ubuntu Server 22.04 LTS from USB/iDRAC virtual media
# After OS install, update and harden:
sudo apt update && sudo apt upgrade -y
sudo apt install -y ufw fail2ban unattended-upgrades curl git
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw allow 443/tcp
sudo ufw allow 5678/tcp comment 'n8n web UI - restrict to management IPs later'
sudo ufw enable
# Configure fail2ban for SSH
sudo systemctl enable fail2ban
sudo systemctl start fail2ban
# Enable automatic security updates
sudo dpkg-reconfigure -plow unattended-upgrades
# Set timezone to dealership local time
sudo timedatectl set-timezone America/Chicago

# Install Docker Engine
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER
# Install Docker Compose plugin
sudo apt install -y docker-compose-plugin
# Verify installation
docker --version
docker compose version
# Create project directory
sudo mkdir -p /opt/ai-comms-platform
sudo chown $USER:$USER /opt/ai-comms-platform
cd /opt/ai-comms-platform

cat > /opt/ai-comms-platform/docker-compose.yml << 'EOF'
version: '3.8'

volumes:
  n8n_data:
  postgres_data:
  nginx_data:
  nginx_letsencrypt:

networks:
  ai-comms-net:
    driver: bridge

services:
  postgres:
    image: postgres:16-alpine
    container_name: ai-comms-postgres
    restart: always
    networks:
      - ai-comms-net
    environment:
      POSTGRES_DB: n8n
      POSTGRES_USER: n8n
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./init-scripts:/docker-entrypoint-initdb.d
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U n8n']
      interval: 10s
      timeout: 5s
      retries: 5

  n8n:
    image: n8nio/n8n:latest
    container_name: ai-comms-n8n
    restart: always
    networks:
      - ai-comms-net
    ports:
      - '5678:5678'
    environment:
      N8N_HOST: ${N8N_HOST}
      N8N_PORT: 5678
      N8N_PROTOCOL: https
      WEBHOOK_URL: https://${N8N_HOST}/
      DB_TYPE: postgresdb
      DB_POSTGRESDB_HOST: postgres
      DB_POSTGRESDB_PORT: 5432
      DB_POSTGRESDB_DATABASE: n8n
      DB_POSTGRESDB_USER: n8n
      DB_POSTGRESDB_PASSWORD: ${POSTGRES_PASSWORD}
      N8N_ENCRYPTION_KEY: ${N8N_ENCRYPTION_KEY}
      N8N_BASIC_AUTH_ACTIVE: 'true'
      N8N_BASIC_AUTH_USER: ${N8N_ADMIN_USER}
      N8N_BASIC_AUTH_PASSWORD: ${N8N_ADMIN_PASSWORD}
      GENERIC_TIMEZONE: ${TIMEZONE}
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy

  nginx-proxy:
    image: jc21/nginx-proxy-manager:latest
    container_name: ai-comms-nginx
    restart: always
    networks:
      - ai-comms-net
    ports:
      - '80:80'
      - '443:443'
      - '81:81'
    volumes:
      - nginx_data:/data
      - nginx_letsencrypt:/etc/letsencrypt
EOF
# Create environment file
cat > /opt/ai-comms-platform/.env << 'EOF'
POSTGRES_PASSWORD=CHANGE_ME_STRONG_PASSWORD_32CHARS
N8N_HOST=n8n.yourmsp.com
N8N_ENCRYPTION_KEY=CHANGE_ME_RANDOM_64CHAR_HEX_STRING
N8N_ADMIN_USER=mspadmin
N8N_ADMIN_PASSWORD=CHANGE_ME_STRONG_PASSWORD
TIMEZONE=America/Chicago
EOF
# Set secure permissions on .env
chmod 600 /opt/ai-comms-platform/.env

mkdir -p /opt/ai-comms-platform/init-scripts
cat > /opt/ai-comms-platform/init-scripts/01-compliance-tables.sql << 'SQLEOF'
-- Compliance and audit database
CREATE DATABASE IF NOT EXISTS compliance;
\c compliance;

CREATE TABLE IF NOT EXISTS consent_records (
  id SERIAL PRIMARY KEY,
  customer_id VARCHAR(100) NOT NULL,
  dealership_id VARCHAR(50) NOT NULL,
  channel VARCHAR(10) NOT NULL CHECK (channel IN ('email', 'sms')),
  consent_type VARCHAR(20) NOT NULL CHECK (consent_type IN ('promotional', 'informational', 'transactional')),
  consent_given BOOLEAN NOT NULL DEFAULT false,
  consent_timestamp TIMESTAMPTZ NOT NULL DEFAULT NOW(),
  consent_source VARCHAR(255),
  ip_address INET,
  opt_out_timestamp TIMESTAMPTZ,
  opt_out_source VARCHAR(255),
  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

CREATE INDEX idx_consent_customer ON consent_records(customer_id, channel);
CREATE INDEX idx_consent_dealership ON consent_records(dealership_id);

CREATE TABLE IF NOT EXISTS communication_log (
  id SERIAL PRIMARY KEY,
  dealership_id VARCHAR(50) NOT NULL,
  customer_id VARCHAR(100) NOT NULL,
  channel VARCHAR(10) NOT NULL,
  message_type VARCHAR(50) NOT NULL,
  subject_line TEXT,
  ai_model_used VARCHAR(50),
  ai_prompt_template VARCHAR(100),
  content_hash VARCHAR(64),
  sendgrid_message_id VARCHAR(255),
  twilio_message_sid VARCHAR(255),
  delivery_status VARCHAR(30),
  sent_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
  opened_at TIMESTAMPTZ,
  clicked_at TIMESTAMPTZ,
  bounced_at TIMESTAMPTZ,
  unsubscribed_at TIMESTAMPTZ
);

CREATE INDEX idx_comlog_customer ON communication_log(customer_id);
CREATE INDEX idx_comlog_dealership_date ON communication_log(dealership_id, sent_at);

CREATE TABLE IF NOT EXISTS campaign_metrics (
  id SERIAL PRIMARY KEY,
  dealership_id VARCHAR(50) NOT NULL,
  campaign_name VARCHAR(255) NOT NULL,
  campaign_type VARCHAR(50) NOT NULL,
  total_sent INTEGER DEFAULT 0,
  total_delivered INTEGER DEFAULT 0,
  total_opened INTEGER DEFAULT 0,
  total_clicked INTEGER DEFAULT 0,
  total_unsubscribed INTEGER DEFAULT 0,
  total_bounced INTEGER DEFAULT 0,
  appointments_booked INTEGER DEFAULT 0,
  revenue_attributed NUMERIC(10,2) DEFAULT 0,
  started_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
  completed_at TIMESTAMPTZ
);
SQLEOF

cd /opt/ai-comms-platform
docker compose up -d
# Verify all containers are running
docker compose ps
# Check n8n logs for successful startup
docker compose logs n8n --tail 50
# Check PostgreSQL is healthy
docker compose logs postgres --tail 20

sudo ufw delete allow 5678/tcp
sudo ufw allow from 127.0.0.1 to any port 5678

dig TXT dealername.com +short
dig CNAME s1._domainkey.dealername.com +short
dig TXT _dmarc.dealername.com +short

# CDK Fortellis HTTP Request:
# Method: GET
# URL: https://api.fortellis.io/cdkdrive/service/v1/repair-orders
# Query Params: status=closed&closedAfter={{$now.minus(4,'hours').toISO()}}
# Authentication: OAuth2 (Fortellis credential)
# Headers: Accept: application/json, Request-Id: {{$workflow.id}}-{{$now.toMillis()}}

# POST to https://api.openai.com/v1/chat/completions

{
  "model": "gpt-5.4-mini",
  "temperature": 0.7,
  "max_tokens": 500,
  "messages": [
    {"role": "system", "content": "{{system_prompt}}"},
    {"role": "user", "content": "{{user_prompt}}"}
  ],
  "response_format": {"type": "json_object"}
}

POST https://api.sendgrid.com/v3/mail/send
Authorization: Bearer {{$credentials.sendgridApiKey}}

{
  "personalizations": [{
    "to": [{"email": "{{customer_email}}", "name": "{{customer_name}}"}],
    "subject": "{{ai_subject_line}}",
    "custom_args": {
      "dealership_id": "{{dealership_id}}",
      "campaign_type": "{{message_type}}",
      "comm_log_id": "{{comm_log_id}}"
    }
  }],
  "from": {"email": "service@dealername.com", "name": "Dealer Service Team"},
  "reply_to": {"email": "service@dealername.com"},
  "content": [{"type": "text/html", "value": "{{ai_email_body_html}}"}],
  "tracking_settings": {
    "open_tracking": {"enable": true},
    "click_tracking": {"enable": true}
  },
  "asm": {
    "group_id": 12345,
    "groups_to_display": [12345, 12346]
  }
}

# In n8n, create a new workflow: 'SMS Delivery Engine'
# Trigger: Schedule every 15 minutes during business hours (9AM-8PM local, TCPA requirement)

# Workflow nodes:
# 1. Postgres node -> Fetch queued SMS (channel='sms', status='pending')
# 2. Postgres node -> STRICT consent check:
#    SELECT * FROM consent_records
#    WHERE customer_id={{customer_id}}
#    AND channel='sms'
#    AND consent_given=true
#    AND opt_out_timestamp IS NULL
#    AND (consent_type='promotional' OR '{{message_type}}' IN ('post_service_followup','maintenance_reminder'))
# 3. IF node -> Consent verified? Continue : Skip + log refusal reason
# 4. Function node -> Ensure message includes opt-out: append 'Reply STOP to opt out'
# 5. Twilio node -> Send SMS
#    From: +1XXXXXXXXXX (registered Messaging Service number)
#    To: {{customer_phone}}
#    Body: {{ai_sms_body}} Reply STOP to opt out.
#    MessagingServiceSid: MGXXXXXXXXX (registered A2P campaign)
# 6. Postgres node -> Log twilio_message_sid and delivery status

# Inbound SMS handling workflow:
# Create webhook: https://n8n.yourmsp.com/webhook/twilio-inbound
# Configure in Twilio: Messaging Service -> Integration -> Webhook URL
# Nodes:
# 1. Webhook Trigger
# 2. Function node -> Parse inbound message
# 3. Switch node -> Check for STOP/CANCEL/UNSUBSCRIBE/START/HELP
# 4a. STOP branch: Postgres -> Set opt_out_timestamp, Twilio -> confirm opt-out
# 4b. START branch: Postgres -> Create new consent record (requires verification)
# 4c. HELP branch: Twilio -> Send help message with dealership phone number
# 4d. Other: Forward to dealership service desk or queue for human review

# Create prompt templates table in compliance database:
docker exec -it ai-comms-postgres psql -U n8n -d compliance -c "
CREATE TABLE IF NOT EXISTS prompt_templates (
  id SERIAL PRIMARY KEY,
  template_name VARCHAR(100) UNIQUE NOT NULL,
  communication_type VARCHAR(50) NOT NULL,
  channel VARCHAR(10) NOT NULL,
  system_prompt TEXT NOT NULL,
  user_prompt_template TEXT NOT NULL,
  active BOOLEAN DEFAULT true,
  version INTEGER DEFAULT 1,
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW()
);"

# Install Uptime Kuma for lightweight monitoring
docker run -d --name uptime-kuma --network ai-comms-net -p 3001:3001 -v uptime-kuma:/app/data --restart always louislam/uptime-kuma:1

# 1. Export existing opt-in data from current email/SMS systems
# (ActiveCampaign, Mailchimp, DealerSocket, etc.)
# Format as CSV: customer_id, email, phone, consent_type, consent_date, source

# 2. Create import script:
cat > /opt/ai-comms-platform/import-consent.py << 'PYEOF'
import csv
import psycopg2
from datetime import datetime

conn = psycopg2.connect(
    host='localhost', port=5432,
    dbname='compliance', user='n8n',
    password='YOUR_POSTGRES_PASSWORD'
)
cur = conn.cursor()

with open('/tmp/consent_export.csv', 'r') as f:
    reader = csv.DictReader(f)
    for row in reader:
        cur.execute("""
            INSERT INTO consent_records 
            (customer_id, dealership_id, channel, consent_type, 
             consent_given, consent_timestamp, consent_source)
            VALUES (%s, %s, %s, %s, %s, %s, %s)
            ON CONFLICT DO NOTHING
        """, (
            row['customer_id'], row.get('dealership_id', 'DEFAULT'),
            row['channel'], row.get('consent_type', 'informational'),
            True, row.get('consent_date', datetime.now().isoformat()),
            'historical_import'
        ))

conn.commit()
cur.close()
conn.close()
print('Import complete')
PYEOF

# 3. Run import:
sudo apt install -y python3-psycopg2
python3 /opt/ai-comms-platform/import-consent.py

# 4. Verify import:
docker exec -it ai-comms-postgres psql -U n8n -d compliance -c "SELECT channel, consent_type, COUNT(*) FROM consent_records GROUP BY channel, consent_type;"

{
  "email_subject": "Thanks for bringing in your 2021 Camry, Sarah!",
  "email_body_html": "<p>Hi Sarah,</p><p>Thank you for trusting us with your 2021 Toyota Camry's oil change and tire rotation today. We appreciate your continued loyalty to our service team.</p><p>Your advisor Mike wanted to let you know that your next recommended service — a 30,000-mile inspection — will be due around August 2025. We'll send you a reminder as it approaches.</p><p>If you have a moment, we'd love to hear about your experience: <a href='https://g.page/r/dealer/review'>Leave a quick review</a></p><p>Thank you,<br>The Service Team at Valley Toyota</p>",
  "sms_body": "Hi Sarah! Thanks for visiting Valley Toyota today for your Camry's service. Questions? Call us at 555-0123.",
  "communication_tone": "warm, grateful, personal"
}

# import into n8n and configure credentials)

{
  "name": "DMS Data Sync - Service Records",
  "nodes": [
    {
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "parameters": {
        "rule": {
          "interval": [{"field": "hours", "hoursInterval": 4}]
        }
      },
      "position": [240, 300]
    },
    {
      "name": "Get DMS Auth Token",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "method": "POST",
        "url": "https://identity.fortellis.io/oauth2/aus1p1ixy7YL8cMq02p7/v1/token",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [{"name": "Content-Type", "value": "application/x-www-form-urlencoded"}]
        },
        "sendBody": true,
        "bodyParameters": {
          "parameters": [
            {"name": "grant_type", "value": "client_credentials"},
            {"name": "scope", "value": "{{$credentials.fortellisScope}}"}
          ]
        },
        "authentication": "genericCredentialType",
        "genericAuthType": "httpBasicAuth"
      },
      "position": [460, 300]
    },
    {
      "name": "Fetch Closed Repair Orders",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "method": "GET",
        "url": "https://api.fortellis.io/cdkdrive/service/v1/repair-orders",
        "sendQuery": true,
        "queryParameters": {
          "parameters": [
            {"name": "status", "value": "closed"},
            {"name": "closedAfter", "value": "={{$now.minus(4, 'hours').toISO()}}"}
          ]
        },
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {"name": "Authorization", "value": "Bearer {{$node['Get DMS Auth Token'].json.access_token}}"},
            {"name": "Accept", "value": "application/json"},
            {"name": "Request-Id", "value": "={{$workflow.id}}-{{$now.toMillis()}}"}
          ]
        }
      },
      "position": [680, 300]
    },
    {
      "name": "Normalize & Categorize",
      "type": "n8n-nodes-base.function",
      "parameters": {
        "functionCode": "const repairOrders = items[0].json.repairOrders || items[0].json.data || [];\nconst results = [];\nconst now = new Date();\n\nfor (const ro of repairOrders) {\n  const customer = {\n    customer_id: ro.customerId || ro.customer?.id,\n    customer_first_name: ro.customerFirstName || ro.customer?.firstName,\n    customer_last_name: ro.customerLastName || ro.customer?.lastName,\n    customer_email: ro.customerEmail || ro.customer?.email,\n    customer_phone: ro.customerPhone || ro.customer?.phone,\n    vehicle_year: ro.vehicleYear || ro.vehicle?.year,\n    vehicle_make: ro.vehicleMake || ro.vehicle?.make,\n    vehicle_model: ro.vehicleModel || ro.vehicle?.model,\n    vehicle_vin: ro.vin || ro.vehicle?.vin,\n    services_performed: (ro.lineItems || ro.services || []).filter(s => s.status === 'completed').map(s => s.description).join(', '),\n    services_declined: (ro.lineItems || ro.services || []).filter(s => s.status === 'declined').map(s => s.description).join(', '),\n    service_date: ro.closedDate || ro.completedDate,\n    advisor_name: ro.advisorName || ro.serviceAdvisor?.name || 'your service advisor',\n    ro_number: ro.repairOrderNumber || ro.id,\n    next_service_recommendation: ro.nextService?.description || '',\n    next_service_due: ro.nextService?.dueDate || ro.nextService?.dueMileage || '',\n    estimated_mileage: ro.mileageIn || ro.vehicle?.currentMileage\n  };\n\n  // Determine communication type\n  const hoursSinceClose = (now - new Date(customer.service_date)) / (1000*60*60);\n  \n  if (hoursSinceClose <= 6) {\n    customer.comm_type = 'post_service_followup';\n    customer.scheduled_send_delay_hours = 2;\n  }\n  \n  if (customer.services_declined && customer.services_declined.length > 0) {\n    const declinedRecord = {...customer, comm_type: 'declined_service_followup', scheduled_send_delay_hours: 168};\n    results.push({json: declinedRecord});\n  }\n  \n  results.push({json: customer});\n}\n\nreturn results;"
      },
      "position": [900, 300]
    },
    {
      "name": "Check Already Contacted",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "executeQuery",
        "query": "SELECT COUNT(*) as cnt FROM communication_log WHERE customer_id='{{$json.customer_id}}' AND message_type='{{$json.comm_type}}' AND sent_at > NOW() - INTERVAL '7 days'"
      },
      "position": [1120, 300]
    },
    {
      "name": "Not Already Contacted?",
      "type": "n8n-nodes-base.if",
      "parameters": {
        "conditions": {
          "number": [{"value1": "={{$json.cnt}}", "operation": "equal", "value2": 0}]
        }
      },
      "position": [1340, 300]
    },
    {
      "name": "Insert Into Queue",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "insert",
        "table": "processing_queue",
        "columns": "customer_id,customer_first_name,customer_email,customer_phone,vehicle_year,vehicle_make,vehicle_model,services_performed,services_declined,service_date,advisor_name,comm_type,scheduled_send_at,status",
        "values": "={{$json.customer_id}},={{$json.customer_first_name}},={{$json.customer_email}},={{$json.customer_phone}},={{$json.vehicle_year}},={{$json.vehicle_make}},={{$json.vehicle_model}},={{$json.services_performed}},={{$json.services_declined}},={{$json.service_date}},={{$json.advisor_name}},={{$json.comm_type}},={{$now.plus($json.scheduled_send_delay_hours, 'hours').toISO()}},pending"
      },
      "position": [1560, 240]
    }
  ],
  "connections": {
    "Schedule Trigger": {"main": [[{"node": "Get DMS Auth Token", "type": "main", "index": 0}]]},
    "Get DMS Auth Token": {"main": [[{"node": "Fetch Closed Repair Orders", "type": "main", "index": 0}]]},
    "Fetch Closed Repair Orders": {"main": [[{"node": "Normalize & Categorize", "type": "main", "index": 0}]]},
    "Normalize & Categorize": {"main": [[{"node": "Check Already Contacted", "type": "main", "index": 0}]]},
    "Check Already Contacted": {"main": [[{"node": "Not Already Contacted?", "type": "main", "index": 0}]]},
    "Not Already Contacted?": {"main": [[{"node": "Insert Into Queue", "type": "main", "index": 0}], []]}
  }
}

N8N WORKFLOW STRUCTURE:

Workflow Name: AI Content Generation Engine
Trigger: Schedule every 30 minutes

Node 1 - Schedule Trigger:
  Type: scheduleTrigger
  Config: every 30 minutes

Node 2 - Fetch Pending Queue Items:
  Type: postgres
  Query: SELECT * FROM processing_queue WHERE status='pending' AND scheduled_send_at <= NOW() ORDER BY scheduled_send_at ASC LIMIT 20

Node 3 - Check If Items Exist:
  Type: if
  Condition: items.length > 0
  False path: NoOp (stop)

Node 4 - Split In Batches:
  Type: splitInBatches
  Batch Size: 5
  Options: pause between batches: 2000ms

Node 5 - Get Prompt Template:
  Type: postgres
  Query: SELECT system_prompt, user_prompt_template FROM prompt_templates WHERE communication_type='{{$json.comm_type}}' AND channel='email' AND active=true ORDER BY version DESC LIMIT 1

Node 6 - Build Prompt:
  Type: function
  Code:
    const template = items[0].json;
  const customer = $('Split In Batches').item.json;
  
  // Replace all template variables
  let systemPrompt = template.system_prompt;
  let userPrompt = template.user_prompt_template;
  
  const replacements = {
    '{{customer_first_name}}': customer.customer_first_name,
    '{{vehicle_year}}': customer.vehicle_year,
    '{{vehicle_make}}': customer.vehicle_make,
    '{{vehicle_model}}': customer.vehicle_model,
    '{{services_performed}}': customer.services_performed,
    '{{services_declined}}': customer.services_declined || 'none',
    '{{service_date}}': customer.service_date,
    '{{advisor_name}}': customer.advisor_name,
    '{{next_service_recommendation}}': customer.next_service_recommendation || 'Regular maintenance per manufacturer schedule',
    '{{next_service_due_date_or_mileage}}': customer.next_service_due || 'Per manufacturer recommendation',
    '{{estimated_current_mileage}}': customer.estimated_mileage || 'N/A',
    '{{scheduling_url}}': $env.SCHEDULING_URL || 'https://dealername.com/schedule',
    '{{google_review_url}}': $env.GOOGLE_REVIEW_URL || 'https://g.page/r/dealer/review',
    '{{service_phone}}': $env.SERVICE_PHONE || '555-0123',
    '{{dealership_name}}': $env.DEALERSHIP_NAME || 'Our Dealership'
  };
  
  for (const [key, value] of Object.entries(replacements)) {
    systemPrompt = systemPrompt.replaceAll(key, value || '');
    userPrompt = userPrompt.replaceAll(key, value || '');
  }
  
  return [{json: {
    system_prompt: systemPrompt,
    user_prompt: userPrompt,
    customer_data: customer
  }}];
  
Node 7 - Call OpenAI API:
  Type: httpRequest
  Method: POST
  URL: https://api.openai.com/v1/chat/completions
  Headers:
    Authorization: Bearer {{$credentials.openaiApiKey}}
    Content-Type: application/json
  Body:
  {
    "model": "gpt-5.4-mini",
    "temperature": 0.7,
    "max_tokens": 600,
    "response_format": {"type": "json_object"},
    "messages": [
      {"role": "system", "content": "{{$json.system_prompt}}"},
      {"role": "user", "content": "{{$json.user_prompt}}"}
    ]
  }
  Retry on Fail: true
  Max Retries: 3
  Wait Between Retries: 5000ms

Node 8 - Parse AI Response:
  Type: function
  Code:
    const aiResponse = JSON.parse(items[0].json.choices[0].message.content);
  const customer = $('Build Prompt').item.json.customer_data;
  
  // Quality validation
  const errors = [];
  if (!aiResponse.email_subject || aiResponse.email_subject.length < 10) errors.push('Missing/short subject');
  if (!aiResponse.email_body_html || aiResponse.email_body_html.length < 50) errors.push('Missing/short email body');
  if (!aiResponse.sms_body || aiResponse.sms_body.length < 20) errors.push('Missing/short SMS body');
  if (aiResponse.sms_body && aiResponse.sms_body.length > 145) errors.push('SMS too long');
  if (aiResponse.email_body_html && aiResponse.email_body_html.includes('{{')) errors.push('Unreplaced template variable in email');
  if (aiResponse.sms_body && aiResponse.sms_body.includes('{{')) errors.push('Unreplaced template variable in SMS');
  
  return [{
    json: {
      ...aiResponse,
      customer_id: customer.customer_id,
      customer_email: customer.customer_email,
      customer_phone: customer.customer_phone,
      comm_type: customer.comm_type,
      dealership_id: customer.dealership_id || 'default',
      quality_passed: errors.length === 0,
      quality_errors: errors.join('; '),
      ai_model: 'gpt-5.4-mini'
    }
  }];
  
Node 9 - Quality Gate:
  Type: if
  Condition: $json.quality_passed == true
  True: Continue to delivery queue
  False: Log error and flag for human review

Node 10 - Queue for Email Delivery:
  Type: postgres
  Insert into delivery_queue: customer_id, channel='email', subject, body_html, comm_type, scheduled_at, status='pending'

Node 11 - Queue for SMS Delivery:
  Type: postgres
  Insert into delivery_queue: customer_id, channel='sms', body=sms_body, comm_type, scheduled_at, status='pending'

Node 12 - Update Processing Queue:
  Type: postgres
  UPDATE processing_queue SET status='generated' WHERE id={{$json.queue_id}}

ERROR HANDLING:
  Error Trigger -> Function (check if OpenAI error) -> IF (rate limit?) -> Wait 60s -> Retry
  Persistent failure -> Switch to Anthropic Claude:
    URL: https://api.anthropic.com/v1/messages
    Headers: x-api-key, anthropic-version: 2023-06-01
    Body: {model: 'claude-haiku-4-5', max_tokens: 600, messages: [...]}
  Still failing -> Mark as 'failed' in queue, send alert to MSP

// Node 1: Determine Consent Requirement

// Input Parameters (passed from parent workflow):
// - customer_id (string)
// - channel ('email' | 'sms')
// - message_type ('post_service_followup' | 'maintenance_reminder' | 'declined_service_followup' | 'seasonal_campaign' | 'satisfaction_check' | 'recall_notification')
// - dealership_id (string)

const { channel, message_type } = items[0].json;

// TCPA consent classification
// Informational: service confirmations, recall notices, appointment reminders
// Promotional: marketing campaigns, upsells, seasonal offers
const informationalTypes = ['post_service_followup', 'recall_notification', 'satisfaction_check'];
const promotionalTypes = ['seasonal_campaign', 'declined_service_followup', 'maintenance_reminder'];

let required_consent_level;
if (informationalTypes.includes(message_type)) {
  required_consent_level = 'informational'; // Lower bar - existing business relationship may suffice
} else {
  required_consent_level = 'promotional'; // Requires explicit prior express written consent for SMS
}

// For email (CAN-SPAM): existing business relationship = implicit consent
// But explicit consent is always preferred
if (channel === 'email') {
  required_consent_level = 'informational'; // CAN-SPAM is opt-out based, not opt-in
}

return [{json: {...items[0].json, required_consent_level}}];

-- Node 2: Query Consent Database

SELECT 
  consent_given,
  consent_type,
  consent_timestamp,
  opt_out_timestamp,
  CASE 
    WHEN opt_out_timestamp IS NOT NULL THEN 'opted_out'
    WHEN consent_given = false THEN 'no_consent'
    WHEN consent_type = 'promotional' THEN 'full_consent'
    WHEN consent_type = 'informational' THEN 'informational_only'
    WHEN consent_type = 'transactional' THEN 'transactional_only'
    ELSE 'unknown'
  END as consent_status
FROM consent_records
WHERE customer_id = '{{$json.customer_id}}'
  AND channel = '{{$json.channel}}'
  AND dealership_id = '{{$json.dealership_id}}'
ORDER BY consent_timestamp DESC
LIMIT 1

// Node 3: Evaluate Consent

const input = $('Determine Consent Requirement').item.json;
const record = items[0].json;

let allowed = false;
let reason = '';

if (!record || !record.consent_status) {
  allowed = false;
  reason = 'No consent record found for this customer/channel';
} else if (record.consent_status === 'opted_out') {
  allowed = false;
  reason = `Customer opted out on ${record.opt_out_timestamp}`;
} else if (record.consent_status === 'no_consent') {
  allowed = false;
  reason = 'Consent record exists but consent not given';
} else if (input.required_consent_level === 'promotional' && record.consent_type === 'informational') {
  // Need promotional consent but only have informational
  if (input.channel === 'email') {
    allowed = true; // CAN-SPAM allows with opt-out mechanism
    reason = 'Email: CAN-SPAM opt-out model applies. Informational consent sufficient.';
  } else {
    allowed = false;
    reason = 'SMS promotional message requires explicit promotional consent. Customer only has informational consent.';
  }
} else {
  allowed = true;
  reason = `Valid ${record.consent_type} consent from ${record.consent_timestamp}`;
}

return [{json: {
  consent_allowed: allowed,
  consent_reason: reason,
  customer_id: input.customer_id,
  channel: input.channel,
  message_type: input.message_type,
  checked_at: new Date().toISOString()
}}];

CREATE TABLE consent_audit_log (
  id SERIAL PRIMARY KEY,
  customer_id VARCHAR(100) NOT NULL,
  channel VARCHAR(10) NOT NULL,
  message_type VARCHAR(50) NOT NULL,
  consent_allowed BOOLEAN NOT NULL,
  consent_reason TEXT,
  checked_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX idx_audit_customer ON consent_audit_log(customer_id, checked_at);

N8N WORKFLOW: Weekly Campaign Analytics Report
Trigger: Schedule every Monday at 7:00 AM

Node 1 - Aggregate Weekly Metrics:
  Type: postgres
  Query:
    SELECT 
    cm.campaign_type,
    cm.dealership_id,
    SUM(cm.total_sent) as total_sent,
    SUM(cm.total_delivered) as total_delivered,
    SUM(cm.total_opened) as total_opened,
    SUM(cm.total_clicked) as total_clicked,
    SUM(cm.total_unsubscribed) as total_unsubscribed,
    SUM(cm.total_bounced) as total_bounced,
    SUM(cm.appointments_booked) as appointments_booked,
    SUM(cm.revenue_attributed) as revenue_attributed,
    ROUND(SUM(cm.total_delivered)::numeric / NULLIF(SUM(cm.total_sent), 0) * 100, 1) as delivery_rate,
    ROUND(SUM(cm.total_opened)::numeric / NULLIF(SUM(cm.total_delivered), 0) * 100, 1) as open_rate,
    ROUND(SUM(cm.total_clicked)::numeric / NULLIF(SUM(cm.total_opened), 0) * 100, 1) as click_rate,
    ROUND(SUM(cm.total_unsubscribed)::numeric / NULLIF(SUM(cm.total_sent), 0) * 100, 2) as unsubscribe_rate
  FROM campaign_metrics cm
  WHERE cm.started_at >= NOW() - INTERVAL '7 days'
  GROUP BY cm.campaign_type, cm.dealership_id
  ORDER BY cm.campaign_type;
  
Node 2 - Get Historical Comparison:
  Type: postgres
  Query: Same query but for previous 4 weeks for trend analysis

Node 3 - Build Analytics Prompt:
  Type: function
  Code:
    const currentWeek = $('Aggregate Weekly Metrics').all();
  const history = $('Get Historical Comparison').all();
  
  const benchmarks = {
    automotive_email_open_rate: 17.5, // industry average
    automotive_email_click_rate: 2.1,
    automotive_sms_response_rate: 12.0,
    healthy_unsubscribe_rate: 0.5,
    healthy_bounce_rate: 2.0
  };
  
  const prompt = `Analyze these weekly automotive service communication metrics and generate an executive summary report.

This Week's Performance:
${JSON.stringify(currentWeek, null, 2)}

Previous 4 Weeks Trend:
${JSON.stringify(history, null, 2)}

Industry Benchmarks:
- Automotive email open rate average: ${benchmarks.automotive_email_open_rate}%
- Automotive email click rate average: ${benchmarks.automotive_email_click_rate}%
- Healthy unsubscribe rate: <${benchmarks.healthy_unsubscribe_rate}%
- Healthy bounce rate: <${benchmarks.healthy_bounce_rate}%

Generate a JSON report with:
{
  "executive_summary": "3-4 sentence overview for the dealership GM",
  "highlights": ["list of positive trends"],
  "concerns": ["list of any metrics below benchmark or negative trends"],
  "recommendations": ["specific actionable recommendations"],
  "roi_summary": "statement about appointments booked and revenue attributed this week",
  "week_over_week_trend": "improving | stable | declining"
}`;
  
  return [{json: {prompt, benchmarks, raw_metrics: currentWeek}}];
  
Node 4 - Generate AI Report:
  Type: httpRequest (OpenAI GPT-5.4 for higher quality analysis)
  Model: gpt-5.4
  Temperature: 0.3 (more analytical, less creative)

Node 5 - Format HTML Report:
  Type: function
  Build professional HTML email with dealership branding, charts placeholders, and the AI-generated insights

Node 6 - Send to Dealership Manager:
  Type: sendGrid
  To: dealership_gm@dealername.com
  Subject: 'Weekly AI Communications Performance Report - {{$now.format("MMM D, YYYY")}}'

Node 7 - Send to MSP Account Manager:
  Type: sendGrid  
  To: account_manager@yourmsp.com
  Subject: '[Client: DealerName] Weekly Performance - {{$now.format("MMM D, YYYY")}}'

docker compose pull n8n && docker compose up -d n8n

docker exec ai-comms-postgres pg_dump -U n8n compliance > /backup/compliance_$(date +%Y%m%d).sql