Run Task on Last Day of Month at 2:30 AM | CronBase
0 30 2 l * ? At 2:30 AM on the last day of every month
* In a Nutshell
The cron expression 0 30 2 l * ? runs At 2:30 AM on the last day of every month. This schedule is critical for processes that must run only once per month, specifically after all other daily or weekly tasks have completed. For example, it's ideal for final monthly financial reconciliations or generating consolidated end-of-month reports that depend on daily data aggregation.
* When to use this
Use 0 30 2 l * ? when a recurring task needs to run At 2:30 AM on the last day of every month. This schedule is commonly associated with end of month and financial processing and monthly schedules workloads. It uses Quartz Scheduler (6–7 Fields) syntax, supported by Unix cron daemons, cloud schedulers such as AWS EventBridge, and container orchestration platforms such as Kubernetes CronJob.
CronBase parses 0 30 2 l * ? using a dialect-aware rules engine that identifies the Quartz Scheduler (6–7 Fields) format, validates field structure against the Quartz Scheduler (6–7 Fields) specification, and produces the translation above. Next run times are calculated by forward-scanning from the current UTC clock. Learn how CronBase works.
Platform Implementations
Bash
Prerequisites
Unix/Linux host with a cron daemon running (vixie-cron, cronie, or systemd-cron). The script at /usr/local/bin/run-task.sh must exist and be executable (chmod +x).
Configuration
Run crontab -e to open the crontab editor. Cron reads the server's local timezone; prefix with CRON_TZ=UTC before the expression to pin to UTC. Always redirect output with >> /var/log/cron-tasks.log 2>&1 to capture both stdout and stderr.
Gotchas
Cron jobs inherit a minimal PATH — use full binary paths or set PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin at the top of the crontab. For sub-hourly schedules, add flock -n /tmp/run-task.lock before the command to skip overlapping runs if the previous execution is still running.
# Add to crontab with: crontab -e
30 2 l * * /usr/local/bin/run-task.sh >> /var/log/cron-tasks.log 2>&1Last verified:
Nodejs
Prerequisites
Node.js 18+ with node-cron installed (npm install node-cron). Add "type": "module" to package.json to use the import syntax shown above.
Configuration
Pass { timezone: 'UTC' } as the third argument to cron.schedule(). Without this option the schedule uses the Node.js process timezone, which shifts during DST transitions when servers are not pinned to UTC.
Gotchas
node-cron uses standard 5-field cron syntax — not Quartz 6-field. If your job runs longer than the schedule interval the next trigger fires while the previous is still executing. Use a boolean guard or a queue to skip concurrent runs rather than relying on the scheduler to enforce it.
import cron from 'node-cron';
cron.schedule('30 2 l * *', async () => {
console.log('[cron] running at', new Date().toISOString());
// your task logic here
}, { timezone: 'UTC' });Last verified:
Python
Prerequisites
Python 3.8+ with apscheduler installed (pip install apscheduler). For Python 3.12+ use apscheduler>=3.10.
Configuration
CronTrigger.from_crontab() accepts a standard 5-field cron string. Always pass timezone='UTC' to both the BlockingScheduler constructor and the trigger to ensure consistent scheduling regardless of the server's locale.
Gotchas
BlockingScheduler.start() blocks the calling thread indefinitely. For a web application, use BackgroundScheduler instead and call scheduler.start() at application startup. APScheduler logs missed fires if the process is stopped and restarted — configure misfire_grace_time (in seconds) to control how late a missed job is allowed to run.
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger
scheduler = BlockingScheduler(timezone='UTC')
@scheduler.scheduled_job(
CronTrigger.from_crontab('30 2 l * *', timezone='UTC')
)
def run_task() -> None:
print('task running')
# your task logic here
scheduler.start()Last verified:
Golang
Prerequisites
Go 1.18+ and github.com/robfig/cron/v3 (go get github.com/robfig/cron/v3).
Configuration
Always create the scheduler with cron.New(cron.WithLocation(time.UTC)). Without WithLocation, the library defaults to the server's local timezone. Call c.Start() to begin the scheduler, then block with select {} to keep the process alive.
Gotchas
robfig/cron v3 uses standard 5-field cron expressions by default. To add second-level precision (6 fields), pass cron.WithSeconds() to cron.New() — but this changes field positions, so never mix syntaxes in the same scheduler. Always check the error returned by c.AddFunc() — a malformed expression is silently ignored without it.
package main
import (
"fmt"
"time"
"github.com/robfig/cron/v3"
)
func main() {
c := cron.New(cron.WithLocation(time.UTC))
_, err := c.AddFunc("30 2 l * *", func() {
fmt.Println("task running at", time.Now().UTC())
// your task logic here
})
if err != nil {
panic(err)
}
c.Start()
defer c.Stop()
select {}
}Last verified:
Java
Prerequisites
Spring Boot 2.7+ (or Spring Framework 5.3+) with spring-context on the classpath. Annotate your @SpringBootApplication class with @EnableScheduling — without it, @Scheduled methods are silently ignored.
Configuration
Spring @Scheduled uses a 6-field Quartz-style expression: [sec] [min] [hr] [dom] [mon] [dow]. The expression 0 30 2 l * ? is derived from 0 30 2 l * ? — a leading 0 is prepended for the seconds field, and ? replaces the unconstrained day field.
Gotchas
Standard Unix cron has 5 fields; Spring requires 6. Pasting a 5-field expression directly into @Scheduled shifts every field by one and the job misfires silently. Use ? for either dom or dow — Quartz does not allow both to be *.
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@Component
public class ScheduledTask {
@Scheduled(cron = "0 30 2 l * ?")
public void runTask() {
System.out.println("task running at: " + java.time.Instant.now());
// your task logic here
}
}Last verified:
Kubernetes
Prerequisites
Kubernetes 1.21+ (CronJob API is GA). kubectl configured with cluster access. Container image must be pullable from within the cluster.
Configuration
Apply with kubectl apply -f cronjob.yaml. Check status with kubectl get cronjobs and inspect run history with kubectl get jobs. concurrencyPolicy: Allow is set because this schedule fires infrequently — parallel runs are acceptable.
Gotchas
Without startingDeadlineSeconds, a missed job (e.g., due to cluster downtime) triggers as soon as the controller recovers. Kubernetes 1.25+ supports timeZone: UTC in the spec to avoid timezone ambiguity. Keep successfulJobsHistoryLimit and failedJobsHistoryLimit low to avoid accumulating stale Job objects in the cluster.
apiVersion: batch/v1
kind: CronJob
metadata:
name: scheduled-task
spec:
schedule: "30 2 l * *"
concurrencyPolicy: Allow
jobTemplate:
spec:
template:
spec:
restartPolicy: OnFailure
containers:
- name: task
image: alpine:3.19
command: ["/bin/sh", "-c", "echo 'task running'"]Last verified:
Frequently Asked Questions
What exactly does the `0 30 2 l * ?` cron expression do?
This cron expression is configured to trigger a task precisely at 2:30 AM, but only on the very last calendar day of each month, regardless of how many days are in that specific month. It's designed for monthly-specific operations.
How does this schedule handle Daylight Saving Time clock changes?
Cron schedulers typically adjust automatically for Daylight Saving Time transitions. If a DST change occurs on the last day of the month at or around 2:30 AM, the job might run an hour earlier or later than usual, or potentially be skipped if the system observes the change by 'springing forward' or 'falling back' at that exact time.
How can I verify that my job is running on the last day of the month?
To verify, check your job execution logs for the past few months. You should see successful runs appearing on the last day of January, February (even in leap years), March, and so on. Ensure the timestamp in the logs aligns with the expected 2:30 AM execution time.
What are the potential gotchas with running on the last day of the month?
A primary concern is that the last day of the month can vary significantly (28, 29, 30, or 31 days). If your process relies on data from preceding days, ensure it can handle this variability and that upstream data sources are available by the time this job is scheduled to run.
What is a common variant of this monthly schedule?
A frequent variation is to run a task on the first day of the month instead. This is achieved by adjusting the day-of-month field to trigger at the beginning of each calendar month, suitable for tasks needing to start the new month's cycle.
More schedules like this
Explore End of Month →* Try any expression
Standard, Quartz, AWS EventBridge, Jenkins, named schedules (@daily, @hourly…)
* Keep Exploring