What do the five fields in a standard Unix cron expression represent?

From left to right: Minute (0-59), Hour (0-23), Day of Month (1-31), Month (1-12 or JAN-DEC), and Day of Week (0-7, where 0 and 7 are Sunday).

What is the difference between an asterisk (*) and a question mark (?) in cron syntax?

An asterisk (*) matches every allowed value in that field. The question mark (?) is used in Quartz/Spring schedules to signify "no specific value" when you want to specify Day of Week without constraining Day of Month (or vice versa).

How do step values like */15 work in cron expressions?

Step values specify repetition intervals starting from the lowest field number. In the Minute field, */15 means "every 15 minutes", executing at minutes 0, 15, 30, and 45 of each matching hour.

How can I prevent overlapping cron job executions if a task takes longer than the interval?

Use file-based locks (flock in Linux shell scripts), concurrency guards in application code (boolean flags or mutexes), or distributed locks (Redis Redlock) to ensure previous runs finish before new ones start.

Why is running cron jobs in UTC recommended over local server time?

UTC does not observe Daylight Saving Time (DST). Running in local time can cause scheduled jobs to run twice during autumn clock fallbacks or skip entirely during spring forward transitions.

Dev & Data Popular

Cron Expression Generator & Human Explainer

Build standard 5-part and Quartz 6-part cron expressions visually with plain-English human translations, next execution run-time schedules, preset templates, and syntax validator.

Interactive schedule builder for Minute, Hour, Day of Month, Month, and Day of Week fields

Real-time plain-English translation converting cryptic expressions into natural human sentences

Next 5 to 10 upcoming execution timestamps calculated dynamically based on user timezone

Extensive preset library: hourly, daily at midnight, weekdays at 9am, bi-weekly, end of month

Support for both standard Unix crontab (5 fields) and extended Quartz/Spring schedules (6 fields)

The Complete Guide to Cron Expression Syntax, Schedules & Automation

In-depth specifications, architectural mechanics, real-world code implementations, and industry best practices.

Understanding Unix Crontab Architecture (The 5-Field Standard)

Crontab (cron table) is the time-based job scheduler standard found across Unix, Linux, and macOS environments. A standard cron expression consists of 5 space-separated fields: 1. Minute (0–59) 2. Hour (0–23, 24-hour format) 3. Day of Month (1–31) 4. Month (1–12 or JAN–DEC) 5. Day of Week (0–7, where both 0 and 7 represent Sunday, or SUN–SAT) Each field defines matching temporal constraints that the daemon evaluates every minute to trigger scheduled scripts, database backups, cache updates, and background workers.

Implementation Example

┌───────────── Minute (0 - 59)
│ ┌─────────── Hour (0 - 23)
│ │ ┌───────── Day of Month (1 - 31)
│ │ │ ┌─────── Month (1 - 12 or JAN - DEC)
│ │ │ │ ┌───── Day of Week (0 - 7 or SUN - SAT)
│ │ │ │ │
* * * * *  (Executes every single minute)

Special Characters Explained: Asterisk (*), Slash (/), Comma (,), Hyphen (-)

• Cron expressions use concise wildcard operators to construct complex scheduling logic:
• Asterisk (*): Wildcard matching all allowed values in the field (e.g., * in Hour means every hour).
• Comma (,): Value list separator specifying multiple discrete execution points (e.g., 15,45 in Minute).
• Hyphen (-): Continuous range operator (e.g., 9-17 in Hour runs during business hours from 9 AM to 5 PM).
• Slash (/): Step interval modifier (e.g., */15 in Minute runs at 0, 15, 30, and 45 minutes past the hour).
• Question Mark (?): Used in Quartz/Spring 6-part cron to denote "no specific value" when disambiguating Day of Month vs Day of Week.

Implementation Example

# Common Production Cron Schedule Examples
0 0 * * *        # Daily at 00:00 (midnight UTC)
*/10 * * * *     # Every 10 minutes continuously
0 9 * * 1-5      # Weekdays (Monday through Friday) at 9:00 AM
0 0 1,15 * *     # Bi-monthly: 1st and 15th of every month at midnight
0 3 * * 0        # Weekly on Sunday at 03:00 AM (Database cleanup)

Step-by-Step: Parsing and Calculating Next Cron Occurrences in TypeScript

Calculating future execution dates requires matching candidate Date objects against parsed field constraints. The scheduling engine increments minutes sequentially until all 5 field conditions evaluate to true.

Implementation Example

// Basic Cron Parser & Next Run Calculator in TypeScript
export interface CronFields {
  minutes: number[];
  hours: number[];
  daysOfMonth: number[];
  months: number[];
  daysOfWeek: number[];
}

export function parseCronField(field: string, min: number, max: number): number[] {
  if (field === '*') {
    return Array.from({ length: max - min + 1 }, (_, i) => min + i);
  }
  if (field.startsWith('*/')) {
    const step = parseInt(field.slice(2), 10);
    const result: number[] = [];
    for (let i = min; i <= max; i += step) result.push(i);
    return result;
  }
  if (field.includes(',')) {
    return field.split(',').map((v) => parseInt(v.trim(), 10));
  }
  if (field.includes('-')) {
    const [start, end] = field.split('-').map((v) => parseInt(v.trim(), 10));
    return Array.from({ length: end - start + 1 }, (_, i) => start + i);
  }
  return [parseInt(field, 10)];
}

export function getNextCronDate(expression: string, fromDate: Date = new Date()): Date {
  const [minStr, hrStr, domStr, monStr, dowStr] = expression.trim().split(/\s+/);
  const minutes = parseCronField(minStr, 0, 59);
  const hours = parseCronField(hrStr, 0, 23);
  const months = parseCronField(monStr, 1, 12);
  const daysOfWeek = parseCronField(dowStr, 0, 6);

  const candidate = new Date(fromDate.getTime() + 60000);
  candidate.setSeconds(0, 0);

  for (let i = 0; i < 525600; i++) { // Check up to 1 year ahead
    if (
      minutes.includes(candidate.getMinutes()) &&
      hours.includes(candidate.getHours()) &&
      months.includes(candidate.getMonth() + 1) &&
      daysOfWeek.includes(candidate.getDay())
    ) {
      return candidate;
    }
    candidate.setMinutes(candidate.getMinutes() + 1);
  }
  throw new Error('No matching execution found within 1 year');
}

Quartz & Spring 6-Part Cron vs Standard Unix 5-Part Cron

Enterprise Java frameworks (Quartz, Spring Scheduler) extend standard cron to 6 or 7 fields by adding a Seconds field at index 0 and an optional Year field at index 6. In Quartz, you cannot specify both Day of Month and Day of Week simultaneously; one must be designated with the question mark (?) character to prevent scheduling ambiguity.

Implementation Example

// Quartz 6-Field Schedule Format
// Seconds Minutes Hours DayOfMonth Month DayOfWeek
"0 15 10 ? * MON-FRI" // 10:15:00 AM every weekday

Timezone Pitfalls, Daylight Saving Time & Overlapping Run Prevention

Scheduling critical automated jobs in local timezones leads to execution failures during Daylight Saving Time (DST) transitions—jobs may execute twice in autumn or get skipped completely in spring. Production infrastructure should always configure cron daemons in Coordinated Universal Time (UTC). Furthermore, long-running tasks must utilize mutex locks (e.g., flock on Linux or Redis Redlock in distributed systems) to prevent overlapping concurrency bottlenecks.

Implementation Example

// Node.js safe scheduled task with lock guard
import cron from 'node-cron';

let isJobRunning = false;

cron.schedule('*/5 * * * *', async () => {
  if (isJobRunning) {
    console.warn('Previous job still executing. Skipping iteration.');
    return;
  }
  isJobRunning = true;
  try {
    await performDatabaseBackup();
  } finally {
    isJobRunning = false;
  }
}, { timezone: 'UTC' });

Knowledge Base & Clarifications