Intervals
Schedule Notifications at Scale

High-performance, distributed notification scheduling system for time-sensitive alerts, promotional campaigns, and workflow automation.

Get Started Documentation

What is Intervals?

Intervals is a robust application designed to schedule and trigger notifications at specified times in the future with exceptional performance and reliability.

High Performance

Minimal latency delivery with optimized processing for time-critical notifications.

High Throughput

Handles large volumes of concurrent notifications with ease.

Scalable

Horizontal scaling from small workloads to enterprise-level deployments.

Reliable

Built on Kafka + MongoDB with distributed locking for fault tolerance.

Flexible Scheduling

ISO 8601 support - single and periodic scheduling options.

Time-Sensitive

Perfect for reminders, alerts, promotional campaigns, and workflow automation.

How It Works

Simple flow: Send → Wait → Receive

Your Application
(Producer)
→
Intervals
Schedules & tracks time
→
Your Application
(Consumer)

Intervals continuously monitor the current time and deliver your message when scheduled

Quick Integration

Get started in minutes with just a few lines of code

Step 1: Send a Scheduled Message

val producer = KafkaProducer<String, ByteArray>(properties)

val record = ProducerRecord<String, ByteArray>(
    "assignments.<your-tenant>",
    payload
)

record.headers().add("intervals-schedule", "2026-07-21T19:20:30.45Z")

producer.send(record)

Step 2: Receive the Execution

consumer.subscribe("executions.t30600")

// When the scheduled time arrives,
// the message will be delivered here
// with all original headers preserved

Step 1: Send a Scheduled Message

from kafka import KafkaProducer
import json

producer = KafkaProducer(bootstrap_servers='localhost:9092')

topic = "assignments.<your-tenant>"
payload = json.dumps({"message": "Hello"}).encode('utf-8')

producer.send(
    topic,
    value=payload,
    headers=[
        ("intervals-schedule", "2026-07-21T19:20:30.45Z".encode()),
        ("intervals-tenant-id", "your-tenant".encode())
    ]
)

producer.flush()

Step 2: Receive the Execution

from kafka import KafkaConsumer

consumer = KafkaConsumer(
    'executions.t30600',
    bootstrap_servers='localhost:9092',
    auto_offset_reset='earliest'
)

for message in consumer:
    # When the scheduled time arrives,
    # the message will be delivered here
    # with all original headers preserved
    print(message.value)

Step 1: Send a Scheduled Message

const { Kafka } = require('kafkajs');

const kafka = new Kafka({
  clientId: 'my-app',
  brokers: ['localhost:9092']
});

const producer = kafka.producer();
await producer.connect();

await producer.send({
  topic: "assignments.<your-tenant>",
  messages: [
    {
      value: JSON.stringify({ message: "Hello" }),
      headers: {
        "intervals-schedule": "2026-07-21T19:20:30.45Z"
      }
    }
  ]
});

Step 2: Receive the Execution

const consumer = kafka.consumer({ groupId: 'test-group' });
await consumer.connect();
await consumer.subscribe({ topic: 'executions.t30600' });

await consumer.run({
  eachMessage: async ({ topic, partition, message }) => {
    // When the scheduled time arrives,
    // the message will be delivered here
    // with all original headers preserved
    console.log(message.value.toString());
  },
});

Schedule Formats

Intervals uses ISO 8601 based scheduling for maximum flexibility

Single

Execute once at the specified time.

2026-07-16T19:20:30.45Z

Periodic

Execute every interval from start to end date.

R/2026-07-16T19:20:30.45Z/PT7H/2026-07-17T20:20:30.45Z

Contact

Get in touch with us

Email us at:

intervals.application@gmail.com