Smart Automation
Event-Based Telegram Message Scheduling Automation

Event-Based Telegram Scheduling

Transform your messaging strategy with intelligent event-driven automation. Send perfectly timed messages triggered by user actions, system events, API changes, and custom conditions.

Start Event AutomationExplore Events
Real-time
Event Detection
Smart
Conditions
Instant
Response

Understanding Event-Based Scheduling

Event-based scheduling sends messages in response to specific triggers rather than at predetermined times. This creates more relevant, contextual communication that responds to user behavior, system changes, or external events in real-time.

Key Benefits of Event-Based Messaging

  • Higher engagement through relevance
  • Real-time response to user actions
  • Personalized messaging at scale
  • Automated customer journey flows

Time-Based vs Event-Based

Time-Based:
"Send every Monday at 9 AM"
Event-Based:
"Send when user completes signup"

Common Use Cases

  • • Welcome messages after registration
  • • Abandoned cart reminders
  • • Order status notifications
  • • Birthday/anniversary greetings
  • • Re-engagement campaigns

Event Types & Triggers

User Behavior Events

Trigger messages based on user actions and interactions within your platform.

Common Triggers:

  • User registration/signup
  • Profile completion or updates
  • First login or activity
  • Purchase or subscription
  • Feature usage milestones
  • Inactivity periods
Example:

Send a welcome series when a user completes their profile, followed by feature tutorials based on their interests.

System & Data Events

Respond to changes in your database, application state, or system metrics.

Common Triggers:

  • Database record changes
  • Inventory level updates
  • System performance alerts
  • Backup completion status
  • Error threshold breaches
  • Scheduled maintenance windows
Example:

Alert admins when inventory drops below threshold, or notify users when their requested item is back in stock.

API & Webhook Events

Integrate with external services and third-party platforms through webhooks and API calls.

Common Triggers:

  • Payment processing updates
  • CRM contact changes
  • Email campaign interactions
  • Social media mentions
  • Weather API alerts
  • Stock price movements
Example:

Send shipping updates when payment processors webhook confirms successful payment, or weather alerts for outdoor events.

Time-Relative Events

Combine time elements with other conditions for sophisticated scheduling.

Common Triggers:

  • X days after user signup
  • Before/after important dates
  • Business hours activation
  • Recurring date patterns
  • Timezone-aware events
  • Duration-based triggers
Example:

Send onboarding tips 1, 3, and 7 days after signup, or birthday messages at optimal time in user's timezone.

Implementation Guide

Webhook-Based Events

1. Set up Webhook Endpoint

// Express.js webhook endpoint
app.post('/webhook/user-events', async (req, res) => {
  const { event, user, data } = req.body;
  
  switch(event) {
    case 'user.registered':
      await scheduleWelcomeSeries(user.id, user.telegram_id);
      break;
    case 'purchase.completed':
      await sendOrderConfirmation(user.telegram_id, data.order);
      break;
    case 'cart.abandoned':
      await scheduleReminderAfterDelay(user.telegram_id, data.cart, '2h');
      break;
  }
  
  res.status(200).json({ status: 'processed' });
});

2. Event Processing Logic

async function scheduleWelcomeSeries(userId, telegramId) {
  const welcomeEvents = [
    { delay: '0', message: 'Welcome! Thanks for joining us! 🎉' },
    { delay: '1d', message: 'Here are some tips to get started...' },
    { delay: '3d', message: 'How are you finding the platform?' },
  ];
  
  for (const event of welcomeEvents) {
    await scheduleMessage({
      telegramId,
      message: event.message,
      sendAt: moment().add(event.delay).toDate(),
      eventType: 'welcome_series',
      userId
    });
  }
}

Database Trigger Events

PostgreSQL Trigger

CREATE OR REPLACE FUNCTION notify_telegram_event()
RETURNS trigger AS $$
BEGIN
  PERFORM pg_notify('telegram_events', 
    json_build_object(
      'event', TG_OP,
      'table', TG_TABLE_NAME,
      'data', row_to_json(NEW)
    )::text
  );
  RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER user_status_changed
  AFTER UPDATE ON users
  FOR EACH ROW
  EXECUTE FUNCTION notify_telegram_event();

Node.js Listener

const client = new Client(connectionString);
await client.connect();

client.on('notification', async (msg) => {
  const event = JSON.parse(msg.payload);
  
  if (event.table === 'users' && event.data.status === 'premium') {
    await sendTelegramMessage(
      event.data.telegram_id,
      '🎉 Welcome to Premium! Here are your new features...'
    );
  }
});

await client.query('LISTEN telegram_events');

Queue, Delay Buffer & Retry

Event tabanlı akışlarda gecikme tamponu (delay buffer) ve kuyruk kullanmak, iptal edilebilirlik ve ölçeklenebilirlik sağlar.

// BullMQ example
import { Queue, Worker, QueueScheduler, JobsOptions } from 'bullmq';

const queue = new Queue('telegram-events', { connection: { host: '127.0.0.1', port: 6379 }});
new QueueScheduler('telegram-events', { connection: { host: '127.0.0.1', port: 6379 }});

export async function enqueueTelegramMessage(payload: { chatId: string; text: string }, opts: JobsOptions = {}) {
  // delay buffer: allow cancel/edit within N minutes
  const job = await queue.add('send-message', payload, {
    delay: opts.delay ?? 2 * 60 * 1000, // 2 min
    attempts: 5,
    backoff: { type: 'exponential', delay: 3000 },
    removeOnComplete: true,
    removeOnFail: false
  });
  return job.id;
}

new Worker('telegram-events', async (job) => {
  const { chatId, text } = job.data;
  // call Telegram API here
});

Advanced Patterns

Decision Engine (Rules + Scoring)

Kurallar, segmentler ve skorlamayı birleştirerek hangi mesajın tetikleneceğini belirleyin.

function chooseMessage(user, context) {
  const rules = [
    { when: user.isNew && context.event === 'user.registered', message: '👋 Welcome!' },
    { when: context.cartAbandoned && context.hoursSinceAbandon > 2, message: '🛒 Forgot something?' },
    { when: user.tier === 'premium' && context.event === 'renewal.reminder', message: '✨ Premium renewal reminder' },
  ];
  return rules.find(r => r.when)?.message ?? null;
}

Idempotency & De-Duplication

Aynı event için birden fazla gönderimi engellemek adına idempotent anahtarlar kullanın.

// Redis SETNX pattern
// key: event:{eventId}
// value: timestamp
// expire: 10 minutes
async function lockEvent(eventId) {
  const ok = await redis.setNX(`event:${eventId}`, Date.now());
  if (ok) await redis.expire(`event:${eventId}`, 600);
  return ok;
}

Quiet Hours & Consent Gates

Kullanıcıların sessiz saatlerine saygı gösterin ve izne dayalı tetiklemeler uygulayın.

  • • Local-time hesaplama ve esnetilebilir teslim pencereleri
  • • Hassas tetiklerde ikinci onay (double opt-in)
  • • Sessiz saatlerde kuyruğa alıp sabah iletimi

Dead Letter Queue (DLQ)

Sürekli hata veren işleri DLQ’ya gönderip ayrı bir süreçte inceleyin ve gerekiyorsa manuel yeniden işleyin.

  • • Hata kodu, gövde ve tekrar sayısını loglayın
  • • Otomatik geri alma ve bildirimler ekleyin

Best Practices

✅ Do's

  • ✓ Webhook imzası ve doğrulama ekleyin
  • ✓ Kuyruk + geri alma stratejisi kullanın
  • ✓ Idempotency anahtarlarıyla çift gönderimi engelleyin
  • ✓ Sessiz saatlere saygı duyun, yerel saate göre planlayın

❌ Don'ts

  • ✗ Tüm eventleri anında, filtresiz tetiklemeyin
  • ✗ 429/flood control uyarılarını yok saymayın
  • ✗ Kullanıcı onayı olmadan özel gün bildirimleri göndermeyin
  • ✗ Hata loglarını ve DLQ’yu ihmal etmeyin
Pro tip: Kritik eventlerde two-step confirm kullan — ilk mesaj, kullanıcıdan onay alır; onaylanırsa asıl aksiyon mesajı gönderilir.

Frequently Asked Questions

What's the difference between time-based and event-based scheduling?▼

Time-based scheduling sends messages at specific times (cron-like), while event-based triggers messages when certain conditions or actions occur (user signup, purchase, etc.).

Can I combine multiple events in one trigger?▼

Yes! You can create complex conditions using AND/OR logic, such as 'user registered AND hasn't purchased within 3 days'.

How fast do event-triggered messages get delivered?▼

Typically within seconds to minutes, depending on your webhook/polling setup and Telegram's rate limits.

Can I cancel an event-triggered message before it's sent?▼

Yes, if you implement a delay buffer or queue system. Immediate triggers are harder to cancel once the event occurs.

What happens if my webhook endpoint is down?▼

Most platforms offer retry mechanisms with exponential backoff. You should also implement dead letter queues for failed events.

Ready to build event-driven flows?

Trigger messages at the perfect moment using webhooks, queues and smart conditions — all while respecting rate limits and user consent.

Start with WapiuuExplore Weekly Campaigns