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

Why is */15 a popular cron interval?

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

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 the full AWS ruleset — the ? quirk, # and L operators, CloudFormation and Terraform examples — see the AWS EventBridge cron generator. For the complete Kubernetes manifest with concurrencyPolicy and startingDeadlineSeconds, use the Kubernetes CronJob schedule generator.

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