0Pricing
MongoDB Academy · Lesson

Scheduled Triggers and Cron Jobs

Learners will configure a scheduled trigger with a cron expression to run periodic maintenance tasks like archiving old documents.

Scheduled Triggers and Cron Jobs is a free MongoDB Academy lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the MongoDB Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

What Are Scheduled Triggers?

Scheduled Triggers in Atlas App Services execute an Atlas Function on a recurring schedule defined by a cron expression. Unlike database triggers (which fire in response to data changes), scheduled triggers fire based on time — making them ideal for maintenance tasks, periodic reports, data archiving, and cache refreshes that need to run automatically without human intervention.

Cron Expression Syntax

Atlas scheduled triggers use standard five-field cron expressions: minute hour day-of-month month day-of-week. Use * for 'every', */n for 'every n units', comma-separated values for lists, and ranges with -. Examples: 0 * * * * = every hour on the hour; 0 2 * * * = daily at 2 AM; */15 * * * * = every 15 minutes.

// Common cron expressions
'0 * * * *'    // Every hour at minute 0
'0 2 * * *'    // Daily at 02:00 UTC
'0 0 * * 0'    // Every Sunday at midnight
'0 0 1 * *'    // First day of every month at midnight
'*/15 * * * *' // Every 15 minutes
'0 9-17 * * 1-5' // Every hour, 9 AM to 5 PM, weekdays

Creating a Scheduled Trigger

You create scheduled triggers in the Atlas UI under App Services > Triggers > Add Trigger > Scheduled. You give it a name, set the schedule (cron expression or preset intervals like 'every 5 minutes'), and link an Atlas Function. The function receives no arguments — it is called with no event payload, unlike a database trigger, so it must know what to do based on the current time.

// Scheduled trigger config (via App Services API)
// {
//   name: 'dailyArchiveJob',
//   type: 'SCHEDULED',
//   config: {
//     schedule: '0 3 * * *'   // 3 AM UTC daily
//   },
//   functionName: 'archiveOldOrders'
// }

Common Use Case: Data Archiving

A classic scheduled trigger use case is archiving documents that are older than a threshold. The function queries for documents beyond the cutoff, copies them to an archive collection (or exports them to S3), then deletes the originals. This keeps the active collection lean and fast without requiring TTL indexes (which delete permanently without archiving).

// Atlas Function: archiveOldOrders (runs at 3 AM daily)
exports = async function() {
  const db = context.services.get('mongodb-atlas').db('mydb')
  const cutoff = new Date()
  cutoff.setMonth(cutoff.getMonth() - 6)  // older than 6 months

  const oldOrders = await db.collection('orders').find({
    createdAt: { $lt: cutoff },
    status: 'completed'
  }).toArray()

  if (oldOrders.length === 0) return

  // Copy to archive, then delete from active collection
  await db.collection('orders_archive').insertMany(oldOrders)
  await db.collection('orders').deleteMany({
    createdAt: { $lt: cutoff }, status: 'completed'
  })

  console.log('Archived ' + oldOrders.length + ' orders')
}

Common Use Case: Aggregating Statistics

Scheduled triggers are perfect for pre-computing expensive aggregations into a summary collection. Instead of running a heavy aggregation on every dashboard request, a scheduled trigger runs the aggregation once per hour (or per day) and stores results in a stats collection. Dashboard queries become instant point-lookups instead of multi-second scans.

// Atlas Function: computeDailyRevenue
exports = async function() {
  const db = context.services.get('mongodb-atlas').db('mydb')
  const today = new Date().toISOString().split('T')[0]  // 'YYYY-MM-DD'

  const result = await db.collection('orders').aggregate([
    { $match: { date: today, status: 'completed' } },
    { $group: { _id: '$region', revenue: { $sum: '$amount' }, count: { $sum: 1 } } }
  ]).toArray()

  // Upsert into stats collection
  for (const row of result) {
    await db.collection('daily_revenue').updateOne(
      { date: today, region: row._id },
      { $set: { revenue: row.revenue, count: row.count } },
      { upsert: true }
    )
  }
}

Common Use Case: Sending Reminders

Scheduled triggers are the right tool for time-triggered notifications: send a reminder email to users who have items in their cart for more than 24 hours, notify users of expiring subscriptions 7 days before renewal, or ping team members about overdue tasks. The trigger runs every hour (or every minute for time-sensitive notifications) and finds documents that meet the threshold.

// Atlas Function: sendCartAbandonmentReminders (runs hourly)
exports = async function() {
  const db = context.services.get('mongodb-atlas').db('mydb')
  const twentyFourHoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1000)

  const abandonedCarts = await db.collection('carts').find({
    updatedAt: { $lt: twentyFourHoursAgo },
    reminderSent: { $ne: true },
    status: 'active'
  }).toArray()

  for (const cart of abandonedCarts) {
    // Send email via a linked external service
    await context.functions.execute('sendEmail', cart.userEmail, 'You left items in your cart!')
    // Mark reminder sent to avoid duplicate emails
    await db.collection('carts').updateOne(
      { _id: cart._id },
      { $set: { reminderSent: true } }
    )
  }
}

Execution Timeout and Long-Running Jobs

Atlas Functions have a maximum execution time of 90 seconds. For long-running jobs (archiving millions of documents, sending thousands of emails), process data in batches: use limit() to process a manageable chunk per invocation, and run the trigger frequently enough to keep up. Use a state document in MongoDB to track the last processed position between invocations.

// Batch processing with state tracking
exports = async function() {
  const db = context.services.get('mongodb-atlas').db('mydb')
  const state = await db.collection('_trigger_state').findOne({ _id: 'archiver' })
  const lastId = state ? state.lastProcessedId : null

  const query = lastId ? { _id: { $gt: lastId }, status: 'completed' } : { status: 'completed' }
  const batch = await db.collection('orders').find(query)
    .sort({ _id: 1 }).limit(500).toArray()

  if (batch.length === 0) return

  await db.collection('orders_archive').insertMany(batch)
  await db.collection('orders').deleteMany({ _id: { $in: batch.map(d => d._id) } })
  await db.collection('_trigger_state').updateOne(
    { _id: 'archiver' },
    { $set: { lastProcessedId: batch[batch.length - 1]._id } },
    { upsert: true }
  )
}

Disabling Triggers During Maintenance

You can temporarily disable a scheduled trigger without deleting it — useful during database migrations, large data imports, or maintenance windows. Disabled triggers do not execute even when their cron schedule fires. Re-enable them after maintenance completes. All configuration is preserved when disabled.

// Disable a trigger via Atlas Admin API
// PUT /api/admin/v3.0/groups/{groupId}/apps/{appId}/triggers/{triggerId}
// Body: { 'disabled': true }

// Via Atlas CLI:
// atlas functions triggers update --triggerId <id> --disabled true

Logging and Monitoring Scheduled Triggers

Every scheduled trigger invocation is logged in the App Services execution log with the status (success/failure/timeout) and any console output from the function (console.log() calls appear in the log). Use structured logging — log the number of documents processed, any errors, and timing — so you can monitor job health and set up Atlas Alerts when a job fails.

// Good logging practice in a scheduled function
exports = async function() {
  const start = Date.now()
  try {
    const db = context.services.get('mongodb-atlas').db('mydb')
    const n = await doWork(db)
    console.log(JSON.stringify({ job: 'archive', status: 'success', processed: n, ms: Date.now() - start }))
  } catch(err) {
    console.error(JSON.stringify({ job: 'archive', status: 'error', error: err.message }))
    throw err  // re-throw so Atlas marks this invocation as failed
  }
}

Scheduled Triggers vs TTL Indexes

MongoDB TTL indexes (expireAfterSeconds) also delete old documents automatically but have limitations: they only delete — they cannot archive to another collection or S3. They run approximately every 60 seconds and cannot be paused. Scheduled triggers give you full control: archive instead of delete, run at specific times, batch process, and add custom business logic before removing documents.

// TTL index: simple deletion, no archiving
db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 86400 })

// Scheduled trigger: archive before delete, full control
// - Archive to S3 or another collection
// - Run only at low-traffic hours
// - Skip certain document types based on business rules
// - Send a Slack notification when done

Testing Scheduled Triggers

After creating a scheduled trigger, you can test it immediately from the Atlas UI using the 'Run' button — this invokes the function once without waiting for the next cron fire time. Use this to verify the function works before it runs in production. Check the execution log to see console output and confirm the function completed successfully.

// You can also test the underlying function directly
// via the Atlas Functions editor 'Run' button or CLI:
// appservices function run --name=archiveOldOrders

// Add a DRY RUN mode to your function for safe testing:
exports = async function(dryRun) {
  const isDry = dryRun || context.environment.values.DRY_RUN === 'true'
  const docs = await getDocsToArchive()
  if (!isDry) {
    await archiveDocs(docs)
  }
  console.log((isDry ? '[DRY RUN] Would archive' : 'Archived') + ' ' + docs.length + ' docs')
}

Quick Check

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

Lesson Recap

In this lesson you learned: scheduled triggers run Atlas Functions on a cron schedule for periodic maintenance, reporting, and notifications, processing in batches with state tracking is essential for large jobs that exceed the 90-second function timeout, and scheduled triggers offer more control than TTL indexes by enabling archive-before-delete workflows. Next up we explore writing Atlas Functions in JavaScript.

Frequently asked questions

Is the “Scheduled Triggers and Cron Jobs” lesson free?

Yes — the full text of “Scheduled Triggers and Cron Jobs” is free to read here on the web, and the MongoDB Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the MongoDB Academy course, upgrade to CoddyKit PRO.

What will I learn in “Scheduled Triggers and Cron Jobs”?

Learners will configure a scheduled trigger with a cron expression to run periodic maintenance tasks like archiving old documents. You practise MongoDB Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start MongoDB Academy?

No prior experience is required. MongoDB Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Scheduled Triggers and Cron Jobs” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this MongoDB Academy lesson?

Yes. Every MongoDB Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Database Triggers: Reacting to CRUD Events
  2. Scheduled Triggers and Cron Jobs
  3. Writing Atlas Functions in JavaScript
  4. HTTPS Endpoints as Lightweight Webhooks
← Back to MongoDB Academy