Skip to main content
Tools Harbor

Cron expression for every 15 minutes

The cron expression */15 * * * * runs a job every 15 minutes — at :00, :15, :30 and :45 of every hour. Four runs per hour, 96 runs per day. The clock-aligned firing makes it ideal for monitoring pings, cache refreshes and any job that needs to overlap with external systems’ quarter-hour boundaries.

Quick reference

PlatformExpression
Unix / Linux crontab*/15 * * * *
Kubernetes CronJob*/15 * * * *
GitHub Actions*/15 * * * *
AWS EventBridgecron(0/15 * * * ? *)
Quartz (Java)0 0/15 * ? * *

It hits four marks per hour aligned with the natural clock divisions — :00, :15, :30, :45 — which means your job runs at the same minute marks every hour, every day. Three concrete reasons this matters:

  • Monitoring pings — Pingdom, UptimeRobot, Better Stack and most monitoring services check at clock-aligned intervals. Aligning your refresh to :15-marks means metrics are fresh when the monitor checks.
  • Cache TTL alignment — a 15-minute Redis cache TTL combined with */15 refresh means the cache is always fresh when read.
  • Cross-system sync — when two services both run on */15, they observe the world at the same moments — easier to debug than offset schedules.

Variations

ScheduleExpression
Every 15 min, business hours only*/15 9-17 * * *
Every 15 min, weekdays only*/15 * * * 1-5
Every 15 min on the half-hour offset (:07, :22, :37, :52)7-59/15 * * * *
Every 15 min in AWScron(0/15 * * * ? *)
Every 15 min in AWS, weekdays onlycron(0/15 * ? * MON-FRI *)

How do I use it on each platform?

Linux crontab:

*/15 * * * * /usr/local/bin/refresh-cache

Kubernetes CronJob:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: refresh-cache
spec:
  schedule: "*/15 * * * *"
  concurrencyPolicy: Forbid
  jobTemplate:
    spec:
      template:
        spec:
          containers:
            - name: refresh
              image: my-org/refresh-cache:1.0
          restartPolicy: OnFailure

AWS EventBridge Scheduler (with timezone):

Type: AWS::Scheduler::Schedule
Properties:
  Name: refresh-cache
  ScheduleExpression: 'cron(0/15 * * * ? *)'
  ScheduleExpressionTimezone: 'UTC'
  FlexibleTimeWindow:
    Mode: 'OFF'
  Target:
    Arn: !GetAtt RefreshFunction.Arn
    RoleArn: !GetAtt SchedulerRole.Arn

GitHub Actions:

on:
  schedule:
    - cron: '*/15 * * * *'

Common mistakes

Off-the-quarter offsets are valid but rarely needed. 7-59/15 * * * * runs at :07, :22, :37, :52 — sometimes useful to dodge a thundering herd at :00, but breaks the alignment that makes */15 valuable in the first place.

Confusing */15 with “every 15 minutes after the previous run”. Cron is clock-aligned. If a run takes 16 minutes, the next one starts 1 minute after — overlap is your problem to handle (set concurrencyPolicy: Forbid in K8s, reserve concurrency 1 for Lambda targets).

Assuming AWS rejects */15. Older AWS documentation claims */15 is invalid and only 0/15 works. In practice both forms parse correctly today. Use 0/15 for portability with old IaC, */15 if you prefer the standard form.

For other schedules see common cron schedules, or build a custom expression with the Cron Expression Builder.

Frequently asked questions

What is the difference between `*/15` and `0/15`?
Both mean "every 15 units starting from 0". Standard Unix cron accepts both. AWS EventBridge prefers `0/15` and some older AWS docs even claim `*/15` is invalid — it actually works in EventBridge today, but `0/15` is the safer form for AWS-specific docs and IaC examples.
Why might my :00, :15, :30, :45 runs drift over time?
Cron itself doesn't drift — the controller checks the current minute every cycle and fires when the minute matches. What you might see is small jitter (a few seconds late) because of controller polling intervals or queue backpressure. If runs are minutes late, the controller is overloaded or has been restarted; investigate the controller, not the cron expression.
Is `*/15` aligned with the clock or with cron startup time?
Always with the wall clock. `*/15 * * * *` runs at :00, :15, :30, :45 — never at :07, :22, :37, :52. The expression is independent of when cron started or when the rule was created.

Need a different schedule?

Build cron expressions for Unix, Kubernetes and AWS — with a human-readable description and the next 5 run times.

Open the Cron Expression Builder →

Related

Cron expression for every 5 minutes

The cron expression `*/5 * * * *` runs every 5 minutes in Linux crontab, Kubernetes, GitHub Actions; `cron(*/5 * * * ? *)` in AWS EventBridge.

Cron expression for every hour

The cron expression `0 * * * *` runs once per hour on the hour. Same syntax in Linux, Kubernetes and GitHub Actions; `cron(0 * * * ? *)` in AWS EventBridge.

Cron expression for daily at midnight

The cron expression `0 0 * * *` runs once daily at midnight. Watch the timezone — Kubernetes < 1.25 and AWS EventBridge default to UTC, not local time.

Cron expression for every weekday

The cron expression `0 9 * * 1-5` runs at 9 AM Monday through Friday. AWS uses `cron(0 9 ? * MON-FRI *)` because day-of-week numbering differs.

Cron expression for the first of every month

The cron expression `0 0 1 * *` runs at midnight on the 1st of every month. AWS uses `cron(0 0 1 * ? *)`.

Cron expression for every Sunday

The cron expression `0 0 * * 0` runs every Sunday at midnight in Unix cron. AWS uses `cron(0 0 ? * 1 *)` because Sunday is `1` in AWS, not `0`.