Search tools

Developer guides

Cron Every 15 Minutes: Syntax, Offsets, and Server Spikes

Writing a cron job to run every 15 minutes is easy with */15. Here is how step values work, why top-of-the-hour spikes crash servers, and how to offset runs.

3D dark glass chronometer console with glowing pulse nodes at each 15-minute quadrant

Setting a background job to run every 15 minutes is one of the most common tasks in systems engineering. You need to poll an inbox, clean temporary session rows, or sync an external API.

The quick answer is: put */15 * * * * in your crontab.

You can verify your cron syntax and check the next execution dates in plain English with our cron expression generator.

Here is how the step operator works, why running on the exact quarter-hour can crash servers, and how to write a safer schedule.

How the */15 syntax works

A standard Linux crontab expression has five positional fields:

┌───────────── Minute (0 - 59)
│ ┌─────────── Hour (0 - 23)
│ │ ┌───────── Day of Month (1 - 31)
│ │ │ ┌─────── Month (1 - 12)
│ │ │ │ ┌───── Day of Week (0 - 6, Sunday is 0)
│ │ │ │ │
* * * * *

When you write */15 in the minute field, the forward slash acts as a step operator. It means: “start at minute 0 and run every 15th minute after that.”

*/15 * * * * triggers at: - XX:00 - XX:15 - XX:30 - XX:45

You can write the exact same schedule by listing the comma-separated minutes: 0,15,30,45 * * * *. Both expressions produce identical execution schedules.

The common beginner mistake: * 15 * * *

A frequent mistake is placing 15 in the hour field instead of the minute field:

# Wrong: runs every minute between 3:00 PM and 3:59 PM (60 executions!)
* 15 * * * /srv/app/sync.sh

# Right: runs every 15 minutes all day long (96 executions per day)
*/15 * * * * /srv/app/sync.sh

If your job is firing dozens of times in a row, our troubleshooting guide for silent cron failures walks through common crontab configuration traps.

The “thundering herd” problem

While */15 * * * * works, it has a serious operational drawback: everyone runs their jobs at :00, :15, :30, and :45.

If you have five microservices, backups, and third-party cron tasks all configured with */15, they will all wake up at the exact same millisecond. Your database connections spike, CPU load surges, and third-party APIs hit rate limits.

Worse, public cloud APIs experience traffic surges on the quarter hour as thousands of developers’ automated scripts hit them simultaneously.

The fix: Offset your minutes

Unless your job strictly requires synchronization with the clock (like generating financial quarterly snapshots), offset your starting minute:

# Offset by 3 minutes: runs at :03, :18, :33, :48
3,18,33,48 * * * * /srv/app/sync.sh

# Offset by 7 minutes: runs at :07, :22, :37, :52
7,22,37,52 * * * * /srv/app/sync.sh

By shifting execution by a few minutes, your job runs during the quiet valleys of server activity. CPU usage stays flat, disk I/O stays manageable, and rate-limit errors disappear.

How to test your crontab safely

Before deploying a new cron expression to production:

  1. Redirect outputs: Make sure both standard output and errors are captured: >> /tmp/job.log 2>&1.
  2. Verify time zones: Server clocks almost always run in UTC. A job scheduled for 15 minutes past the hour in your local time may run at unexpected hours if daylight saving time shifts. Read our cron time zones and daylight saving guide to avoid timing bugs.

To generate expressions for custom intervals, daily cutoffs, or weekly maintenance, use the ToolQuilt cron expression generator.

Read next