Notification Personalization: How to Segment Users for Better Engagement

// Before: Generic
const message = "Your order has shipped!"
 
// After: Personalized
const message = `Hi ${user.firstName}, your order #${order.id} has shipped!`

const getShippingMessage = (user: User, order: Order) => {
  const estimate = getDeliveryEstimate(order, user.address)
  const trackingUrl = `https://track.example.com/${order.trackingNumber}`
 
  return {
    subject: `${user.firstName}, your ${order.items[0].name} is on the way!`,
    body: `
      Great news! Your order is shipping to ${user.address.city}.
 
      Estimated delivery: ${estimate.date}
      ${estimate.isExpress ? '🚀 Express shipping - arriving faster!' : ''}
 
      Track your package: ${trackingUrl}
    `
  }
}

const getReEngagementMessage = (user: User) => {
  const daysSinceLastVisit = getDaysSince(user.lastActiveAt)
  const favoriteCategory = user.mostViewedCategory
 
  if (daysSinceLastVisit > 30) {
    return {
      subject: `We miss you, ${user.firstName}!`,
      body: `It's been a while. Check out what's new in ${favoriteCategory}.`,
      incentive: '20% off your next order'
    }
  } else if (daysSinceLastVisit > 14) {
    return {
      subject: `New arrivals in ${favoriteCategory}`,
      body: `Based on your interests, we think you'll love these.`,
      incentive: null
    }
  }
 
  return null // Don't send to active users
}

import { NotiGrid } from '@notigrid/node'
 
const notigrid = new NotiGrid({ apiKey: process.env.NOTIGRID_API_KEY })
 
// Define segments
const segments = {
  powerUsers: (user: User) => user.sessionsThisMonth >= 10,
  atRisk: (user: User) => daysSince(user.lastActiveAt) >= 14,
  newUsers: (user: User) => daysSince(user.createdAt) <= 7,
}
 
// Send segmented notification
async function sendFeatureAnnouncement(feature: Feature) {
  const powerUsers = await db.users.findMany({
    where: { sessionsThisMonth: { gte: 10 } }
  })
 
  for (const user of powerUsers) {
    await notigrid.notify({
      channel: 'feature-announcement',
      recipient: { userId: user.id, email: user.email },
      variables: {
        user_name: user.firstName,
        feature_name: feature.name,
        feature_description: feature.description,
        beta_access_url: `https://app.example.com/beta/${feature.slug}`,
      }
    })
  }
}

interface RFMScore {
  recency: 1 | 2 | 3 | 4 | 5    // Days since last purchase
  frequency: 1 | 2 | 3 | 4 | 5  // Number of purchases
  monetary: 1 | 2 | 3 | 4 | 5   // Total spend
}
 
function calculateRFM(user: User): RFMScore {
  const daysSinceLastPurchase = getDaysSince(user.lastPurchaseAt)
  const purchaseCount = user.totalOrders
  const totalSpend = user.lifetimeValue
 
  return {
    recency: scoreRecency(daysSinceLastPurchase),
    frequency: scoreFrequency(purchaseCount),
    monetary: scoreMonetary(totalSpend),
  }
}
 
function getSegmentFromRFM(rfm: RFMScore): string {
  const score = rfm.recency + rfm.frequency + rfm.monetary
 
  if (score >= 12) return 'champions'      // Best customers
  if (score >= 9) return 'loyal'           // Regular buyers
  if (score >= 6) return 'potential'       // Could be more engaged
  if (rfm.recency <= 2) return 'at_risk'   // Recently inactive
  return 'hibernating'                      // Need reactivation
}

Hi {{user_name}},
 
{{#if is_premium_user}}
As a Premium member, you get early access to our new collection!
{{else}}
Check out our new collection - Premium members got first access yesterday.
{{/if}}
 
{{#if has_items_in_cart}}
Don't forget - you have {{cart_item_count}} items waiting in your cart.
{{/if}}
 
{{#if preferred_language == "es"}}
¿Prefieres leer esto en español? [Cambiar idioma]
{{/if}}

async function getPersonalizedRecommendations(user: User) {
  const viewedCategories = user.recentlyViewedCategories
  const purchasedProducts = user.purchasedProductIds
 
  // Get products from viewed categories, excluding purchased
  const recommendations = await db.products.findMany({
    where: {
      categoryId: { in: viewedCategories },
      id: { notIn: purchasedProducts },
    },
    orderBy: { popularity: 'desc' },
    take: 3,
  })
 
  return recommendations.map(p => ({
    name: p.name,
    price: formatCurrency(p.price, user.currency),
    image_url: p.imageUrl,
    product_url: `https://shop.example.com/p/${p.slug}`,
  }))
}
 
// Use in notification
await notigrid.notify({
  channel: 'weekly-recommendations',
  recipient: { userId: user.id, email: user.email },
  variables: {
    user_name: user.firstName,
    recommendations: await getPersonalizedRecommendations(user),
  }
})

function getTimeBasedGreeting(user: User): string {
  const userTime = getUserLocalTime(user.timezone)
  const hour = userTime.getHours()
 
  if (hour < 12) return `Good morning, ${user.firstName}`
  if (hour < 17) return `Good afternoon, ${user.firstName}`
  return `Good evening, ${user.firstName}`
}
 
function getUrgencyMessage(deadline: Date, user: User): string {
  const userTime = getUserLocalTime(user.timezone)
  const hoursUntilDeadline = differenceInHours(deadline, userTime)
 
  if (hoursUntilDeadline <= 2) return '⚡ Ending very soon!'
  if (hoursUntilDeadline <= 24) return `⏰ Only ${hoursUntilDeadline} hours left`
  if (hoursUntilDeadline <= 72) return `Ends in ${Math.ceil(hoursUntilDeadline / 24)} days`
  return ''
}

interface UserPreferences {
  preferredChannel: 'email' | 'sms' | 'push' | 'slack'
  emailEnabled: boolean
  smsEnabled: boolean
  pushEnabled: boolean
  quietHoursStart: number // 0-23
  quietHoursEnd: number
}
 
async function sendWithPreferences(
  user: User,
  notification: Notification
) {
  const prefs = await getUserPreferences(user.id)
 
  // Respect quiet hours for non-critical notifications
  if (!notification.critical && isQuietHours(prefs, user.timezone)) {
    await scheduleForLater(user, notification, prefs.quietHoursEnd)
    return
  }
 
  // Use preferred channel if enabled
  const channel = selectChannel(prefs, notification.priority)
 
  await notigrid.notify({
    channel: `${notification.type}-${channel}`,
    recipient: { userId: user.id },
    variables: notification.variables,
  })
}
 
function selectChannel(
  prefs: UserPreferences,
  priority: 'critical' | 'high' | 'normal' | 'low'
): string {
  // Critical notifications use SMS if available
  if (priority === 'critical' && prefs.smsEnabled) {
    return 'sms'
  }
 
  // Otherwise use preferred channel
  if (prefs.preferredChannel === 'email' && prefs.emailEnabled) {
    return 'email'
  }
  if (prefs.preferredChannel === 'sms' && prefs.smsEnabled) {
    return 'sms'
  }
  if (prefs.preferredChannel === 'push' && prefs.pushEnabled) {
    return 'push'
  }
 
  // Fallback to email
  return 'email'
}

async function sendWithEscalation(user: User, notification: Notification) {
  // Start with preferred channel
  const result = await notigrid.notify({
    channel: `${notification.type}-${user.preferredChannel}`,
    recipient: { userId: user.id },
    variables: notification.variables,
  })
 
  // If high priority and not opened within 1 hour, escalate
  if (notification.priority === 'high') {
    await scheduleEscalation({
      notificationId: result.id,
      userId: user.id,
      escalateAfterMinutes: 60,
      escalateToChannel: 'sms',
    })
  }
}

function buildNotificationVariables(user: User, order: Order) {
  return {
    // Use fallback for missing name
    user_name: user.firstName || user.email.split('@')[0] || 'there',
 
    // Format with fallback currency
    order_total: formatCurrency(
      order.total,
      user.currency || order.currency || 'USD'
    ),
 
    // Default to first item if multiple
    product_name: order.items[0]?.name || 'your order',
 
    // Safe navigation for optional fields
    loyalty_points: user.loyaltyPoints?.toLocaleString() || '0',
 
    // Timezone-safe date formatting
    delivery_date: formatDate(
      order.estimatedDelivery,
      user.timezone || 'UTC',
      user.locale || 'en-US'
    ),
  }
}

const translations = {
  en: {
    orderConfirmation: {
      subject: 'Order {{order_id}} confirmed!',
      greeting: 'Hi {{user_name}},',
      body: 'Thank you for your order.',
    }
  },
  es: {
    orderConfirmation: {
      subject: '¡Pedido {{order_id}} confirmado!',
      greeting: 'Hola {{user_name}},',
      body: 'Gracias por tu pedido.',
    }
  },
  fr: {
    orderConfirmation: {
      subject: 'Commande {{order_id}} confirmée !',
      greeting: 'Bonjour {{user_name}},',
      body: 'Merci pour votre commande.',
    }
  }
}
 
function getLocalizedTemplate(
  templateKey: string,
  locale: string
): NotificationTemplate {
  const lang = locale.split('-')[0] // 'en-US' -> 'en'
  return translations[lang]?.[templateKey] || translations.en[templateKey]
}

async function sendWithABTest(
  users: User[],
  notification: Notification,
  variants: NotificationVariant[]
) {
  // Randomly assign users to variants
  const assignments = users.map(user => ({
    user,
    variant: variants[Math.floor(Math.random() * variants.length)],
  }))
 
  // Send notifications
  for (const { user, variant } of assignments) {
    await notigrid.notify({
      channel: notification.channel,
      recipient: { userId: user.id },
      variables: {
        ...notification.variables,
        ...variant.variables,
      },
      metadata: {
        abTestId: notification.testId,
        variantId: variant.id,
      }
    })
  }
 
  // Track results after 24 hours
  await scheduleAnalysis(notification.testId, 24 * 60 * 60 * 1000)
}

import { NotiGrid } from '@notigrid/node'
 
const notigrid = new NotiGrid({ apiKey: process.env.NOTIGRID_API_KEY })
 
// Personalized notification with all the features
await notigrid.notify({
  channel: 'order-confirmation',
  recipient: {
    userId: user.id,
    email: user.email,
    locale: user.locale,
    timezone: user.timezone,
  },
  variables: {
    user_name: user.firstName,
    order_id: order.id,
    order_total: formatCurrency(order.total, user.currency),
    items: order.items.map(formatItem),
    delivery_estimate: order.estimatedDelivery,
    recommendations: await getRecommendations(user),
  },
  preferences: {
    respectQuietHours: true,
    preferredChannel: user.preferredChannel,
  }
})