Scheduled Alerts

Summary

Scheduled Alerts fire at a date and time you configure
The Schedule can be either a one off, or on a recurring cron
Schedules are defined as specialised Scheduled Alert Definitions with a Schedule instead of a Rule

Scheduled Alerts notify users when a schedule fires.

Unlike the other AdapTable Alert types, they do not watch grid data, rules, or cell changes.

Hint

Scheduled Alerts are ideal to use as reminders or operational prompts
e.g. to prompt users to run an end-of-day report or review a dashboard at the same time each weekday

Scheduled Alerts use a Schedule model which can be configured in 2 ways (same as scheduled reports):

Recurring — a CronExpression using a 5-field cron (e.g. 30 17 * * 1-5 for 17:30 on weekdays)
One-off — a single run at a specified ISO datetime

Note

After a one-off Alert fires, it is not auto-suspended
You can edit the RunAt property to run the Alert again, or suspend/delete the definition in the Alert UI

You can configure a Scheduled Alert to behave like any other Alert, including:

displaying a Toast Notification
updating the Alert UI controls: Toolbar, Tool Panel and Status Bar Panel
logging to the console
displaying a System Status message

Caution

Some of the behaviour available in other Alerts are not relevant to Scheduled Alerts (and are hidden in the UI)
For instance behaviours relating to highlighting or jumping to Cells or undoing a Cell edits are removed

Alerts: Scheduled

Fork Fork

This example provides two Scheduled Alert definitions in Alert Initial State:
- Daily stand-up reminder — recurring cron (0 9 * * *) so the Alert runs every day at 09:00
- One-off demo Alert — runs once about 2 minutes after the demo loads (RunAt is computed when the sandpack starts)

Try It Out

Wait ~2 minutes after load for the one-off toast (or check System Status / Alert panel)
Edit the daily alert’s cron (e.g. change hour/minute) or suspend the one-off before it fires

import { AdaptableOptions } from '@adaptabletools/adaptable';
import { WebFramework } from './rowData';

/** One-off fires ~2 minutes after the demo loads (computed when this module runs). */
const oneOffRunAt = new Date(Date.now() + 2 * 60 * 1000).toISOString();

export const adaptableOptions: AdaptableOptions<WebFramework> = {
  primaryKey: 'id',
  adaptableId: 'Scheduled Alert',

  initialState: {
    Dashboard: {
      ModuleButtons: ['Alert'],
      Tabs: [
        {
          Name: 'Toolbars',
          Toolbars: ['Alert'],
        },
      ],
    },
    StatusBar: {
      StatusBars: [
        {
          Key: 'Center Panel',
          StatusBarPanels: ['Alert'],
        },
      ],
    },
    Theme: { CurrentTheme: 'dark' },
    Alert: {
      AlertDefinitions: [
        {
          Name: 'Daily stand-up reminder',
          MessageHeader: 'Daily stand-up',
          MessageText: 'Review the grid and confirm today’s priorities.',
          MessageType: 'Info',
          AlertProperties: {
            DisplayNotification: true,
            DisplaySystemStatusMessage: true,
          },
          Schedule: {
            IsOneOff: false,
            // Every day at 09:00 (minute hour day-of-month month day-of-week)
            CronExpression: '0 9 * * *',
          },
        },
        {
          Name: 'One-off demo alert',
          MessageHeader: 'Scheduled alert fired',
          MessageText: 'This one-off alert was set to run about 2 minutes after the demo loaded.',
          MessageType: 'Success',
          AlertProperties: {
            DisplayNotification: true,
            DisplaySystemStatusMessage: true,
            IncludeSuspendButton: true,
          },
          Schedule: {
            IsOneOff: true,
            RunAt: oneOffRunAt,
          },
        },
      ],
    },
    Layout: {
      CurrentLayout: 'Standard Layout',
      Layouts: [
        {
          TableColumns: [
            'action',
            'name',
            'language',
            'github_stars',
            'license',
            'created_at',
            'has_wiki',
            'updated_at',
            'topics',
          ],
          Name: 'Standard Layout',
          AutoSizeColumns: true,
        },
      ],
    },
  },
};

Configuring Scheduled Alerts

Scheduled Alerts are defined, and persisted, in the Alert section of Adaptable State.

Deep Dive

Anatomy of a Scheduled Alert

A Scheduled Alert is an object of type ScheduledAlertDefinition.

This is a specialised AlertDefinition containing a Schedule property (instead of Rule or Scope).

It inherits from Alert Definition Base which is defined as follows:

Property	Type	Description
MessageHeader	`string`	Title of displayed Alert Message
MessageText	`string`	Title of displayed Alert Message; if null, AdapTable creates dynamically using Rule & Scope
MessageType	`AdaptableMessageType`	Type of Alert: 'Info', 'Success', 'Warning', 'Error'; influences Alert colour, icon and logging
Name	`string`	Name of the Alert Definition
IsReadOnly	`boolean`	Sets Entity to ReadOnly (overwriting a Strategy Entitlement of 'Full')
IsSuspended	`boolean`	Suspends (i.e. turns off) an Adaptable Object

And it contains this extra schedule-related props:

Property	Type	Description
AlertProperties	`ScheduledAlertProperties`	Notification properties for scheduled alerts (no grid behaviours)
Schedule	`Schedule`	When the alert should run
IsReadOnly	`boolean`	Sets Entity to ReadOnly (overwriting a Strategy Entitlement of 'Full')
IsSuspended	`boolean`	Suspends (i.e. turns off) an Adaptable Object

The timing object is the shared Schedule type:

Property	Type	Description
CronExpression	`string`	Standard 5-field cron (minute hour day-of-month month day-of-week); e.g. weekdays at 09:30 → `30 9 * * 1-5`
IsOneOff	`boolean`	If true, the schedule runs once (using RunAt)
RunAt	`string`	ISO datetime for a one-off run (local time); set when IsOneOff is true

It contains an AlertProperties object of type ScheduledAlertProperties which derives from Alert Presentation Properties and defines some optional behaviour for the Alert:

Property	Type	Description
DisplayNotification	`boolean`	Displays a notification when Alert is triggered
DisplaySystemStatusMessage	`boolean`	Shows the alert message in the System Status panel
LogToConsole	`boolean`	Logs the Alert message to the console
NotificationDuration	`NotificationsOptions['duration']`	Notifiction duration(defaults to `NotificationOptions.duration`)
ShowInDiv	`boolean`	Shows Alert text in the div specificed in `alertContainer` property of Container Options

With these added properties:

Property	Type	Description
IncludeSuspendButton	`boolean`	When true, the scheduled notification includes a Suspend button

Developer Guide

Providing Scheduled Alerts in Initial State

Shared Alert Definitions are Alers which must include Schedule (instead of Rule / Scope).

const initialState: InitialState = {
  Alert: {
    AlertDefinitions: [
      {
        Name: 'End of day reminder',
        MessageHeader: "Run 'End of Day' report",
        MessageText: 'Send the report to Middle Office',
        MessageType: 'Warning',
        AlertProperties: {
          DisplayNotification: true,
          DisplaySystemStatusMessage: true,
        },
        Schedule: {
          IsOneOff: false,
          CronExpression: '30 17 * * 1-5',
        },
      },
      {
        Name: 'One-off check',
        MessageHeader: 'Review figures',
        MessageText: 'Please confirm today’s numbers before close',
        MessageType: 'Info',
        AlertProperties: {
          DisplayNotification: true,
        },
        Schedule: {
          IsOneOff: true,
          RunAt: '2026-05-19T17:30:00.000Z',
        },
      },
    ],
  },
};

Add AlertDefinitions under Alert Initial State

Scheduled Alerts live alongside rule-based Alerts in the same array. AdapTable distinguishes them by the presence of Schedule.

Set name, message, and notification properties

Name — unique Alert name
MessageHeader / MessageText — shown when the Alert fires (required for Scheduled Alerts in the UI)
MessageType — Info, Success, Warning, or Error (controls colour and icon)
AlertProperties.DisplayNotification — whether to show a toast when the schedule fires
AlertProperties.IncludeSuspendButton — when true, the notification includes OK and Suspend buttons (otherwise OK only)

Either: Create a Recurring schedule (cron)

Set Schedule.IsOneOff to false and provide CronExpression.

Example: 30 17 * * 1-5 runs at 17:30 on weekdays.

Or: Create a One-off schedule (RunAt)

Set Schedule.IsOneOff to true and RunAt to an ISO datetime (local time).

Hint

For a one-off Alert / reminder at design time that fires soon after the grid loads (e.g. in a demo), compute RunAt dynamically (as we do in the demo above)

Managing Scheduled Alerts

You can view active (and suspended) Scheduled Alerts in the Alert settings section of the Settings Panel.

Options include:

Create or Edit a Scheduled Alert using the Alert Wizard (set message, schedule and behaviour)
Suspend / Unsuspend — pauses scheduling without deleting the definition (IsSuspended)
Delete — removes the Alert Definition and cancels its timers

UI Step by Step Guide

Creating a Scheduled Alert in the Alert Wizard

Name & Type

Settings tab:

Enter a Name (must be unique among all Alert definitions).

Alert Type tab:

Select Scheduled — “fires at a date and time you choose”.
Other Alert types (Data Change, Validation, Observable, etc.) are hidden for the rest of the wizard.

Schedule

Configure when the Alert runs (same builder as report schedules):

Recurring — choose a preset (e.g. Every Day, Weekdays, Selected Days, Monthly) or Custom cron; set hour and minute.
One-off — pick the date and time for a single run (RunAt).

AdapTable stores either CronExpression or RunAt on the alert’s Schedule object.

Message

Message Type — choose Info, Success, Warning, or Error (colour and icon in notifications and Alert panels).

Message Text — for Scheduled Alerts, both fields are required:

Header — title shown in the notification and Alert UI.
Message — body text shown when the schedule fires.

Notification

Check Display a Notification when the Schedule is triggered to show a Toast Notification when the schedule runs.
With notifications enabled, use Alert Preview to see the header, message, and buttons.
The default notification includes OK only; enable Include Suspend button (or set AlertProperties.IncludeSuspendButton) to add a Suspend button on the popup.

If notifications are off, the Alert can still appear in Alert panels and system status depending on Behaviour.

Behaviour

Scheduled Alerts offer a reduced behaviour set (no cell/row highlights or jump-to, because nothing changed in the grid):

Show in separate <div /> element — render in a dedicated Alert region if configured in your layout.
Log To Console — write to the browser console when fired.
Show as System Status Message — add an entry to the System Status panel.

Tags (optional)

If Object Tags are enabled, assign tags so the Alert is limited to specific layouts like other Adaptable Objects.

Summary

Review all steps, then use Finish to save. The Alert is added to Alert.AlertDefinitions and timers are scheduled automatically.

FAQ

How is a Scheduled Alert different from a rule-based Alert? Rule-based Alerts include Scope and Rule and fire when data matches. Scheduled Alerts include only Schedule and fire at the configured time.

Can I still use the old Reminder objects in Schedule Initial State? No. Reminders were replaced in Version 23.0 with Scheduled Alert Definitions. Use Schedule with CronExpression / RunAt instead of DaysOfWeek, Hour, and Minute.

What happens after a one-off Scheduled Alert fires? The Alert runs once. It stays in state until you suspend, delete it, or change RunAt to a future time.

Why does the UI Wizard not show Trigger or Rule for Scheduled Alerts? Those steps apply only to data-driven Alert types. Scheduled Alerts have no column scope or expression and so the steps have been removed.

Can I suspend a Scheduled Alert from inside the notification so it won't run again? Yes, if you enable Display Notification and set AlertProperties.IncludeSuspendButton to true (or enable Include Suspend button in the Alert Wizard).

PreviousObservable Alerts NextValidation Alerts