The 10 most useful cron expressions, explained
Most cron jobs use a small set of recurring patterns. Here are 10 expressions you'll use most often, with explanations of what each does and when to use it.
For visual cron expression building, the cron builder generates expressions for you.
1. Every minute
```
*
```
Use cases: testing, real-time monitoring with low-cost jobs, lightweight polling.
Don't use for: anything heavy. 1440 fires per day adds up.
2. Every 5 minutes
```
/5 *
```
Equivalent to: `0,5,10,15,20,25,30,35,40,45,50,55 `
Use cases: monitoring health checks, polling external APIs, processing queue items.
Most common pattern for "frequent but not constant" tasks.
3. Every 15 minutes
```
/15 *
```
Use cases: status checks, lightweight data syncs, quarter-hourly reports.
A good middle ground between high-frequency and infrequent.
4. Every hour, on the hour
```
0
```
Use cases: hourly aggregation, periodic reports, cache refreshes.
The classic "hourly task" expression.
5. Every weekday morning at 9 AM
```
0 9 1-5
```
Use cases: daily standup notifications, morning report generation, business-hour-only tasks.
Day-of-week field uses `1-5` for Monday through Friday.
6. Daily at midnight
```
0 0 *
```
Or with the special string: `@daily`
Use cases: daily backup, log rotation, batch jobs that don't conflict with peak business hours.
7. Daily at noon (lunchtime tasks)
```
0 12 *
```
Use cases: daily metrics reset, midday report generation, lunchtime notification.
8. Weekly on Sunday morning at 6 AM
```
0 6 0
```
Use cases: weekly cleanup, weekly report compilation, weekly database optimization.
` 0` matches Sunday (day-of-week 0).
9. Monthly on the 1st at midnight
```
0 0 1
```
Or: `@monthly`
Use cases: monthly billing, monthly reports, archiving old data, monthly subscription renewals.
10. Quarterly (every 3 months) on the 1st
```
0 0 1 /3
```
Use cases: quarterly business reports, quarterly system audits, quarterly data exports.
The `*/3` step in the month field gives every 3rd month.
Bonus expressions
Run twice a day
```
0 9,17 * 9 AM and 5 PM daily
```
Every weekday at 9 AM and 5 PM
```
0 9,17 1-5
```
First business day of the month
```
0 9 1-3 * 1-5
```
This runs at 9 AM if day 1, 2, OR 3 is a weekday. Use a script to deduplicate if multiple days qualify.
Last business day of the month
Hard to express in standard cron. Common workaround: run on days 28-31 with a script that checks if it's the last business day.
```
0 17 28-31 * 1-5
```
Then have your script verify it's actually the last business day before doing the work.
Every 30 minutes during business hours
```
/30 9-17 * 1-5
```
This runs every 30 minutes from 9 AM to 5:30 PM, weekdays only.
Once a year on January 1st
```
0 0 1 1 *
```
Or: `@yearly`
Use case: annual report generation, year-over-year metrics.
Thursday before quarterly board meeting
If board meets the second Tuesday of every quarter, send agenda 3 days before:
```
0 9 4-10 1,4,7,10 4
```
This is approximate; complex enough that a custom script is usually better than pure cron.
Time zone considerations
These expressions assume the cron daemon's local time zone. For UTC alignment:
- Set the system to UTC, OR
- Adjust hours to match UTC equivalents
For example, "9 AM Eastern" in UTC depends on DST:
- Winter (EST): 9 AM EST = 14:00 UTC
- Summer (EDT): 9 AM EDT = 13:00 UTC
If you want a consistent UTC-anchored job:
```
0 14 * Always 14:00 UTC (= 9 AM EST in winter, 10 AM EDT in summer)
```
Or use a scheduling system with explicit time zone support (systemd timers, app-level schedulers).
Common mistakes with these expressions
Forgetting the leading 0
```
/15 * Every 15 minutes — STARTS AT MINUTE 0
```
This actually fires at 0, 15, 30, 45. NOT at 1, 16, 31, 46. The step starts at 0 by default.
To start at a different offset:
```
5/15 Starts at 5, then 20, 35, 50 (in implementations that support starting offsets)
```
Alternatively use a list:
```
5,20,35,50
```
Day-of-week off-by-one
Some tools use 1-7 for day-of-week (Monday = 1). Standard Unix cron uses 0-7 with 0 and 7 both = Sunday. Verify your scheduler's convention.
Month off-by-one
Months are 1-12 in cron. January = 1. (Different from JavaScript Date, where months are 0-11.)
Forgetting environment
Cron runs with minimal environment. Don't assume PATH includes /usr/local/bin or that custom variables are set. Source your environment explicitly:
```
0 9 * /home/user/scripts/backup.sh
```
vs better:
```
0 9 * cd /home/user && bash -c 'source ~/.bashrc && ./scripts/backup.sh'
```
When NOT to use cron
Cron isn't always the right answer:
- Long-running jobs: cron jobs that take hours. Better: dedicated daemon or job queue.
- Tasks needing precise timing: cron drift can be 1-2 seconds. For sub-second precision, use specialized tools.
- Tasks dependent on each other: cron doesn't have native job dependencies. Use Airflow, Dagster, or similar.
- Tasks that need monitoring: vanilla cron doesn't notify on failures. Wrap with monitoring tools.
- Tasks with retry logic: cron has no built-in retry. Use a wrapper or dedicated scheduler.
Common alternatives to cron
- systemd timers: modern Linux systems' replacement for cron. More features.
- PM2: Node.js process manager with cron-like scheduling.
- Airflow / Dagster / Prefect: full workflow orchestration with dependencies.
- GitHub Actions schedule: cron-like, runs in GitHub.
- AWS EventBridge: cron-like, runs in AWS.
- Cron services like Heroku Scheduler: managed cron without running your own daemon.
Cron expression validators
Before deploying, verify your expression:
- The cron builder shows when each expression will fire
- crontab.guru (online): plain-English explanation of any expression
- Inline cron-validation in many CI/CD systems
FAQ
What does `*/5` actually mean?
In the minute field, `*/5` fires at minute 0, 5, 10, ..., 55. The step is 5 starting from 0.
Can I run a job every 2 hours?
Yes: `0 /2 ` fires at hour 0, 2, 4, ..., 22.
What's the difference between `0 9 ` and `0 9 * 1-7`?
Both run daily at 9 AM. The first uses `*` for day-of-week; the second explicitly lists Monday-Sunday. Functionally identical.
Why doesn't my cron job run on the last day of the month?
Cron has no native "last day" syntax in standard Unix. Use day 28-31 with script logic, or use a scheduler with extensions (Quartz `L`).
How do I run a job at second 30 of every minute?
Standard Unix cron is minute-precision. For seconds, use a 6-field cron variant (Quartz, Spring) or a sleep-based wrapper.
Why does my cron job sometimes run an hour late?
Likely DST. The daemon adjusts for DST shifts but the behavior varies. Run in UTC to avoid this.
Bottom line
Most cron needs are covered by 10 common patterns: every 5/15/30 minutes, hourly, daily, weekday mornings, weekly, monthly, quarterly, yearly. Memorize these. For more complex needs, the cron builder helps you build the expression.