diff --git a/README.md b/README.md
index 3de02591..9b4af560 100644
--- a/README.md
+++ b/README.md
@@ -46,6 +46,7 @@ Content creators and community contributors lack a simple, transparent way to re
 ## Features
 
 - **Direct STX Tipping** - Send micro-tips to any Stacks address with optional messages
+- **Scheduled Tips** - Schedule tips to be sent at a future date and time (up to 365 days in advance)
 - **Batch Tipping** - Tip up to 50 recipients in a single transaction with strict or partial modes
 - **Recursive Tipping (Tip-a-Tip)** - Tip someone back directly from the live feed
 - **User Profiles** - Set a display name, bio, and avatar URL stored on-chain
@@ -137,6 +138,8 @@ See [ARCHITECTURE.md](ARCHITECTURE.md) for the full system design.
 | `/send` | Send Tip | Send a single STX tip | Stable |
 | `/batch` | Batch Tip | Tip up to 50 recipients at once | Stable |
 | `/token-tip` | Token Tip | Send a SIP-010 token tip (beta) | Beta |
+| `/schedule` | Schedule Tip | Schedule a tip for future execution | Stable |
+| `/scheduled-tips` | Scheduled Tips | View and manage scheduled tips | Stable |
 | `/feed` | Live Feed | Real-time feed of recent tips with pagination | Stable |
 | `/leaderboard` | Leaderboard | Top senders and receivers | Stable |
 | `/activity` | My Activity | Personal tip history | Stable |
diff --git a/chainhook/job-processor.js b/chainhook/job-processor.js
new file mode 100644
index 00000000..e0122b97
--- /dev/null
+++ b/chainhook/job-processor.js
@@ -0,0 +1,220 @@
+import { logger } from './logging.js';
+import { SCHEDULED_TIP_STATUSES } from './scheduler.js';
+
+const PROCESSING_INTERVAL_MS = 60000;
+const NOTIFICATION_LEAD_MINUTES = 60;
+
+class JobProcessor {
+  constructor(scheduledTipStore, options = {}) {
+    this.store = scheduledTipStore;
+    this.processingInterval = options.processingInterval || PROCESSING_INTERVAL_MS;
+    this.notificationLeadMinutes = options.notificationLeadMinutes || NOTIFICATION_LEAD_MINUTES;
+    this.intervalId = null;
+    this.isProcessing = false;
+    this.onExecuteTip = options.onExecuteTip || null;
+    this.onNotifyTip = options.onNotifyTip || null;
+  }
+
+  start() {
+    if (this.intervalId) {
+      logger.warn('Job processor already running');
+      return;
+    }
+
+    logger.info('Starting scheduled tip job processor', {
+      processing_interval_ms: this.processingInterval,
+      notification_lead_minutes: this.notificationLeadMinutes,
+    });
+
+    this.intervalId = setInterval(() => {
+      this.processJobs().catch(err => {
+        logger.error('Job processing failed', err, {
+          error_message: err.message,
+        });
+      });
+    }, this.processingInterval);
+
+    this.processJobs().catch(err => {
+      logger.error('Initial job processing failed', err);
+    });
+  }
+
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+      logger.info('Scheduled tip job processor stopped');
+    }
+  }
+
+  async processJobs() {
+    if (this.isProcessing) {
+      logger.debug('Job processing already in progress, skipping');
+      return;
+    }
+
+    this.isProcessing = true;
+
+    try {
+      await this.processNotifications();
+      await this.processPendingTips();
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+
+  async processNotifications() {
+    try {
+      const notifiableTips = await this.store.getNotifiableScheduledTips(this.notificationLeadMinutes);
+
+      if (notifiableTips.length === 0) {
+        return;
+      }
+
+      logger.info('Processing notifications for scheduled tips', {
+        count: notifiableTips.length,
+      });
+
+      for (const tip of notifiableTips) {
+        try {
+          if (this.onNotifyTip) {
+            await this.onNotifyTip(tip);
+          }
+
+          await this.store.updateScheduledTip(tip.id, {
+            notifiedAt: new Date(),
+          });
+
+          logger.info('Notification sent for scheduled tip', {
+            id: tip.id,
+            sender: tip.sender,
+            scheduled_for: tip.scheduledFor,
+          });
+        } catch (err) {
+          logger.error('Failed to notify scheduled tip', err, {
+            id: tip.id,
+            error_message: err.message,
+          });
+        }
+      }
+    } catch (err) {
+      logger.error('Failed to process notifications', err);
+    }
+  }
+
+  async processPendingTips() {
+    try {
+      const pendingTips = await this.store.getPendingScheduledTips();
+
+      if (pendingTips.length === 0) {
+        return;
+      }
+
+      logger.info('Processing pending scheduled tips', {
+        count: pendingTips.length,
+      });
+
+      for (const tip of pendingTips) {
+        await this.processSingleTip(tip);
+      }
+    } catch (err) {
+      logger.error('Failed to process pending tips', err);
+    }
+  }
+
+  async processSingleTip(tip) {
+    try {
+      await this.store.updateScheduledTip(tip.id, {
+        status: SCHEDULED_TIP_STATUSES.PROCESSING,
+      });
+
+      logger.info('Executing scheduled tip', {
+        id: tip.id,
+        sender: tip.sender,
+        recipient: tip.recipient,
+        amount: tip.amount,
+      });
+
+      let txId = null;
+      let failureReason = null;
+
+      if (this.onExecuteTip) {
+        try {
+          const result = await this.onExecuteTip(tip);
+          txId = result.txId;
+        } catch (err) {
+          failureReason = err.message || 'execution failed';
+          logger.error('Failed to execute scheduled tip', err, {
+            id: tip.id,
+            error_message: err.message,
+          });
+        }
+      } else {
+        logger.warn('No execution handler configured for scheduled tips', {
+          id: tip.id,
+        });
+        failureReason = 'no execution handler configured';
+      }
+
+      if (txId) {
+        await this.store.updateScheduledTip(tip.id, {
+          status: SCHEDULED_TIP_STATUSES.EXECUTED,
+          executedAt: new Date(),
+          txId,
+        });
+
+        logger.info('Scheduled tip executed successfully', {
+          id: tip.id,
+          tx_id: txId,
+        });
+      } else {
+        await this.store.updateScheduledTip(tip.id, {
+          status: SCHEDULED_TIP_STATUSES.FAILED,
+          failureReason,
+        });
+
+        logger.error('Scheduled tip execution failed', {
+          id: tip.id,
+          failure_reason: failureReason,
+        });
+      }
+    } catch (err) {
+      logger.error('Failed to process scheduled tip', err, {
+        id: tip.id,
+        error_message: err.message,
+      });
+
+      try {
+        await this.store.updateScheduledTip(tip.id, {
+          status: SCHEDULED_TIP_STATUSES.FAILED,
+          failureReason: err.message || 'processing error',
+        });
+      } catch (updateErr) {
+        logger.error('Failed to update failed scheduled tip status', updateErr, {
+          id: tip.id,
+        });
+      }
+    }
+  }
+
+  async getStats() {
+    const pendingCount = await this.store.countScheduledTips(SCHEDULED_TIP_STATUSES.PENDING);
+    const processingCount = await this.store.countScheduledTips(SCHEDULED_TIP_STATUSES.PROCESSING);
+    const executedCount = await this.store.countScheduledTips(SCHEDULED_TIP_STATUSES.EXECUTED);
+    const failedCount = await this.store.countScheduledTips(SCHEDULED_TIP_STATUSES.FAILED);
+    const cancelledCount = await this.store.countScheduledTips(SCHEDULED_TIP_STATUSES.CANCELLED);
+
+    return {
+      pending: pendingCount,
+      processing: processingCount,
+      executed: executedCount,
+      failed: failedCount,
+      cancelled: cancelledCount,
+      total: pendingCount + processingCount + executedCount + failedCount + cancelledCount,
+      is_running: !!this.intervalId,
+      processing_interval_ms: this.processingInterval,
+    };
+  }
+}
+
+export { JobProcessor, PROCESSING_INTERVAL_MS, NOTIFICATION_LEAD_MINUTES };
diff --git a/chainhook/scheduler.js b/chainhook/scheduler.js
new file mode 100644
index 00000000..d2ce5aa5
--- /dev/null
+++ b/chainhook/scheduler.js
@@ -0,0 +1,142 @@
+import { randomUUID } from 'node:crypto';
+
+const SCHEDULED_TIP_STATUSES = {
+  PENDING: 'pending',
+  PROCESSING: 'processing',
+  EXECUTED: 'executed',
+  CANCELLED: 'cancelled',
+  FAILED: 'failed',
+};
+
+const MIN_SCHEDULE_MINUTES = 5;
+const MAX_SCHEDULE_DAYS = 365;
+
+function validateScheduledTime(scheduledFor) {
+  const scheduledDate = new Date(scheduledFor);
+  const now = new Date();
+
+  if (isNaN(scheduledDate.getTime())) {
+    return { valid: false, error: 'Invalid scheduled date format' };
+  }
+
+  const minTime = new Date(now.getTime() + MIN_SCHEDULE_MINUTES * 60 * 1000);
+  if (scheduledDate < minTime) {
+    return { valid: false, error: `Scheduled time must be at least ${MIN_SCHEDULE_MINUTES} minutes in the future` };
+  }
+
+  const maxTime = new Date(now.getTime() + MAX_SCHEDULE_DAYS * 24 * 60 * 60 * 1000);
+  if (scheduledDate > maxTime) {
+    return { valid: false, error: `Scheduled time cannot be more than ${MAX_SCHEDULE_DAYS} days in the future` };
+  }
+
+  return { valid: true };
+}
+
+function validateScheduledTipParams(params) {
+  const { sender, recipient, amount, scheduledFor, message, category } = params;
+
+  if (!sender || typeof sender !== 'string') {
+    return { valid: false, error: 'Sender address is required' };
+  }
+
+  if (!recipient || typeof recipient !== 'string') {
+    return { valid: false, error: 'Recipient address is required' };
+  }
+
+  if (sender === recipient) {
+    return { valid: false, error: 'Cannot schedule a tip to yourself' };
+  }
+
+  const amountNum = Number(amount);
+  if (!amount || isNaN(amountNum) || amountNum <= 0) {
+    return { valid: false, error: 'Amount must be a positive number' };
+  }
+
+  if (amountNum < 1000) {
+    return { valid: false, error: 'Minimum tip amount is 1000 microSTX (0.001 STX)' };
+  }
+
+  if (amountNum > 10000000000000) {
+    return { valid: false, error: 'Maximum tip amount is 10,000,000,000,000 microSTX (10,000 STX)' };
+  }
+
+  const timeValidation = validateScheduledTime(scheduledFor);
+  if (!timeValidation.valid) {
+    return timeValidation;
+  }
+
+  if (message && typeof message !== 'string') {
+    return { valid: false, error: 'Message must be a string' };
+  }
+
+  if (message && message.length > 280) {
+    return { valid: false, error: 'Message must be 280 characters or less' };
+  }
+
+  if (category !== undefined && (typeof category !== 'number' || category < 0)) {
+    return { valid: false, error: 'Category must be a non-negative number' };
+  }
+
+  return { valid: true };
+}
+
+class ScheduledTip {
+  constructor(data) {
+    this.id = data.id || randomUUID();
+    this.sender = data.sender;
+    this.recipient = data.recipient;
+    this.amount = data.amount;
+    this.scheduledFor = new Date(data.scheduledFor);
+    this.message = data.message || '';
+    this.category = data.category ?? 0;
+    this.status = data.status || SCHEDULED_TIP_STATUSES.PENDING;
+    this.createdAt = data.createdAt ? new Date(data.createdAt) : new Date();
+    this.updatedAt = data.updatedAt ? new Date(data.updatedAt) : new Date();
+    this.executedAt = data.executedAt ? new Date(data.executedAt) : null;
+    this.txId = data.txId || null;
+    this.failureReason = data.failureReason || null;
+    this.notifiedAt = data.notifiedAt ? new Date(data.notifiedAt) : null;
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      sender: this.sender,
+      recipient: this.recipient,
+      amount: this.amount,
+      scheduledFor: this.scheduledFor.toISOString(),
+      message: this.message,
+      category: this.category,
+      status: this.status,
+      createdAt: this.createdAt.toISOString(),
+      updatedAt: this.updatedAt.toISOString(),
+      executedAt: this.executedAt ? this.executedAt.toISOString() : null,
+      txId: this.txId,
+      failureReason: this.failureReason,
+      notifiedAt: this.notifiedAt ? this.notifiedAt.toISOString() : null,
+    };
+  }
+
+  isPending() {
+    return this.status === SCHEDULED_TIP_STATUSES.PENDING;
+  }
+
+  isExecutable() {
+    return this.isPending() && this.scheduledFor <= new Date();
+  }
+
+  isNotifiable(notificationLeadMinutes = 60) {
+    if (!this.isPending() || this.notifiedAt) return false;
+    const notificationTime = new Date(this.scheduledFor.getTime() - notificationLeadMinutes * 60 * 1000);
+    return new Date() >= notificationTime;
+  }
+}
+
+export {
+  ScheduledTip,
+  SCHEDULED_TIP_STATUSES,
+  validateScheduledTime,
+  validateScheduledTipParams,
+  MIN_SCHEDULE_MINUTES,
+  MAX_SCHEDULE_DAYS,
+};
diff --git a/chainhook/scheduler.test.js b/chainhook/scheduler.test.js
new file mode 100644
index 00000000..43b28897
--- /dev/null
+++ b/chainhook/scheduler.test.js
@@ -0,0 +1,190 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { ScheduledTip, validateScheduledTipParams, validateScheduledTime, SCHEDULED_TIP_STATUSES, MIN_SCHEDULE_MINUTES, MAX_SCHEDULE_DAYS } from './scheduler.js';
+
+test('ScheduledTip creates with default values', () => {
+  const tip = new ScheduledTip({
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000).toISOString(),
+  });
+
+  assert.ok(tip.id);
+  assert.strictEqual(tip.sender, 'SP2J6Z...ABC');
+  assert.strictEqual(tip.recipient, 'SP3K5...XYZ');
+  assert.strictEqual(tip.amount, 1000000);
+  assert.strictEqual(tip.status, SCHEDULED_TIP_STATUSES.PENDING);
+  assert.strictEqual(tip.message, '');
+  assert.strictEqual(tip.category, 0);
+  assert.ok(tip.createdAt);
+  assert.ok(tip.updatedAt);
+  assert.strictEqual(tip.executedAt, null);
+  assert.strictEqual(tip.txId, null);
+  assert.strictEqual(tip.failureReason, null);
+});
+
+test('ScheduledTip.toJSON returns expected structure', () => {
+  const tip = new ScheduledTip({
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000).toISOString(),
+  });
+
+  const json = tip.toJSON();
+
+  assert.strictEqual(typeof json.id, 'string');
+  assert.strictEqual(json.sender, 'SP2J6Z...ABC');
+  assert.strictEqual(json.recipient, 'SP3K5...XYZ');
+  assert.strictEqual(json.amount, 1000000);
+  assert.strictEqual(json.status, 'pending');
+});
+
+test('ScheduledTip.isPending returns true for pending status', () => {
+  const tip = new ScheduledTip({
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000).toISOString(),
+    status: SCHEDULED_TIP_STATUSES.PENDING,
+  });
+
+  assert.strictEqual(tip.isPending(), true);
+});
+
+test('ScheduledTip.isPending returns false for non-pending status', () => {
+  const tip = new ScheduledTip({
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000).toISOString(),
+    status: SCHEDULED_TIP_STATUSES.EXECUTED,
+  });
+
+  assert.strictEqual(tip.isPending(), false);
+});
+
+test('ScheduledTip.isExecutable returns true when scheduled time has passed', () => {
+  const tip = new ScheduledTip({
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() - 1000).toISOString(),
+    status: SCHEDULED_TIP_STATUSES.PENDING,
+  });
+
+  assert.strictEqual(tip.isExecutable(), true);
+});
+
+test('ScheduledTip.isExecutable returns false when scheduled time has not passed', () => {
+  const tip = new ScheduledTip({
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000).toISOString(),
+    status: SCHEDULED_TIP_STATUSES.PENDING,
+  });
+
+  assert.strictEqual(tip.isExecutable(), false);
+});
+
+test('validateScheduledTime rejects past dates', () => {
+  const pastDate = new Date(Date.now() - 3600000).toISOString();
+  const result = validateScheduledTime(pastDate);
+
+  assert.strictEqual(result.valid, false);
+  assert.ok(result.error.includes('at least'));
+});
+
+test('validateScheduledTime accepts future dates', () => {
+  const futureDate = new Date(Date.now() + (MIN_SCHEDULE_MINUTES + 5) * 60 * 1000).toISOString();
+  const result = validateScheduledTime(futureDate);
+
+  assert.strictEqual(result.valid, true);
+});
+
+test('validateScheduledTime rejects dates too far in the future', () => {
+  const farFutureDate = new Date(Date.now() + (MAX_SCHEDULE_DAYS + 10) * 24 * 60 * 60 * 1000).toISOString();
+  const result = validateScheduledTime(farFutureDate);
+
+  assert.strictEqual(result.valid, false);
+  assert.ok(result.error.includes('cannot be more than'));
+});
+
+test('validateScheduledTime rejects invalid date format', () => {
+  const result = validateScheduledTime('not-a-date');
+
+  assert.strictEqual(result.valid, false);
+  assert.strictEqual(result.error, 'Invalid scheduled date format');
+});
+
+test('validateScheduledTipParams validates required fields', () => {
+  const result = validateScheduledTipParams({});
+
+  assert.strictEqual(result.valid, false);
+  assert.strictEqual(result.error, 'Sender address is required');
+});
+
+test('validateScheduledTipParams rejects sender equals recipient', () => {
+  const result = validateScheduledTipParams({
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP2J6Z...ABC',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000).toISOString(),
+  });
+
+  assert.strictEqual(result.valid, false);
+  assert.strictEqual(result.error, 'Cannot schedule a tip to yourself');
+});
+
+test('validateScheduledTipParams validates amount', () => {
+  const result = validateScheduledTipParams({
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: -100,
+    scheduledFor: new Date(Date.now() + 3600000).toISOString(),
+  });
+
+  assert.strictEqual(result.valid, false);
+  assert.ok(result.error.includes('positive number'));
+});
+
+test('validateScheduledTipParams validates minimum amount', () => {
+  const result = validateScheduledTipParams({
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 100,
+    scheduledFor: new Date(Date.now() + 3600000).toISOString(),
+  });
+
+  assert.strictEqual(result.valid, false);
+  assert.ok(result.error.includes('Minimum tip'));
+});
+
+test('validateScheduledTipParams validates message length', () => {
+  const longMessage = 'a'.repeat(281);
+  const result = validateScheduledTipParams({
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000).toISOString(),
+    message: longMessage,
+  });
+
+  assert.strictEqual(result.valid, false);
+  assert.ok(result.error.includes('280 characters'));
+});
+
+test('validateScheduledTipParams accepts valid params', () => {
+  const result = validateScheduledTipParams({
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + (MIN_SCHEDULE_MINUTES + 5) * 60 * 1000).toISOString(),
+    message: 'Test message',
+    category: 1,
+  });
+
+  assert.strictEqual(result.valid, true);
+});
diff --git a/chainhook/schema.sql b/chainhook/schema.sql
index cb43284b..713eda90 100644
--- a/chainhook/schema.sql
+++ b/chainhook/schema.sql
@@ -13,3 +13,26 @@ CREATE INDEX IF NOT EXISTS chainhook_events_tx_id_idx ON chainhook_events (tx_id
 CREATE INDEX IF NOT EXISTS chainhook_events_block_height_idx ON chainhook_events (block_height DESC);
 CREATE INDEX IF NOT EXISTS chainhook_events_contract_idx ON chainhook_events (contract);
 CREATE INDEX IF NOT EXISTS chainhook_events_ingested_at_idx ON chainhook_events (ingested_at DESC);
+
+CREATE TABLE IF NOT EXISTS scheduled_tips (
+  id TEXT PRIMARY KEY,
+  sender TEXT NOT NULL,
+  recipient TEXT NOT NULL,
+  amount BIGINT NOT NULL,
+  scheduled_for TIMESTAMPTZ NOT NULL,
+  message TEXT NOT NULL DEFAULT '',
+  category INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL DEFAULT 'pending',
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  executed_at TIMESTAMPTZ,
+  tx_id TEXT,
+  failure_reason TEXT,
+  notified_at TIMESTAMPTZ
+);
+
+CREATE INDEX IF NOT EXISTS scheduled_tips_sender_idx ON scheduled_tips (sender);
+CREATE INDEX IF NOT EXISTS scheduled_tips_recipient_idx ON scheduled_tips (recipient);
+CREATE INDEX IF NOT EXISTS scheduled_tips_status_idx ON scheduled_tips (status);
+CREATE INDEX IF NOT EXISTS scheduled_tips_scheduled_for_idx ON scheduled_tips (scheduled_for);
+CREATE INDEX IF NOT EXISTS scheduled_tips_pending_due_idx ON scheduled_tips (scheduled_for) WHERE status = 'pending';
diff --git a/chainhook/server.js b/chainhook/server.js
index b692535c..3315b910 100644
--- a/chainhook/server.js
+++ b/chainhook/server.js
@@ -9,9 +9,10 @@ import { parseAllowedOrigins, getCorsHeaders } from "./cors.js";
 import { RateLimiter, getClientIp, validateRateLimitConfig } from "./rate-limit.js";
 import { logger } from "./logging.js";
 import { setupGracefulShutdown, isShuttingDown } from "./graceful-shutdown.js";
-import { createEventStore, getRetentionCutoff, parseRetentionDays } from "./storage.js";
+import { createEventStore, createScheduledTipStore, getRetentionCutoff, parseRetentionDays } from "./storage.js";
 import { normalizeClarityEventFields } from "../shared/clarityValues.js";
 import { BadRequestError, PayloadTooLargeError, RateLimitError, UnauthorizedError, ServiceUnavailableError, classifyError, toErrorResponse } from "./errors.js";
+import { ScheduledTip, validateScheduledTipParams, SCHEDULED_TIP_STATUSES } from "./scheduler.js";
 
 const PORT = process.env.PORT || 3100;
 const AUTH_TOKEN = process.env.CHAINHOOK_AUTH_TOKEN || "";
@@ -26,6 +27,7 @@ const RATE_LIMIT_MAX_REQUESTS = parseInt(process.env.RATE_LIMIT_MAX_REQUESTS ||
 const RATE_LIMIT_WINDOW_MS = parseInt(process.env.RATE_LIMIT_WINDOW_MS || "60000", 10);
 const rateLimiter = new RateLimiter(RATE_LIMIT_MAX_REQUESTS, RATE_LIMIT_WINDOW_MS);
 let eventStore = null;
+let scheduledTipStore = null;
 
 /**
  * Get the rate limiter instance for runtime configuration.
@@ -52,6 +54,20 @@ async function getEventStore() {
   return eventStore;
 }
 
+async function getScheduledTipStore() {
+  if (!scheduledTipStore) {
+    if (STORAGE_MODE === "postgres" && !DATABASE_URL) {
+      throw new Error("DATABASE_URL is required when CHAINHOOK_STORAGE=postgres");
+    }
+    scheduledTipStore = await createScheduledTipStore({
+      mode: STORAGE_MODE,
+      databaseUrl: DATABASE_URL,
+    });
+    await scheduledTipStore.init();
+  }
+  return scheduledTipStore;
+}
+
 /**
  * Read and parse a JSON request body from a readable stream.
  * Rejects if the body exceeds MAX_BODY_SIZE or contains invalid JSON.
@@ -483,6 +499,136 @@ const server = http.createServer(async (req, res) => {
     });
   }
 
+  // POST /api/scheduled-tips -- create a scheduled tip
+  if (req.method === "POST" && path === "/api/scheduled-tips") {
+    const startTime = Date.now();
+
+    try {
+      const body = await parseBody(req);
+      const validation = validateScheduledTipParams(body);
+
+      if (!validation.valid) {
+        return sendError(res, new BadRequestError(validation.error), requestId, { path });
+      }
+
+      const scheduledTip = new ScheduledTip({
+        sender: body.sender,
+        recipient: body.recipient,
+        amount: body.amount,
+        scheduledFor: body.scheduledFor,
+        message: body.message || '',
+        category: body.category ?? 0,
+      });
+
+      const store = await getScheduledTipStore();
+      const result = await store.insertScheduledTip(scheduledTip);
+
+      if (!result.inserted) {
+        return sendError(res, new BadRequestError('Scheduled tip with this ID already exists'), requestId, { path });
+      }
+
+      const processingMs = Date.now() - startTime;
+      logger.info('Scheduled tip created', {
+        id: scheduledTip.id,
+        sender: scheduledTip.sender,
+        recipient: scheduledTip.recipient,
+        scheduled_for: scheduledTip.scheduledFor.toISOString(),
+        request_id: requestId,
+        processing_ms: processingMs,
+      });
+
+      metrics.recordRequest(true);
+      return sendJson(res, 201, { ok: true, scheduledTip: result.tip });
+    } catch (err) {
+      const processingMs = Date.now() - startTime;
+      metrics.recordRequest(false);
+      return sendError(res, err, requestId, { path, processing_ms: processingMs });
+    }
+  }
+
+  // GET /api/scheduled-tips -- list scheduled tips with filters
+  if (req.method === "GET" && path === "/api/scheduled-tips") {
+    try {
+      const sender = url.searchParams.get("sender");
+      const recipient = url.searchParams.get("recipient");
+      const status = url.searchParams.get("status");
+      const limit = sanitizeQueryInt(url.searchParams.get("limit") || "50", 1, 100);
+      const offset = sanitizeQueryInt(url.searchParams.get("offset") || "0", 0, Number.MAX_SAFE_INTEGER);
+
+      if (isNaN(limit)) {
+        return sendError(res, new BadRequestError("limit must be between 1 and 100"), requestId, { path });
+      }
+      if (isNaN(offset)) {
+        return sendError(res, new BadRequestError("offset must be a non-negative integer"), requestId, { path });
+      }
+
+      const store = await getScheduledTipStore();
+      const result = await store.listScheduledTips({ sender, recipient, status, limit, offset });
+
+      return sendJson(res, 200, { scheduledTips: result.tips, total: result.total });
+    } catch (err) {
+      return sendError(res, err, requestId, { path });
+    }
+  }
+
+  // GET /api/scheduled-tips/:id -- get a single scheduled tip
+  if (req.method === "GET" && path.match(/^\/api\/scheduled-tips\/[a-f0-9-]+$/)) {
+    try {
+      const id = path.split("/api/scheduled-tips/")[1];
+      const store = await getScheduledTipStore();
+      const tip = await store.getScheduledTip(id);
+
+      if (!tip) {
+        return sendJson(res, 404, { error: "scheduled tip not found" });
+      }
+
+      return sendJson(res, 200, tip);
+    } catch (err) {
+      return sendError(res, err, requestId, { path });
+    }
+  }
+
+  // DELETE /api/scheduled-tips/:id -- cancel a scheduled tip
+  if (req.method === "DELETE" && path.match(/^\/api\/scheduled-tips\/[a-f0-9-]+$/)) {
+    const startTime = Date.now();
+
+    try {
+      const id = path.split("/api/scheduled-tips/")[1];
+      const body = await parseBody(req);
+
+      if (!body.sender || typeof body.sender !== 'string') {
+        return sendError(res, new BadRequestError('sender address is required'), requestId, { path });
+      }
+
+      const store = await getScheduledTipStore();
+      const result = await store.cancelScheduledTip(id, body.sender);
+
+      if (!result.cancelled) {
+        if (result.reason === 'not_found') {
+          return sendJson(res, 404, { error: "scheduled tip not found or you are not the sender" });
+        }
+        if (result.reason === 'not_pending') {
+          return sendError(res, new BadRequestError('can only cancel pending scheduled tips'), requestId, { path });
+        }
+      }
+
+      const processingMs = Date.now() - startTime;
+      logger.info('Scheduled tip cancelled', {
+        id,
+        sender: body.sender,
+        request_id: requestId,
+        processing_ms: processingMs,
+      });
+
+      metrics.recordRequest(true);
+      return sendJson(res, 200, { ok: true, scheduledTip: result.tip });
+    } catch (err) {
+      const processingMs = Date.now() - startTime;
+      metrics.recordRequest(false);
+      return sendError(res, err, requestId, { path, processing_ms: processingMs });
+    }
+  }
+
   // GET /api/admin/events -- admin event log
   if (req.method === "GET" && path === "/api/admin/events") {
     const store = await getEventStore();
diff --git a/chainhook/storage-scheduled.test.js b/chainhook/storage-scheduled.test.js
new file mode 100644
index 00000000..02e1f35a
--- /dev/null
+++ b/chainhook/storage-scheduled.test.js
@@ -0,0 +1,282 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { MemoryScheduledTipStore } from './storage.js';
+
+test('MemoryScheduledTipStore inserts scheduled tip', async () => {
+  const store = new MemoryScheduledTipStore();
+  await store.init();
+
+  const tip = {
+    id: 'test-id-1',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000),
+    message: 'Test tip',
+    category: 1,
+    status: 'pending',
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+
+  const result = await store.insertScheduledTip(tip);
+
+  assert.strictEqual(result.inserted, true);
+  assert.strictEqual(result.tip.id, 'test-id-1');
+});
+
+test('MemoryScheduledTipStore prevents duplicate inserts', async () => {
+  const store = new MemoryScheduledTipStore();
+  await store.init();
+
+  const tip = {
+    id: 'test-id-1',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000),
+    status: 'pending',
+  };
+
+  await store.insertScheduledTip(tip);
+  const result = await store.insertScheduledTip(tip);
+
+  assert.strictEqual(result.inserted, false);
+});
+
+test('MemoryScheduledTipStore gets scheduled tip by id', async () => {
+  const store = new MemoryScheduledTipStore();
+  await store.init();
+
+  const tip = {
+    id: 'test-id-1',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000),
+    status: 'pending',
+  };
+
+  await store.insertScheduledTip(tip);
+  const retrieved = await store.getScheduledTip('test-id-1');
+
+  assert.strictEqual(retrieved.id, 'test-id-1');
+  assert.strictEqual(retrieved.sender, 'SP2J6Z...ABC');
+});
+
+test('MemoryScheduledTipStore returns null for non-existent tip', async () => {
+  const store = new MemoryScheduledTipStore();
+  await store.init();
+
+  const retrieved = await store.getScheduledTip('non-existent');
+
+  assert.strictEqual(retrieved, null);
+});
+
+test('MemoryScheduledTipStore lists scheduled tips with filters', async () => {
+  const store = new MemoryScheduledTipStore();
+  await store.init();
+
+  await store.insertScheduledTip({
+    id: 'tip-1',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000),
+    status: 'pending',
+  });
+
+  await store.insertScheduledTip({
+    id: 'tip-2',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP4L7...DEF',
+    amount: 2000000,
+    scheduledFor: new Date(Date.now() + 7200000),
+    status: 'executed',
+  });
+
+  const allTips = await store.listScheduledTips({});
+  assert.strictEqual(allTips.tips.length, 2);
+  assert.strictEqual(allTips.total, 2);
+
+  const pendingTips = await store.listScheduledTips({ status: 'pending' });
+  assert.strictEqual(pendingTips.tips.length, 1);
+  assert.strictEqual(pendingTips.tips[0].id, 'tip-1');
+
+  const senderTips = await store.listScheduledTips({ sender: 'SP2J6Z...ABC' });
+  assert.strictEqual(senderTips.tips.length, 2);
+});
+
+test('MemoryScheduledTipStore updates scheduled tip', async () => {
+  const store = new MemoryScheduledTipStore();
+  await store.init();
+
+  await store.insertScheduledTip({
+    id: 'tip-1',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000),
+    status: 'pending',
+  });
+
+  const result = await store.updateScheduledTip('tip-1', {
+    status: 'executed',
+    txId: '0xabc123',
+    executedAt: new Date(),
+  });
+
+  assert.strictEqual(result.updated, true);
+  assert.strictEqual(result.tip.status, 'executed');
+  assert.strictEqual(result.tip.txId, '0xabc123');
+});
+
+test('MemoryScheduledTipStore cancels scheduled tip', async () => {
+  const store = new MemoryScheduledTipStore();
+  await store.init();
+
+  await store.insertScheduledTip({
+    id: 'tip-1',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000),
+    status: 'pending',
+  });
+
+  const result = await store.cancelScheduledTip('tip-1', 'SP2J6Z...ABC');
+
+  assert.strictEqual(result.cancelled, true);
+  assert.strictEqual(result.tip.status, 'cancelled');
+});
+
+test('MemoryScheduledTipStore prevents cancelling non-pending tip', async () => {
+  const store = new MemoryScheduledTipStore();
+  await store.init();
+
+  await store.insertScheduledTip({
+    id: 'tip-1',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000),
+    status: 'executed',
+  });
+
+  const result = await store.cancelScheduledTip('tip-1', 'SP2J6Z...ABC');
+
+  assert.strictEqual(result.cancelled, false);
+  assert.strictEqual(result.reason, 'not_pending');
+});
+
+test('MemoryScheduledTipStore prevents cancelling by wrong sender', async () => {
+  const store = new MemoryScheduledTipStore();
+  await store.init();
+
+  await store.insertScheduledTip({
+    id: 'tip-1',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000),
+    status: 'pending',
+  });
+
+  const result = await store.cancelScheduledTip('tip-1', 'SP4L7...DEF');
+
+  assert.strictEqual(result.cancelled, false);
+  assert.strictEqual(result.reason, 'not_found');
+});
+
+test('MemoryScheduledTipStore gets pending scheduled tips', async () => {
+  const store = new MemoryScheduledTipStore();
+  await store.init();
+
+  await store.insertScheduledTip({
+    id: 'tip-1',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() - 1000),
+    status: 'pending',
+  });
+
+  await store.insertScheduledTip({
+    id: 'tip-2',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP4L7...DEF',
+    amount: 2000000,
+    scheduledFor: new Date(Date.now() + 3600000),
+    status: 'pending',
+  });
+
+  const pendingTips = await store.getPendingScheduledTips();
+
+  assert.strictEqual(pendingTips.length, 1);
+  assert.strictEqual(pendingTips[0].id, 'tip-1');
+});
+
+test('MemoryScheduledTipStore gets notifiable scheduled tips', async () => {
+  const store = new MemoryScheduledTipStore();
+  await store.init();
+
+  const now = Date.now();
+  const notificationTime = now + 30 * 60 * 1000;
+
+  await store.insertScheduledTip({
+    id: 'tip-1',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(notificationTime),
+    status: 'pending',
+    notifiedAt: null,
+  });
+
+  await store.insertScheduledTip({
+    id: 'tip-2',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP4L7...DEF',
+    amount: 2000000,
+    scheduledFor: new Date(now + 120 * 60 * 1000),
+    status: 'pending',
+    notifiedAt: null,
+  });
+
+  const notifiableTips = await store.getNotifiableScheduledTips(60);
+
+  assert.strictEqual(notifiableTips.length, 1);
+  assert.strictEqual(notifiableTips[0].id, 'tip-1');
+});
+
+test('MemoryScheduledTipStore counts scheduled tips', async () => {
+  const store = new MemoryScheduledTipStore();
+  await store.init();
+
+  await store.insertScheduledTip({
+    id: 'tip-1',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP3K5...XYZ',
+    amount: 1000000,
+    scheduledFor: new Date(Date.now() + 3600000),
+    status: 'pending',
+  });
+
+  await store.insertScheduledTip({
+    id: 'tip-2',
+    sender: 'SP2J6Z...ABC',
+    recipient: 'SP4L7...DEF',
+    amount: 2000000,
+    scheduledFor: new Date(Date.now() + 7200000),
+    status: 'executed',
+  });
+
+  const totalCount = await store.countScheduledTips();
+  assert.strictEqual(totalCount, 2);
+
+  const pendingCount = await store.countScheduledTips('pending');
+  assert.strictEqual(pendingCount, 1);
+
+  const executedCount = await store.countScheduledTips('executed');
+  assert.strictEqual(executedCount, 1);
+});
diff --git a/chainhook/storage.js b/chainhook/storage.js
index 187d2a52..44a05d6a 100644
--- a/chainhook/storage.js
+++ b/chainhook/storage.js
@@ -349,3 +349,359 @@ export async function createEventStore(options = {}) {
 
 export { MemoryEventStore, PostgresEventStore };
 export { DEFAULT_POOL_MAX, DEFAULT_POOL_IDLE_TIMEOUT_MS, DEFAULT_POOL_CONNECTION_TIMEOUT_MS, DEFAULT_STATEMENT_TIMEOUT_MS };
+
+class MemoryScheduledTipStore {
+  constructor() {
+    this.tips = [];
+  }
+
+  async init() {
+    return this;
+  }
+
+  async insertScheduledTip(tip) {
+    const existing = this.tips.find(t => t.id === tip.id);
+    if (existing) {
+      return { inserted: false, tip: existing };
+    }
+    this.tips.push(tip);
+    return { inserted: true, tip };
+  }
+
+  async getScheduledTip(id) {
+    return this.tips.find(t => t.id === id) || null;
+  }
+
+  async listScheduledTips(filters = {}) {
+    let results = [...this.tips];
+
+    if (filters.sender) {
+      results = results.filter(t => t.sender === filters.sender);
+    }
+    if (filters.recipient) {
+      results = results.filter(t => t.recipient === filters.recipient);
+    }
+    if (filters.status) {
+      results = results.filter(t => t.status === filters.status);
+    }
+
+    results.sort((a, b) => new Date(b.scheduledFor) - new Date(a.scheduledFor));
+
+    const offset = filters.offset || 0;
+    const limit = filters.limit || 50;
+    const total = results.length;
+    results = results.slice(offset, offset + limit);
+
+    return { tips: results, total };
+  }
+
+  async updateScheduledTip(id, updates) {
+    const index = this.tips.findIndex(t => t.id === id);
+    if (index === -1) {
+      return { updated: false, tip: null };
+    }
+    this.tips[index] = { ...this.tips[index], ...updates, updatedAt: new Date() };
+    return { updated: true, tip: this.tips[index] };
+  }
+
+  async cancelScheduledTip(id, sender) {
+    const tip = this.tips.find(t => t.id === id && t.sender === sender);
+    if (!tip) {
+      return { cancelled: false, reason: 'not_found' };
+    }
+    if (tip.status !== 'pending') {
+      return { cancelled: false, reason: 'not_pending' };
+    }
+    tip.status = 'cancelled';
+    tip.updatedAt = new Date();
+    return { cancelled: true, tip };
+  }
+
+  async getPendingScheduledTips() {
+    const now = new Date();
+    return this.tips.filter(t => t.status === 'pending' && new Date(t.scheduledFor) <= now);
+  }
+
+  async getNotifiableScheduledTips(leadMinutes = 60) {
+    const now = new Date();
+    return this.tips.filter(t => {
+      if (t.status !== 'pending' || t.notifiedAt) return false;
+      const notificationTime = new Date(new Date(t.scheduledFor).getTime() - leadMinutes * 60 * 1000);
+      return now >= notificationTime;
+    });
+  }
+
+  async countScheduledTips(status = null) {
+    if (status) {
+      return this.tips.filter(t => t.status === status).length;
+    }
+    return this.tips.length;
+  }
+
+  async close() {}
+}
+
+class PostgresScheduledTipStore {
+  constructor(pool, poolConfig = {}) {
+    this.pool = pool;
+    this.poolConfig = poolConfig;
+    this.ready = null;
+  }
+
+  async init() {
+    if (!this.ready) {
+      this.ready = this.#initialize();
+    }
+    return this.ready;
+  }
+
+  async #initialize() {
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS scheduled_tips (
+        id TEXT PRIMARY KEY,
+        sender TEXT NOT NULL,
+        recipient TEXT NOT NULL,
+        amount BIGINT NOT NULL,
+        scheduled_for TIMESTAMPTZ NOT NULL,
+        message TEXT NOT NULL DEFAULT '',
+        category INTEGER NOT NULL DEFAULT 0,
+        status TEXT NOT NULL DEFAULT 'pending',
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        executed_at TIMESTAMPTZ,
+        tx_id TEXT,
+        failure_reason TEXT,
+        notified_at TIMESTAMPTZ
+      );
+    `);
+
+    await this.pool.query('CREATE INDEX IF NOT EXISTS scheduled_tips_sender_idx ON scheduled_tips (sender);');
+    await this.pool.query('CREATE INDEX IF NOT EXISTS scheduled_tips_recipient_idx ON scheduled_tips (recipient);');
+    await this.pool.query('CREATE INDEX IF NOT EXISTS scheduled_tips_status_idx ON scheduled_tips (status);');
+    await this.pool.query('CREATE INDEX IF NOT EXISTS scheduled_tips_scheduled_for_idx ON scheduled_tips (scheduled_for);');
+    await this.pool.query('CREATE INDEX IF NOT EXISTS scheduled_tips_pending_due_idx ON scheduled_tips (scheduled_for) WHERE status = \'pending\';');
+  }
+
+  async insertScheduledTip(tip) {
+    await this.init();
+
+    const result = await this.pool.query(
+      `INSERT INTO scheduled_tips (id, sender, recipient, amount, scheduled_for, message, category, status, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+       ON CONFLICT (id) DO NOTHING
+       RETURNING *`,
+      [
+        tip.id,
+        tip.sender,
+        tip.recipient,
+        tip.amount,
+        tip.scheduledFor,
+        tip.message || '',
+        tip.category || 0,
+        tip.status || 'pending',
+        tip.createdAt || new Date(),
+        tip.updatedAt || new Date(),
+      ]
+    );
+
+    if (result.rowCount === 0) {
+      const existing = await this.getScheduledTip(tip.id);
+      return { inserted: false, tip: existing };
+    }
+
+    return { inserted: true, tip: this.#rowToTip(result.rows[0]) };
+  }
+
+  async getScheduledTip(id) {
+    await this.init();
+    const result = await this.pool.query('SELECT * FROM scheduled_tips WHERE id = $1', [id]);
+    return result.rows[0] ? this.#rowToTip(result.rows[0]) : null;
+  }
+
+  async listScheduledTips(filters = {}) {
+    await this.init();
+
+    let query = 'SELECT * FROM scheduled_tips WHERE 1=1';
+    const values = [];
+    let paramIndex = 1;
+
+    if (filters.sender) {
+      query += ` AND sender = $${paramIndex++}`;
+      values.push(filters.sender);
+    }
+    if (filters.recipient) {
+      query += ` AND recipient = $${paramIndex++}`;
+      values.push(filters.recipient);
+    }
+    if (filters.status) {
+      query += ` AND status = $${paramIndex++}`;
+      values.push(filters.status);
+    }
+
+    query += ' ORDER BY scheduled_for DESC';
+
+    const offset = filters.offset || 0;
+    const limit = filters.limit || 50;
+    query += ` LIMIT $${paramIndex++} OFFSET $${paramIndex}`;
+    values.push(limit, offset);
+
+    const result = await this.pool.query(query, values);
+
+    const countResult = await this.pool.query(
+      'SELECT COUNT(*)::int AS count FROM scheduled_tips WHERE 1=1' +
+      (filters.sender ? ' AND sender = $1' : '') +
+      (filters.recipient ? ` AND recipient = $${filters.sender ? 2 : 1}` : '') +
+      (filters.status ? ` AND status = $${(filters.sender ? 1 : 0) + (filters.recipient ? 1 : 0) + 1}` : ''),
+      values.slice(0, -2)
+    );
+
+    return {
+      tips: result.rows.map(r => this.#rowToTip(r)),
+      total: countResult.rows[0]?.count || 0,
+    };
+  }
+
+  async updateScheduledTip(id, updates) {
+    await this.init();
+
+    const setClauses = [];
+    const values = [];
+    let paramIndex = 1;
+
+    if (updates.status !== undefined) {
+      setClauses.push(`status = $${paramIndex++}`);
+      values.push(updates.status);
+    }
+    if (updates.executedAt !== undefined) {
+      setClauses.push(`executed_at = $${paramIndex++}`);
+      values.push(updates.executedAt);
+    }
+    if (updates.txId !== undefined) {
+      setClauses.push(`tx_id = $${paramIndex++}`);
+      values.push(updates.txId);
+    }
+    if (updates.failureReason !== undefined) {
+      setClauses.push(`failure_reason = $${paramIndex++}`);
+      values.push(updates.failureReason);
+    }
+    if (updates.notifiedAt !== undefined) {
+      setClauses.push(`notified_at = $${paramIndex++}`);
+      values.push(updates.notifiedAt);
+    }
+
+    setClauses.push(`updated_at = $${paramIndex++}`);
+    values.push(new Date());
+
+    values.push(id);
+
+    const result = await this.pool.query(
+      `UPDATE scheduled_tips SET ${setClauses.join(', ')} WHERE id = $${paramIndex} RETURNING *`,
+      values
+    );
+
+    if (result.rowCount === 0) {
+      return { updated: false, tip: null };
+    }
+
+    return { updated: true, tip: this.#rowToTip(result.rows[0]) };
+  }
+
+  async cancelScheduledTip(id, sender) {
+    await this.init();
+
+    const result = await this.pool.query(
+      `UPDATE scheduled_tips SET status = 'cancelled', updated_at = NOW()
+       WHERE id = $1 AND sender = $2 AND status = 'pending'
+       RETURNING *`,
+      [id, sender]
+    );
+
+    if (result.rowCount === 0) {
+      const tip = await this.getScheduledTip(id);
+      if (!tip || tip.sender !== sender) {
+        return { cancelled: false, reason: 'not_found' };
+      }
+      return { cancelled: false, reason: 'not_pending' };
+    }
+
+    return { cancelled: true, tip: this.#rowToTip(result.rows[0]) };
+  }
+
+  async getPendingScheduledTips() {
+    await this.init();
+    const result = await this.pool.query(
+      "SELECT * FROM scheduled_tips WHERE status = 'pending' AND scheduled_for <= NOW() ORDER BY scheduled_for ASC"
+    );
+    return result.rows.map(r => this.#rowToTip(r));
+  }
+
+  async getNotifiableScheduledTips(leadMinutes = 60) {
+    await this.init();
+    const result = await this.pool.query(
+      `SELECT * FROM scheduled_tips
+       WHERE status = 'pending'
+         AND notified_at IS NULL
+         AND scheduled_for <= NOW() + INTERVAL '1 minute' * $1
+         AND scheduled_for > NOW()
+       ORDER BY scheduled_for ASC`,
+      [leadMinutes]
+    );
+    return result.rows.map(r => this.#rowToTip(r));
+  }
+
+  async countScheduledTips(status = null) {
+    await this.init();
+    if (status) {
+      const result = await this.pool.query('SELECT COUNT(*)::int AS count FROM scheduled_tips WHERE status = $1', [status]);
+      return result.rows[0]?.count || 0;
+    }
+    const result = await this.pool.query('SELECT COUNT(*)::int AS count FROM scheduled_tips');
+    return result.rows[0]?.count || 0;
+  }
+
+  async close() {}
+
+  #rowToTip(row) {
+    return {
+      id: row.id,
+      sender: row.sender,
+      recipient: row.recipient,
+      amount: Number(row.amount),
+      scheduledFor: row.scheduled_for,
+      message: row.message || '',
+      category: row.category || 0,
+      status: row.status,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      executedAt: row.executed_at,
+      txId: row.tx_id,
+      failureReason: row.failure_reason,
+      notifiedAt: row.notified_at,
+    };
+  }
+}
+
+export async function createScheduledTipStore(options = {}) {
+  const mode = options.mode || process.env.CHAINHOOK_STORAGE || (process.env.NODE_ENV === 'test' ? 'memory' : 'postgres');
+
+  if (mode === 'memory') {
+    return new MemoryScheduledTipStore();
+  }
+
+  const databaseUrl = options.databaseUrl || process.env.DATABASE_URL;
+  const ssl = options.ssl ?? process.env.DATABASE_SSL === 'true';
+  const poolConfig = options.poolConfig || parsePoolConfig(process.env);
+
+  const pool = new Pool({
+    connectionString: databaseUrl,
+    ssl: ssl ? { rejectUnauthorized: false } : undefined,
+    max: poolConfig.max,
+    idleTimeoutMillis: poolConfig.idleTimeoutMillis,
+    connectionTimeoutMillis: poolConfig.connectionTimeoutMillis,
+    statement_timeout: poolConfig.statement_timeout,
+  });
+
+  return new PostgresScheduledTipStore(pool, poolConfig);
+}
+
+export { MemoryScheduledTipStore, PostgresScheduledTipStore };
diff --git a/docs/SCHEDULED_TIPS.md b/docs/SCHEDULED_TIPS.md
new file mode 100644
index 00000000..53d57ae9
--- /dev/null
+++ b/docs/SCHEDULED_TIPS.md
@@ -0,0 +1,288 @@
+# Scheduled Tips
+
+The scheduled tips feature allows users to schedule tips to be sent at a future date and time. This is useful for recurring payments, delayed rewards, or planning ahead.
+
+## Features
+
+- Schedule tips up to 365 days in advance
+- Minimum scheduling window of 5 minutes
+- View and manage all scheduled tips
+- Cancel pending scheduled tips
+- Automatic execution when scheduled time arrives
+- Optional notification before execution
+- Full transaction history tracking
+
+## User Interface
+
+### Schedule a Tip
+
+Navigate to the "Schedule" tab to create a new scheduled tip:
+
+1. Enter the recipient's Stacks address
+2. Specify the tip amount in STX
+3. Select the date and time for execution
+4. Add an optional message (up to 280 characters)
+5. Choose a category
+6. Review the fee breakdown
+7. Confirm the scheduled tip
+
+### View Scheduled Tips
+
+Navigate to the "Scheduled" tab to view all your scheduled tips:
+
+- Filter by status: All, Pending, Executed, Cancelled, Failed
+- View scheduled date and time
+- See recipient and amount details
+- Cancel pending tips
+- View transaction IDs for executed tips
+
+## API Endpoints
+
+### Create Scheduled Tip
+
+```http
+POST /api/scheduled-tips
+Content-Type: application/json
+
+{
+  "sender": "SP2J6Z...",
+  "recipient": "SP3K5...",
+  "amount": 1000000,
+  "scheduledFor": "2026-05-20T14:30:00.000Z",
+  "message": "Monthly tip",
+  "category": 1
+}
+```
+
+**Response:**
+```json
+{
+  "ok": true,
+  "scheduledTip": {
+    "id": "uuid",
+    "sender": "SP2J6Z...",
+    "recipient": "SP3K5...",
+    "amount": 1000000,
+    "scheduledFor": "2026-05-20T14:30:00.000Z",
+    "message": "Monthly tip",
+    "category": 1,
+    "status": "pending",
+    "createdAt": "2026-05-14T10:00:00.000Z",
+    "updatedAt": "2026-05-14T10:00:00.000Z"
+  }
+}
+```
+
+### List Scheduled Tips
+
+```http
+GET /api/scheduled-tips?sender=SP2J6Z...&status=pending&limit=50&offset=0
+```
+
+**Query Parameters:**
+- `sender` (optional): Filter by sender address
+- `recipient` (optional): Filter by recipient address
+- `status` (optional): Filter by status (pending, processing, executed, cancelled, failed)
+- `limit` (optional): Number of results per page (1-100, default: 50)
+- `offset` (optional): Pagination offset (default: 0)
+
+**Response:**
+```json
+{
+  "scheduledTips": [...],
+  "total": 10
+}
+```
+
+### Get Scheduled Tip
+
+```http
+GET /api/scheduled-tips/:id
+```
+
+**Response:**
+```json
+{
+  "id": "uuid",
+  "sender": "SP2J6Z...",
+  "recipient": "SP3K5...",
+  "amount": 1000000,
+  "scheduledFor": "2026-05-20T14:30:00.000Z",
+  "status": "pending",
+  ...
+}
+```
+
+### Cancel Scheduled Tip
+
+```http
+DELETE /api/scheduled-tips/:id
+Content-Type: application/json
+
+{
+  "sender": "SP2J6Z..."
+}
+```
+
+**Response:**
+```json
+{
+  "ok": true,
+  "scheduledTip": {
+    "id": "uuid",
+    "status": "cancelled",
+    ...
+  }
+}
+```
+
+## Job Processor
+
+The job processor runs in the background to execute scheduled tips and send notifications.
+
+### Configuration
+
+Environment variables:
+- `PROCESSING_INTERVAL_MS`: How often to check for pending tips (default: 60000ms)
+- `NOTIFICATION_LEAD_MINUTES`: How many minutes before execution to send notification (default: 60)
+
+### Execution Flow
+
+1. Job processor checks for pending tips every minute
+2. Tips with scheduled time in the past are marked as "processing"
+3. Execution handler is called (must be provided by implementation)
+4. On success, tip is marked as "executed" with transaction ID
+5. On failure, tip is marked as "failed" with failure reason
+
+### Notifications
+
+Tips can trigger notifications before execution:
+- Default: 60 minutes before scheduled time
+- Only sent once per tip
+- Notification handler must be provided by implementation
+
+## Database Schema
+
+### scheduled_tips Table
+
+```sql
+CREATE TABLE scheduled_tips (
+  id TEXT PRIMARY KEY,
+  sender TEXT NOT NULL,
+  recipient TEXT NOT NULL,
+  amount BIGINT NOT NULL,
+  scheduled_for TIMESTAMPTZ NOT NULL,
+  message TEXT NOT NULL DEFAULT '',
+  category INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL DEFAULT 'pending',
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  executed_at TIMESTAMPTZ,
+  tx_id TEXT,
+  failure_reason TEXT,
+  notified_at TIMESTAMPTZ
+);
+```
+
+### Indexes
+
+- `scheduled_tips_sender_idx`: Fast lookup by sender
+- `scheduled_tips_recipient_idx`: Fast lookup by recipient
+- `scheduled_tips_status_idx`: Fast filtering by status
+- `scheduled_tips_scheduled_for_idx`: Fast sorting by scheduled time
+- `scheduled_tips_pending_due_idx`: Optimized for job processor queries
+
+## Status Flow
+
+```
+pending → processing → executed
+                    ↘ failed
+
+pending → cancelled
+```
+
+- **pending**: Scheduled tip waiting for execution time
+- **processing**: Currently being executed
+- **executed**: Successfully executed with transaction ID
+- **failed**: Execution failed with reason
+- **cancelled**: Cancelled by sender before execution
+
+## Validation Rules
+
+### Amount
+- Minimum: 1,000 microSTX (0.001 STX)
+- Maximum: 10,000,000,000,000 microSTX (10,000 STX)
+
+### Scheduled Time
+- Minimum: 5 minutes in the future
+- Maximum: 365 days in the future
+
+### Message
+- Maximum length: 280 characters
+- Optional field
+
+### Category
+- Must be a non-negative integer
+- Default: 0 (General)
+
+### Sender/Recipient
+- Must be valid Stacks addresses
+- Cannot be the same address
+
+## Analytics
+
+The following metrics are tracked:
+- `scheduledTipsCreated`: Number of scheduled tips created
+- `scheduledTipsCancelled`: Number of scheduled tips cancelled
+- `scheduledTipsExecuted`: Number of scheduled tips executed successfully
+- `scheduledTipsFailed`: Number of scheduled tips that failed execution
+
+## Error Handling
+
+### Common Errors
+
+**Invalid scheduled time:**
+```json
+{
+  "error": "bad_request",
+  "message": "Scheduled time must be at least 5 minutes in the future"
+}
+```
+
+**Insufficient balance:**
+Checked at execution time, not at scheduling time. If balance is insufficient when execution time arrives, the tip will be marked as failed.
+
+**Cancelled tip:**
+```json
+{
+  "error": "bad_request",
+  "message": "can only cancel pending scheduled tips"
+}
+```
+
+**Not found:**
+```json
+{
+  "error": "scheduled tip not found or you are not the sender"
+}
+```
+
+## Testing
+
+Run tests:
+```bash
+cd chainhook
+npm test scheduler.test.js
+npm test storage-scheduled.test.js
+```
+
+## Future Enhancements
+
+Potential improvements for future versions:
+- Recurring scheduled tips (daily, weekly, monthly)
+- Batch scheduled tips
+- Email/SMS notifications
+- Scheduled tip templates
+- Balance verification at scheduling time
+- Automatic retry on failure
+- Scheduled tip marketplace
diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx
index e75e7701..7ff40aa2 100644
--- a/frontend/src/App.jsx
+++ b/frontend/src/App.jsx
@@ -18,17 +18,19 @@ import { usePageTitle } from './hooks/usePageTitle';
 import { useSessionSync } from './hooks/useSessionSync';
 import { useDemoMode } from './context/DemoContext';
 import {
-  ROUTE_SEND, ROUTE_BATCH, ROUTE_TOKEN_TIP, ROUTE_FEED,
+  ROUTE_SEND, ROUTE_BATCH, ROUTE_TOKEN_TIP, ROUTE_SCHEDULE, ROUTE_SCHEDULED_TIPS, ROUTE_FEED,
   ROUTE_LEADERBOARD, ROUTE_ACTIVITY, ROUTE_PROFILE,
   ROUTE_BLOCK, ROUTE_STATS, ROUTE_ADMIN, ROUTE_TELEMETRY,
   DEFAULT_AUTHENTICATED_ROUTE, ROUTE_META,
 } from './config/routes';
-import { Zap, Radio, Trophy, User, BarChart3, Users, ShieldBan, Coins, UserCircle, Shield, Gauge } from 'lucide-react';
+import { Zap, Radio, Trophy, User, BarChart3, Users, ShieldBan, Coins, UserCircle, Shield, Gauge, Calendar, Clock } from 'lucide-react';
 import { activateDemo, deactivateDemo } from './lib/demo-utils';
 
 const AnimatedHero = lazy(() => import('./components/ui/animated-hero').then(m => ({ default: m.AnimatedHero })));
 const MaintenancePage = lazy(() => import('./components/MaintenancePage'));
 const SendTip = lazy(() => import('./components/SendTip'));
+const ScheduleTip = lazy(() => import('./components/ScheduleTip'));
+const ScheduledTipsList = lazy(() => import('./components/ScheduledTipsList'));
 const TipHistory = lazy(() => import('./components/TipHistory'));
 const PlatformStats = lazy(() => import('./components/PlatformStats'));
 const RecentTips = lazy(() => import('./components/RecentTips'));
@@ -157,6 +159,8 @@ function App() {
       { path: ROUTE_SEND, label: 'Send Tip', icon: Zap },
       { path: ROUTE_BATCH, label: 'Batch', icon: Users },
       { path: ROUTE_TOKEN_TIP, label: 'Token Tip', icon: Coins },
+      { path: ROUTE_SCHEDULE, label: 'Schedule', icon: Calendar },
+      { path: ROUTE_SCHEDULED_TIPS, label: 'Scheduled', icon: Clock },
       { path: ROUTE_FEED, label: 'Live Feed', icon: Radio },
       { path: ROUTE_LEADERBOARD, label: 'Leaderboard', icon: Trophy },
       { path: ROUTE_ACTIVITY, label: 'My Activity', icon: User },
@@ -297,6 +301,30 @@ function App() {
                       )
                     } 
                   />
+                  <Route 
+                    path={ROUTE_SCHEDULE} 
+                    element={
+                      userData || demoEnabled ? (
+                        <ScheduleTip addToast={addToast} />
+                      ) : (
+                        <RequireAuth onAuth={handleAuth} authLoading={authLoading} route={ROUTE_SCHEDULE}>
+                          <ScheduleTip addToast={addToast} />
+                        </RequireAuth>
+                      )
+                    } 
+                  />
+                  <Route 
+                    path={ROUTE_SCHEDULED_TIPS} 
+                    element={
+                      userData || demoEnabled ? (
+                        <ScheduledTipsList addToast={addToast} />
+                      ) : (
+                        <RequireAuth onAuth={handleAuth} authLoading={authLoading} route={ROUTE_SCHEDULED_TIPS}>
+                          <ScheduledTipsList addToast={addToast} />
+                        </RequireAuth>
+                      )
+                    } 
+                  />
                   
                   {/* Public routes - accessible to all */}
                   <Route path={ROUTE_FEED} element={<RecentTips addToast={addToast} />} />
diff --git a/frontend/src/components/ScheduleTip.jsx b/frontend/src/components/ScheduleTip.jsx
new file mode 100644
index 00000000..b702de61
--- /dev/null
+++ b/frontend/src/components/ScheduleTip.jsx
@@ -0,0 +1,401 @@
+import { useState, useMemo, useCallback, useEffect } from 'react';
+import { toMicroSTX, formatSTX } from '../lib/utils';
+import { formatBalance, hasSufficientMicroStx } from '../lib/balance-utils';
+import { isValidStacksPrincipal } from '../lib/stacks-principal';
+import { canProceedWithRecipient, getRecipientValidationMessage } from '../lib/recipient-validation';
+import { totalDeduction, feeForTip, recipientReceives, FEE_PERCENT } from '../lib/post-conditions';
+import { useDemoMode } from '../context/DemoContext';
+import { useBalance } from '../hooks/useBalance';
+import { useBlockCheck } from '../hooks/useBlockCheck';
+import { useStxPrice } from '../hooks/useStxPrice';
+import { useSenderAddress } from '../hooks/useSenderAddress';
+import { analytics } from '../lib/analytics';
+import ConfirmDialog from './ui/confirm-dialog';
+import { Calendar, Clock } from 'lucide-react';
+
+const MIN_TIP_STX = 0.001;
+const MAX_TIP_STX = 10000;
+const MIN_SCHEDULE_MINUTES = 5;
+const MAX_SCHEDULE_DAYS = 365;
+
+const TIP_CATEGORIES = [
+    { id: 0, label: 'General' },
+    { id: 1, label: 'Content Creation' },
+    { id: 2, label: 'Open Source' },
+    { id: 3, label: 'Community Help' },
+    { id: 4, label: 'Appreciation' },
+    { id: 5, label: 'Education' },
+    { id: 6, label: 'Bug Bounty' },
+];
+
+export default function ScheduleTip({ addToast }) {
+    const { demoEnabled, getDemoData } = useDemoMode();
+    const { toUsd } = useStxPrice();
+    const { blocked: blockedWarning, checkBlocked, reset: resetBlockCheck } = useBlockCheck();
+    const [recipient, setRecipient] = useState('');
+    const [amount, setAmount] = useState('');
+    const [message, setMessage] = useState('');
+    const [category, setCategory] = useState(0);
+    const [scheduledDate, setScheduledDate] = useState('');
+    const [scheduledTime, setScheduledTime] = useState('');
+    const [loading, setLoading] = useState(false);
+    const [showConfirm, setShowConfirm] = useState(false);
+    const [recipientError, setRecipientError] = useState('');
+    const [amountError, setAmountError] = useState('');
+    const [scheduleError, setScheduleError] = useState('');
+
+    const walletSenderAddress = useSenderAddress();
+    const senderAddress = demoEnabled ? getDemoData().mockWalletAddress : walletSenderAddress;
+    const realBalanceState = useBalance(senderAddress);
+    const balance = demoEnabled ? getDemoData().mockBalance : realBalanceState.balance;
+    const balanceLoading = demoEnabled ? false : realBalanceState.loading;
+
+    const balanceSTX = useMemo(() => {
+        if (balance === null || balance === undefined) return null;
+        return typeof balance === 'string' ? Number(balance) / 1000000 : balance / 1000000;
+    }, [balance]);
+
+    const isRecipientHighRisk = !canProceedWithRecipient(recipient, blockedWarning);
+
+    const minScheduleDateTime = useMemo(() => {
+        const now = new Date();
+        now.setMinutes(now.getMinutes() + MIN_SCHEDULE_MINUTES);
+        return now.toISOString().slice(0, 16);
+    }, []);
+
+    const maxScheduleDateTime = useMemo(() => {
+        const now = new Date();
+        now.setDate(now.getDate() + MAX_SCHEDULE_DAYS);
+        return now.toISOString().slice(0, 16);
+    }, []);
+
+    const validateRecipient = useCallback((value) => {
+        resetBlockCheck();
+        setRecipientError('');
+
+        if (value && !isValidStacksPrincipal(value)) {
+            setRecipientError('Enter a valid Stacks principal');
+            return;
+        }
+
+        if (value.trim() === senderAddress) {
+            setRecipientError('You cannot send a tip to yourself');
+            return;
+        }
+
+        if (value) {
+            checkBlocked(value);
+        }
+    }, [checkBlocked, resetBlockCheck, senderAddress]);
+
+    useEffect(() => {
+        Promise.resolve().then(() => {
+            validateRecipient(recipient);
+        });
+    }, [recipient, validateRecipient]);
+
+    const handleRecipientChange = (value) => {
+        setRecipient(value);
+    };
+
+    const handleAmountChange = (value) => {
+        setAmount(value);
+        if (!value) { setAmountError(''); return; }
+        const parsed = parseFloat(value);
+        if (isNaN(parsed) || parsed <= 0) {
+            setAmountError('Amount must be a positive number');
+        } else if (parsed < MIN_TIP_STX) {
+            setAmountError(`Minimum tip is ${MIN_TIP_STX} STX`);
+        } else if (parsed > MAX_TIP_STX) {
+            setAmountError(`Maximum tip is ${MAX_TIP_STX.toLocaleString()} STX`);
+        } else if (balanceSTX !== null) {
+            const microSTX = toMicroSTX(parsed.toString());
+            if (!hasSufficientMicroStx(balance, totalDeduction(microSTX))) {
+                setAmountError('Insufficient balance');
+            } else {
+                setAmountError('');
+            }
+        } else {
+            setAmountError('');
+        }
+    };
+
+    const validateScheduleDateTime = useCallback(() => {
+        setScheduleError('');
+
+        if (!scheduledDate || !scheduledTime) {
+            return;
+        }
+
+        const scheduledDateTime = new Date(`${scheduledDate}T${scheduledTime}`);
+        const now = new Date();
+        const minTime = new Date(now.getTime() + MIN_SCHEDULE_MINUTES * 60 * 1000);
+        const maxTime = new Date(now.getTime() + MAX_SCHEDULE_DAYS * 24 * 60 * 60 * 1000);
+
+        if (scheduledDateTime < minTime) {
+            setScheduleError(`Scheduled time must be at least ${MIN_SCHEDULE_MINUTES} minutes in the future`);
+        } else if (scheduledDateTime > maxTime) {
+            setScheduleError(`Scheduled time cannot be more than ${MAX_SCHEDULE_DAYS} days in the future`);
+        }
+    }, [scheduledDate, scheduledTime]);
+
+    useEffect(() => {
+        validateScheduleDateTime();
+    }, [validateScheduleDateTime]);
+
+    const validateAndConfirm = () => {
+        if (!recipient || !amount || !scheduledDate || !scheduledTime) {
+            addToast('Please fill in all required fields', 'warning');
+            return;
+        }
+
+        if (!isValidStacksPrincipal(recipient)) {
+            addToast('Invalid Stacks principal format', 'warning');
+            return;
+        }
+
+        if (recipient.trim() === senderAddress) {
+            addToast('You cannot send a tip to yourself', 'warning');
+            return;
+        }
+
+        if (!canProceedWithRecipient(recipient, blockedWarning)) {
+            const validationMessage = getRecipientValidationMessage(recipient, blockedWarning);
+            addToast(validationMessage || 'Cannot send tip to this recipient', 'error');
+            return;
+        }
+
+        const parsedAmount = parseFloat(amount);
+        if (isNaN(parsedAmount) || parsedAmount <= 0) {
+            addToast('Please enter a valid amount', 'warning');
+            return;
+        }
+
+        if (parsedAmount < MIN_TIP_STX || parsedAmount > MAX_TIP_STX) {
+            addToast(`Amount must be between ${MIN_TIP_STX} and ${MAX_TIP_STX.toLocaleString()} STX`, 'warning');
+            return;
+        }
+
+        if (balanceSTX !== null) {
+            const microSTX = toMicroSTX(amount);
+            if (!hasSufficientMicroStx(balance, totalDeduction(microSTX))) {
+                addToast('Insufficient balance', 'warning');
+                return;
+            }
+        }
+
+        const scheduledDateTime = new Date(`${scheduledDate}T${scheduledTime}`);
+        const now = new Date();
+        const minTime = new Date(now.getTime() + MIN_SCHEDULE_MINUTES * 60 * 1000);
+
+        if (scheduledDateTime < minTime) {
+            addToast(`Scheduled time must be at least ${MIN_SCHEDULE_MINUTES} minutes in the future`, 'warning');
+            return;
+        }
+
+        setShowConfirm(true);
+        analytics.trackTipStarted();
+    };
+
+    const handleScheduleTip = async () => {
+        setShowConfirm(false);
+        setLoading(true);
+
+        try {
+            const scheduledDateTime = new Date(`${scheduledDate}T${scheduledTime}`);
+            const microSTX = toMicroSTX(amount);
+
+            const payload = {
+                sender: senderAddress,
+                recipient: recipient.trim(),
+                amount: microSTX,
+                scheduledFor: scheduledDateTime.toISOString(),
+                message: message || '',
+                category,
+            };
+
+            const response = await fetch('/api/scheduled-tips', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+            });
+
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error.message || 'Failed to schedule tip');
+            }
+
+            const result = await response.json();
+
+            setRecipient('');
+            setAmount('');
+            setMessage('');
+            setCategory(0);
+            setScheduledDate('');
+            setScheduledTime('');
+
+            addToast(`Tip scheduled for ${scheduledDateTime.toLocaleString()}`, 'success');
+            analytics.trackScheduledTipCreated();
+        } catch (error) {
+            console.error('Failed to schedule tip:', error);
+            addToast(error.message || 'Failed to schedule tip', 'error');
+            analytics.trackScheduledTipFailed();
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    return (
+        <div className="max-w-md mx-auto">
+            <div className="bg-white dark:bg-gray-900 rounded-2xl shadow-sm border border-gray-200 dark:border-gray-800 p-6">
+                <h2 className="text-xl font-bold text-gray-900 dark:text-white mb-6">Schedule a Tip</h2>
+
+                {senderAddress && (
+                    <div className="mb-5 flex items-center justify-between bg-gray-50 dark:bg-gray-800 rounded-xl px-4 py-3 border border-gray-100 dark:border-gray-700">
+                        <div>
+                            <p className="text-xs text-gray-500 dark:text-gray-400">Your Balance</p>
+                            <p className="text-lg font-bold text-gray-900 dark:text-white">
+                                {balanceLoading ? 'Loading...' : balanceSTX !== null
+                                    ? formatBalance(balance)
+                                    : 'Unavailable'}
+                            </p>
+                        </div>
+                    </div>
+                )}
+
+                <div className="space-y-4">
+                    <div>
+                        <label htmlFor="schedule-recipient" className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1.5">Recipient Address</label>
+                        {(() => {
+                            const isRisky = !canProceedWithRecipient(recipient, blockedWarning);
+                            const validationMsg = getRecipientValidationMessage(recipient, blockedWarning);
+                            return (
+                                <>
+                                    <input id="schedule-recipient" type="text" value={recipient} onChange={(e) => handleRecipientChange(e.target.value)}
+                                        className={`w-full px-4 py-2.5 border rounded-xl text-sm focus:ring-2 focus:ring-amber-500/50 focus:border-amber-500 outline-none transition-all bg-white dark:bg-gray-800 dark:text-white ${recipientError || (isRisky && validationMsg) ? 'border-red-300 dark:border-red-600' : 'border-gray-200 dark:border-gray-700'}`}
+                                        placeholder="SP2..." />
+                                    {recipientError && <p className="mt-1 text-xs text-red-500">{recipientError}</p>}
+                                    {validationMsg && <p className="mt-1 text-xs text-red-500">{validationMsg}</p>}
+                                </>
+                            );
+                        })()}
+                    </div>
+
+                    <div>
+                        <label htmlFor="schedule-amount" className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1.5">Amount (STX)</label>
+                        <input id="schedule-amount" type="number" value={amount} onChange={(e) => handleAmountChange(e.target.value)}
+                            className={`w-full px-4 py-2.5 border rounded-xl text-sm focus:ring-2 focus:ring-amber-500/50 focus:border-amber-500 outline-none transition-all bg-white dark:bg-gray-800 dark:text-white ${amountError ? 'border-red-300 dark:border-red-600' : 'border-gray-200 dark:border-gray-700'}`}
+                            placeholder="0.5" step="0.001" min={MIN_TIP_STX} max={MAX_TIP_STX} />
+                        {amountError && <p className="mt-1 text-xs text-red-500">{amountError}</p>}
+                    </div>
+
+                    <div className="grid grid-cols-2 gap-3">
+                        <div>
+                            <label htmlFor="schedule-date" className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1.5">
+                                <Calendar className="w-4 h-4 inline mr-1" />
+                                Date
+                            </label>
+                            <input id="schedule-date" type="date" value={scheduledDate} onChange={(e) => setScheduledDate(e.target.value)}
+                                min={minScheduleDateTime.split('T')[0]}
+                                max={maxScheduleDateTime.split('T')[0]}
+                                className="w-full px-4 py-2.5 border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 dark:text-white rounded-xl text-sm focus:ring-2 focus:ring-amber-500/50 focus:border-amber-500 outline-none transition-all" />
+                        </div>
+                        <div>
+                            <label htmlFor="schedule-time" className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1.5">
+                                <Clock className="w-4 h-4 inline mr-1" />
+                                Time
+                            </label>
+                            <input id="schedule-time" type="time" value={scheduledTime} onChange={(e) => setScheduledTime(e.target.value)}
+                                className="w-full px-4 py-2.5 border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 dark:text-white rounded-xl text-sm focus:ring-2 focus:ring-amber-500/50 focus:border-amber-500 outline-none transition-all" />
+                        </div>
+                    </div>
+                    {scheduleError && <p className="text-xs text-red-500">{scheduleError}</p>}
+
+                    <div>
+                        <label htmlFor="schedule-message" className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1.5">Message (optional)</label>
+                        <textarea id="schedule-message" value={message} onChange={(e) => setMessage(e.target.value)}
+                            className="w-full px-4 py-2.5 border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 dark:text-white rounded-xl text-sm focus:ring-2 focus:ring-amber-500/50 focus:border-amber-500 outline-none transition-all resize-none"
+                            placeholder="Great work!" maxLength={280} rows={2} />
+                        <p className={`text-xs mt-1 text-right ${message.length >= 280 ? 'text-red-500' : 'text-gray-400'}`}>
+                            {message.length}/280
+                        </p>
+                    </div>
+
+                    <div>
+                        <label htmlFor="schedule-category" className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1.5">Category</label>
+                        <select id="schedule-category" value={category} onChange={(e) => setCategory(Number(e.target.value))}
+                            className="w-full px-4 py-2.5 border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 dark:text-white rounded-xl text-sm focus:ring-2 focus:ring-amber-500/50 focus:border-amber-500 outline-none transition-all">
+                            {TIP_CATEGORIES.map((cat) => (
+                                <option key={cat.id} value={cat.id}>{cat.label}</option>
+                            ))}
+                        </select>
+                    </div>
+
+                    {amount && parseFloat(amount) > 0 && (
+                        <div className="bg-gray-50 dark:bg-gray-800 rounded-xl p-4 border border-gray-100 dark:border-gray-700 text-sm">
+                            <p className="font-semibold text-gray-700 dark:text-gray-200 mb-2">Fee Preview</p>
+                            <div className="space-y-1 text-gray-600 dark:text-gray-400">
+                                <div className="flex justify-between">
+                                    <span>Tip amount</span>
+                                    <span>
+                                        {parseFloat(amount).toFixed(6)} STX
+                                        {toUsd(amount) && <span className="text-gray-400 ml-1">(~${toUsd(amount)})</span>}
+                                    </span>
+                                </div>
+                                <div className="flex justify-between">
+                                    <span>Platform fee ({FEE_PERCENT}%)</span>
+                                    <span>{formatSTX(feeForTip(toMicroSTX(amount)), 6)} STX</span>
+                                </div>
+                                <div className="border-t border-gray-200 dark:border-gray-600 pt-1 mt-1 flex justify-between font-semibold text-gray-900 dark:text-white">
+                                    <span>Total from wallet</span>
+                                    <span>{formatSTX(totalDeduction(toMicroSTX(amount)), 6)} STX</span>
+                                </div>
+                                <div className="flex justify-between text-gray-500 dark:text-gray-500">
+                                    <span>Recipient receives</span>
+                                    <span>{formatSTX(recipientReceives(toMicroSTX(amount)), 6)} STX</span>
+                                </div>
+                            </div>
+                        </div>
+                    )}
+
+                    <button onClick={validateAndConfirm} disabled={loading || isRecipientHighRisk}
+                        className="w-full bg-gradient-to-r from-amber-500 to-orange-500 hover:from-amber-600 hover:to-orange-600 text-black font-bold py-3 px-4 rounded-xl shadow-sm hover:shadow-md transition-all active:scale-[0.98] disabled:opacity-40 disabled:cursor-not-allowed">
+                        {loading ? (
+                            <span className="flex items-center justify-center gap-2">
+                                <svg className="animate-spin h-4 w-4" fill="none" viewBox="0 0 24 24">
+                                    <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
+                                    <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" />
+                                </svg>
+                                Processing...
+                            </span>
+                        ) : 'Schedule Tip'}
+                    </button>
+                </div>
+
+                <ConfirmDialog open={showConfirm} title="Confirm Scheduled Tip" onConfirm={handleScheduleTip} onCancel={() => setShowConfirm(false)} confirmLabel="Schedule Tip">
+                    <div className="space-y-2">
+                        <p>Schedule <strong>{amount} STX</strong> to:</p>
+                        <p className="font-mono text-xs bg-gray-100 dark:bg-gray-800 p-2 rounded-lg break-all">{recipient}</p>
+                        <p className="text-sm text-gray-600 dark:text-gray-400">
+                            Scheduled for: <strong>{scheduledDate && scheduledTime ? new Date(`${scheduledDate}T${scheduledTime}`).toLocaleString() : ''}</strong>
+                        </p>
+                        <p className="text-sm text-gray-600 dark:text-gray-400">Category: <strong>{TIP_CATEGORIES.find(c => c.id === category)?.label}</strong></p>
+                        {message && <p className="italic text-gray-500">"{message}"</p>}
+                        {amount && parseFloat(amount) > 0 && (
+                            <div className="mt-3 pt-3 border-t border-gray-200 dark:border-gray-700 text-sm text-gray-600 dark:text-gray-400 space-y-1">
+                                <div className="flex justify-between">
+                                    <span>Platform fee ({FEE_PERCENT}%)</span>
+                                    <span>{formatSTX(feeForTip(toMicroSTX(amount)), 6)} STX</span>
+                                </div>
+                                <div className="flex justify-between font-semibold text-gray-900 dark:text-white">
+                                    <span>Total from your wallet</span>
+                                    <span>{formatSTX(totalDeduction(toMicroSTX(amount)), 6)} STX</span>
+                                </div>
+                            </div>
+                        )}
+                    </div>
+                </ConfirmDialog>
+            </div>
+        </div>
+    );
+}
diff --git a/frontend/src/components/ScheduledTipsList.jsx b/frontend/src/components/ScheduledTipsList.jsx
new file mode 100644
index 00000000..08f847ff
--- /dev/null
+++ b/frontend/src/components/ScheduledTipsList.jsx
@@ -0,0 +1,290 @@
+import { useState, useEffect, useCallback } from 'react';
+import { formatSTX } from '../lib/utils';
+import { useSenderAddress } from '../hooks/useSenderAddress';
+import { useDemoMode } from '../context/DemoContext';
+import { analytics } from '../lib/analytics';
+import { Calendar, Clock, X, CheckCircle, XCircle, Loader } from 'lucide-react';
+import ConfirmDialog from './ui/confirm-dialog';
+
+const STATUS_LABELS = {
+    pending: 'Pending',
+    processing: 'Processing',
+    executed: 'Executed',
+    cancelled: 'Cancelled',
+    failed: 'Failed',
+};
+
+const STATUS_COLORS = {
+    pending: 'bg-blue-100 text-blue-800 dark:bg-blue-900 dark:text-blue-200',
+    processing: 'bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200',
+    executed: 'bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200',
+    cancelled: 'bg-gray-100 text-gray-800 dark:bg-gray-900 dark:text-gray-200',
+    failed: 'bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200',
+};
+
+export default function ScheduledTipsList({ addToast }) {
+    const { demoEnabled, getDemoData } = useDemoMode();
+    const walletSenderAddress = useSenderAddress();
+    const senderAddress = demoEnabled ? getDemoData().mockWalletAddress : walletSenderAddress;
+
+    const [scheduledTips, setScheduledTips] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [filter, setFilter] = useState('all');
+    const [cancellingId, setCancellingId] = useState(null);
+    const [showCancelConfirm, setShowCancelConfirm] = useState(false);
+    const [tipToCancel, setTipToCancel] = useState(null);
+
+    const fetchScheduledTips = useCallback(async () => {
+        if (!senderAddress) return;
+
+        setLoading(true);
+        try {
+            const params = new URLSearchParams({ sender: senderAddress });
+            if (filter !== 'all') {
+                params.append('status', filter);
+            }
+
+            const response = await fetch(`/api/scheduled-tips?${params}`);
+            if (!response.ok) {
+                throw new Error('Failed to fetch scheduled tips');
+            }
+
+            const data = await response.json();
+            setScheduledTips(data.scheduledTips || []);
+        } catch (error) {
+            console.error('Failed to fetch scheduled tips:', error);
+            addToast('Failed to load scheduled tips', 'error');
+        } finally {
+            setLoading(false);
+        }
+    }, [senderAddress, filter, addToast]);
+
+    useEffect(() => {
+        fetchScheduledTips();
+    }, [fetchScheduledTips]);
+
+    const handleCancelClick = (tip) => {
+        setTipToCancel(tip);
+        setShowCancelConfirm(true);
+    };
+
+    const handleCancelTip = async () => {
+        if (!tipToCancel) return;
+
+        setShowCancelConfirm(false);
+        setCancellingId(tipToCancel.id);
+
+        try {
+            const response = await fetch(`/api/scheduled-tips/${tipToCancel.id}`, {
+                method: 'DELETE',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ sender: senderAddress }),
+            });
+
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error.message || 'Failed to cancel scheduled tip');
+            }
+
+            addToast('Scheduled tip cancelled successfully', 'success');
+            analytics.trackScheduledTipCancelled();
+            fetchScheduledTips();
+        } catch (error) {
+            console.error('Failed to cancel scheduled tip:', error);
+            addToast(error.message || 'Failed to cancel scheduled tip', 'error');
+        } finally {
+            setCancellingId(null);
+            setTipToCancel(null);
+        }
+    };
+
+    const formatDateTime = (dateString) => {
+        const date = new Date(dateString);
+        return date.toLocaleString(undefined, {
+            year: 'numeric',
+            month: 'short',
+            day: 'numeric',
+            hour: '2-digit',
+            minute: '2-digit',
+        });
+    };
+
+    const isUpcoming = (scheduledFor) => {
+        return new Date(scheduledFor) > new Date();
+    };
+
+    if (!senderAddress) {
+        return (
+            <div className="max-w-4xl mx-auto">
+                <div className="bg-white dark:bg-gray-900 rounded-2xl shadow-sm border border-gray-200 dark:border-gray-800 p-8 text-center">
+                    <p className="text-gray-500 dark:text-gray-400">Connect your wallet to view scheduled tips</p>
+                </div>
+            </div>
+        );
+    }
+
+    return (
+        <div className="max-w-4xl mx-auto">
+            <div className="bg-white dark:bg-gray-900 rounded-2xl shadow-sm border border-gray-200 dark:border-gray-800 p-6">
+                <div className="flex items-center justify-between mb-6">
+                    <h2 className="text-xl font-bold text-gray-900 dark:text-white">Scheduled Tips</h2>
+                    <button
+                        onClick={fetchScheduledTips}
+                        disabled={loading}
+                        className="text-sm text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200 disabled:opacity-50"
+                    >
+                        {loading ? 'Loading...' : 'Refresh'}
+                    </button>
+                </div>
+
+                <div className="flex gap-2 mb-6 overflow-x-auto">
+                    {['all', 'pending', 'executed', 'cancelled', 'failed'].map((status) => (
+                        <button
+                            key={status}
+                            onClick={() => setFilter(status)}
+                            className={`px-4 py-2 rounded-lg text-sm font-medium transition-colors whitespace-nowrap ${
+                                filter === status
+                                    ? 'bg-amber-500 text-black'
+                                    : 'bg-gray-100 text-gray-700 hover:bg-gray-200 dark:bg-gray-800 dark:text-gray-300 dark:hover:bg-gray-700'
+                            }`}
+                        >
+                            {status === 'all' ? 'All' : STATUS_LABELS[status]}
+                        </button>
+                    ))}
+                </div>
+
+                {loading ? (
+                    <div className="flex items-center justify-center py-12">
+                        <Loader className="w-8 h-8 animate-spin text-amber-500" />
+                    </div>
+                ) : scheduledTips.length === 0 ? (
+                    <div className="text-center py-12">
+                        <Calendar className="w-12 h-12 mx-auto text-gray-400 mb-3" />
+                        <p className="text-gray-500 dark:text-gray-400">
+                            {filter === 'all' ? 'No scheduled tips yet' : `No ${filter} scheduled tips`}
+                        </p>
+                    </div>
+                ) : (
+                    <div className="space-y-4">
+                        {scheduledTips.map((tip) => (
+                            <div
+                                key={tip.id}
+                                className="border border-gray-200 dark:border-gray-700 rounded-xl p-4 hover:border-gray-300 dark:hover:border-gray-600 transition-colors"
+                            >
+                                <div className="flex items-start justify-between gap-4">
+                                    <div className="flex-1 min-w-0">
+                                        <div className="flex items-center gap-2 mb-2">
+                                            <span className={`px-2 py-1 rounded-lg text-xs font-medium ${STATUS_COLORS[tip.status]}`}>
+                                                {STATUS_LABELS[tip.status]}
+                                            </span>
+                                            {tip.status === 'pending' && isUpcoming(tip.scheduledFor) && (
+                                                <span className="text-xs text-gray-500 dark:text-gray-400">
+                                                    Upcoming
+                                                </span>
+                                            )}
+                                        </div>
+
+                                        <div className="space-y-1">
+                                            <div className="flex items-center gap-2 text-sm">
+                                                <span className="text-gray-500 dark:text-gray-400">To:</span>
+                                                <span className="font-mono text-xs text-gray-900 dark:text-white truncate">
+                                                    {tip.recipient}
+                                                </span>
+                                            </div>
+
+                                            <div className="flex items-center gap-2 text-sm">
+                                                <span className="text-gray-500 dark:text-gray-400">Amount:</span>
+                                                <span className="font-semibold text-gray-900 dark:text-white">
+                                                    {formatSTX(tip.amount, 6)} STX
+                                                </span>
+                                            </div>
+
+                                            <div className="flex items-center gap-2 text-sm text-gray-600 dark:text-gray-400">
+                                                <Calendar className="w-4 h-4" />
+                                                <span>{formatDateTime(tip.scheduledFor)}</span>
+                                            </div>
+
+                                            {tip.message && (
+                                                <p className="text-sm text-gray-600 dark:text-gray-400 italic mt-2">
+                                                    "{tip.message}"
+                                                </p>
+                                            )}
+
+                                            {tip.txId && (
+                                                <div className="flex items-center gap-2 text-sm mt-2">
+                                                    <CheckCircle className="w-4 h-4 text-green-500" />
+                                                    <a
+                                                        href={`https://explorer.hiro.so/txid/${tip.txId}?chain=mainnet`}
+                                                        target="_blank"
+                                                        rel="noopener noreferrer"
+                                                        className="text-amber-600 hover:text-amber-700 dark:text-amber-400 dark:hover:text-amber-300 font-mono text-xs"
+                                                    >
+                                                        {tip.txId.slice(0, 8)}...{tip.txId.slice(-8)}
+                                                    </a>
+                                                </div>
+                                            )}
+
+                                            {tip.failureReason && (
+                                                <div className="flex items-center gap-2 text-sm mt-2 text-red-600 dark:text-red-400">
+                                                    <XCircle className="w-4 h-4" />
+                                                    <span>{tip.failureReason}</span>
+                                                </div>
+                                            )}
+                                        </div>
+                                    </div>
+
+                                    {tip.status === 'pending' && (
+                                        <button
+                                            onClick={() => handleCancelClick(tip)}
+                                            disabled={cancellingId === tip.id}
+                                            className="flex items-center gap-1 px-3 py-2 text-sm text-red-600 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 hover:bg-red-50 dark:hover:bg-red-900/20 rounded-lg transition-colors disabled:opacity-50"
+                                        >
+                                            {cancellingId === tip.id ? (
+                                                <Loader className="w-4 h-4 animate-spin" />
+                                            ) : (
+                                                <X className="w-4 h-4" />
+                                            )}
+                                            Cancel
+                                        </button>
+                                    )}
+                                </div>
+                            </div>
+                        ))}
+                    </div>
+                )}
+            </div>
+
+            <ConfirmDialog
+                open={showCancelConfirm}
+                title="Cancel Scheduled Tip"
+                onConfirm={handleCancelTip}
+                onCancel={() => {
+                    setShowCancelConfirm(false);
+                    setTipToCancel(null);
+                }}
+                confirmLabel="Cancel Tip"
+            >
+                {tipToCancel && (
+                    <div className="space-y-2">
+                        <p>Are you sure you want to cancel this scheduled tip?</p>
+                        <div className="bg-gray-50 dark:bg-gray-800 rounded-lg p-3 space-y-1 text-sm">
+                            <div className="flex justify-between">
+                                <span className="text-gray-600 dark:text-gray-400">Amount:</span>
+                                <span className="font-semibold">{formatSTX(tipToCancel.amount, 6)} STX</span>
+                            </div>
+                            <div className="flex justify-between">
+                                <span className="text-gray-600 dark:text-gray-400">Recipient:</span>
+                                <span className="font-mono text-xs">{tipToCancel.recipient.slice(0, 8)}...{tipToCancel.recipient.slice(-4)}</span>
+                            </div>
+                            <div className="flex justify-between">
+                                <span className="text-gray-600 dark:text-gray-400">Scheduled for:</span>
+                                <span>{formatDateTime(tipToCancel.scheduledFor)}</span>
+                            </div>
+                        </div>
+                        <p className="text-sm text-gray-500 dark:text-gray-400">This action cannot be undone.</p>
+                    </div>
+                )}
+            </ConfirmDialog>
+        </div>
+    );
+}
diff --git a/frontend/src/config/routes.js b/frontend/src/config/routes.js
index 2f888f57..dc04b9f0 100644
--- a/frontend/src/config/routes.js
+++ b/frontend/src/config/routes.js
@@ -37,6 +37,18 @@ export const ROUTE_BATCH = '/batch';
  */
 export const ROUTE_TOKEN_TIP = '/token-tip';
 
+/**
+ * Schedule a tip for future execution.
+ * @type {string}
+ */
+export const ROUTE_SCHEDULE = '/schedule';
+
+/**
+ * View and manage scheduled tips.
+ * @type {string}
+ */
+export const ROUTE_SCHEDULED_TIPS = '/scheduled-tips';
+
 /**
  * Live feed of recent tips across the platform.
  * @type {string}
@@ -101,6 +113,8 @@ export const ROUTE_LABELS = {
   [ROUTE_SEND]: 'Send Tip',
   [ROUTE_BATCH]: 'Batch',
   [ROUTE_TOKEN_TIP]: 'Token Tip',
+  [ROUTE_SCHEDULE]: 'Schedule',
+  [ROUTE_SCHEDULED_TIPS]: 'Scheduled Tips',
   [ROUTE_FEED]: 'Live Feed',
   [ROUTE_LEADERBOARD]: 'Leaderboard',
   [ROUTE_ACTIVITY]: 'My Activity',
@@ -123,6 +137,8 @@ export const ROUTE_TITLES = {
   [ROUTE_SEND]: 'Send Tip -- TipStream',
   [ROUTE_BATCH]: 'Batch Tip -- TipStream',
   [ROUTE_TOKEN_TIP]: 'Token Tip -- TipStream',
+  [ROUTE_SCHEDULE]: 'Schedule Tip -- TipStream',
+  [ROUTE_SCHEDULED_TIPS]: 'Scheduled Tips -- TipStream',
   [ROUTE_FEED]: 'Live Feed -- TipStream',
   [ROUTE_LEADERBOARD]: 'Leaderboard -- TipStream',
   [ROUTE_ACTIVITY]: 'My Activity -- TipStream',
@@ -165,6 +181,16 @@ export const ROUTE_META = {
     requiresAuth: true,
     adminOnly: false,
   },
+  [ROUTE_SCHEDULE]: {
+    description: 'Schedule a tip to be sent at a future date and time.',
+    requiresAuth: true,
+    adminOnly: false,
+  },
+  [ROUTE_SCHEDULED_TIPS]: {
+    description: 'View and manage your scheduled tips.',
+    requiresAuth: true,
+    adminOnly: false,
+  },
   [ROUTE_FEED]: {
     description: 'Real-time feed of tips across the platform.',
     requiresAuth: false,
diff --git a/frontend/src/lib/analytics.js b/frontend/src/lib/analytics.js
index 81b6db83..577e327c 100644
--- a/frontend/src/lib/analytics.js
+++ b/frontend/src/lib/analytics.js
@@ -15,6 +15,10 @@ const DEFAULT_METRICS = {
   batchTipsFailed: 0,
   batchTipsCancelled: 0,
   batchSizes: {},
+  scheduledTipsCreated: 0,
+  scheduledTipsCancelled: 0,
+  scheduledTipsExecuted: 0,
+  scheduledTipsFailed: 0,
   tabNavigations: {},
   routeRedirects: {},
   errors: {},
@@ -139,6 +143,22 @@ export const analytics = {
     increment('batchTipsCancelled');
   },
 
+  trackScheduledTipCreated() {
+    increment('scheduledTipsCreated');
+  },
+
+  trackScheduledTipCancelled() {
+    increment('scheduledTipsCancelled');
+  },
+
+  trackScheduledTipExecuted() {
+    increment('scheduledTipsExecuted');
+  },
+
+  trackScheduledTipFailed() {
+    increment('scheduledTipsFailed');
+  },
+
   trackTabNavigation(tab) {
     incrementMap('tabNavigations', tab);
   },
@@ -223,6 +243,10 @@ export const analytics = {
       batchTipsConfirmed: m.batchTipsConfirmed || 0,
       batchTipsFailed: m.batchTipsFailed || 0,
       batchTipsCancelled: m.batchTipsCancelled || 0,
+      scheduledTipsCreated: m.scheduledTipsCreated || 0,
+      scheduledTipsCancelled: m.scheduledTipsCancelled || 0,
+      scheduledTipsExecuted: m.scheduledTipsExecuted || 0,
+      scheduledTipsFailed: m.scheduledTipsFailed || 0,
       batchCompletionRate,
       batchDropOffRate,
       averageBatchSize,