Crontab, Cron Jobs and Modern Scheduled Tasks

---

The first version of this article was published in 2019. Since then, the cron job landscape has evolved from “SSH into a server and type crontab -e in a Linux terminal” to a fully serverless, event-driven and stateful architecture. As of 2026, cron is no longer merely a component of the operating system; it is an orchestration tool within cloud architecture.

Crontab Fundamentals

Cron is the daemon that manages scheduled tasks on Unix-based systems (Linux, macOS, BSD). crontab refers to the file and command where these tasks are defined. Each user has their own crontab file, while system-wide tasks are managed through /etc/crontab¹.

Time Expression Syntax

* * * * * [command-or-script]
┬ ┬ ┬ ┬ ┬
│ │ │ │ └───── day of week (0-6, 0=Sunday)
│ │ │ └────────── month (1-12)
│ │ └─────────────── day (1-31)
│ └──────────────────── hour (0-23)
└───────────────────────── minute (0-59)

Basic Operations

# List all tasks
crontab -l

# Edit tasks (with default editor)
crontab -e

# Edit with nano (one-time)
env EDITOR=nano crontab -e

# Delete all tasks (use with caution)
crontab -r

Common Time Expressions

Expression	Description
* * * * *	Every minute
0 * * * *	Every hour
0 9 * * *	Every day at 09:00
0 9 * * 1-5	Weekdays at 09:00
0 0 1 * *	First day of every month at midnight
*/15 * * * *	Every 15 minutes
0 9,18 * * *	Every day at 09:00 and 18:00

Shortcut Expressions

Shortcut	Equivalent	Description
@reboot	-	Once at system startup
@hourly	0 * * * *	Once per hour
@daily	0 0 * * *	Once per day
@weekly	0 0 * * 0	Once per week
@monthly	0 0 1 * *	Once per month
@yearly	0 0 1 1 *	Once per year

A Simple Example

A task that generates a random number every minute and writes it to a file:

# Create random.sh
cat > ~/random.sh << 'SCRIPT'
#!/bin/bash
NUMBER=$[ ( $RANDOM % 100 ) + 1 ] && echo $NUMBER >> ~/number.log
SCRIPT
chmod +x ~/random.sh

# Add to crontab
crontab -e
# Line to add:
* * * * * ~/random.sh

systemd Timers: The Modern Alternative to Crontab

On systemd-based Linux distributions, systemd timers offer distinct advantages over crontab²:

Feature	crontab	systemd Timers
Setup	Single line	Two unit files (service + timer)
Logging	Limited (mail, syslog)	Full journald integration
Missed tasks	Silently skipped	Caught with Persistent=true
Overlap prevention	None (new instance starts)	Single instance guarantee
Dependencies	None	Network, disk, other service dependencies
Resource control	None	cgroups (CPU, memory limits)
Portability	BSD, macOS, all Unix	systemd Linux only

systemd Timer Example

# /etc/systemd/system/backup.service
[Unit]
Description=Daily Backup

[Service]
Type=oneshot
ExecStart=/opt/scripts/backup.sh

# /etc/systemd/system/backup.timer
[Unit]
Description=Daily Backup Scheduler

[Timer]
OnCalendar=*-*-* 03:00:00
Persistent=true

[Install]
WantedBy=timers.target

# Enable and start
systemctl enable --now backup.timer

# Check status
systemctl list-timers
journalctl -u backup.service

When to use which? For simple scheduling, macOS/BSD environments and quick one-liner tasks, use crontab. For production servers that require logging, dependency management and resource control, use systemd timers.

From Classic Cron to Cloud-Native Cron

In 2019, running scheduled tasks required a dedicated server (EC2, Droplet, etc.) to remain up at all times. In 2026, serverless platforms eliminate this requirement by charging only for execution time.

Cloudflare Workers Cron Triggers

Workers, running on what Cloudflare’s official network page lists as 330+ cities of edge servers, can be triggered at specific intervals using cron triggers³:

# wrangler.toml
[triggers]
crons = ["0 3 * * *", "*/30 * * * *"]

export default {
  async scheduled(controller, env, ctx) {
    ctx.waitUntil(async () => {
      // Fetch and process e-commerce data
      const data = await env.DB.prepare("SELECT * FROM orders WHERE date = ?")
        .bind(today())
        .all();
      await processOrders(data);
    });
  },
};

	Free	Paid ($5/month)
Trigger count (per account)	5	250
CPU time (scheduled handler)	10 ms	30 seconds (< 1 hour interval) / 15 minutes (>= 1 hour interval)

Cloudflare documentation specifies a 10-millisecond CPU time limit per scheduled handler on the free plan; long-running cron jobs require the Paid plan.

Vercel Cron Jobs

Vercel can trigger Serverless and Edge Functions via cron⁴:

{
  "crons": [
    { "path": "/api/daily-digest", "schedule": "0 9 * * *" },
    { "path": "/api/cleanup", "schedule": "0 0 * * 0" }
  ]
}

	Hobby	Pro
Cron count (per project)	100	100
Cron count (per team)	2	40
Minimum interval	Once per day	Once per minute
Execution timeout	10 sec	300 sec

On the Hobby plan, cron expressions that run more frequently than daily intervals fail the deployment. The 100 cron-per-project ceiling is the same across plans; the real bottleneck is the team-wide total (Hobby 2, Pro 40).

GitHub Actions as Cron

For simple data fetching tasks, GitHub Actions’ schedule trigger is widely used⁵:

on:
  schedule:
    - cron: "0 */6 * * *" # Every 6 hours

jobs:
  fetch-data:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: python scripts/fetch_data.py

There are notable limitations to be aware of: a minimum 5-minute interval, risk of delays or skips during peak hours, and automatic disabling after 60 days of inactivity on public repositories. It is completely free for public repositories, and private repositories receive 2,000 free minutes per month.

AWS EventBridge Scheduler

EventBridge Scheduler, the successor to CloudWatch Events, can target over 200 AWS services and more than 6,000 API operations according to the official AWS page⁶. The permanent free tier provides 14 million invocations per month; this allowance is region-wide and never expires.

Railway Cron

Railway offers cron configuration through its dashboard with a minimum interval of 5 minutes. It supports UTC only, and the service must exit after completing its task.

Comparison Table

Platform	Min. Interval	Free Tier	Retry	Durable	Configuration
crontab	1 minute	N/A (OS)	No	No	crontab
systemd timers	1 second	N/A (OS)	No	Persistent	Unit files
CF Workers Cron	1 minute	5 triggers, 100k req/day	No	No	wrangler.toml
Vercel Cron	1 min (Pro), 1/day (Hobby)	100 crons	No	No	vercel.json
GitHub Actions	5 minutes	2k min/month (private)	No	No	YAML
EventBridge	1 minute	14M invocations/month	Configurable	No	Console/SDK
Railway	5 minutes	Included in plan	No	No	Dashboard

Stateful and Reliable Scheduling

In 2019, when a cron job failed, the task would silently die. Modern platforms have changed this.

Inngest

Inngest is an event-driven durable execution platform. It can trigger functions via cron, events or webhooks, and fully manages queuing, state, retries and scheduling⁷:

import { inngest } from "./client";

export const weeklyReport = inngest.createFunction(
  { id: "weekly-report" },
  { cron: "TZ=Europe/Istanbul 0 9 * * 1" },
  async ({ step }) => {
    const data = await step.run("fetch-data", async () => {
      return db.orders.findAll({ lastWeek: true });
    });

    const analysis = await step.run("ai-analysis", async () => {
      return llm.analyze(data, "Summarize weekly sales trends");
    });

    await step.run("send-notification", async () => {
      await slack.send("#reports", analysis);
    });
  },
);

Key differences between Inngest and traditional cron:

• Durable execution: Each step.run() result is persisted; on failure, only the failed step is re-executed
• Automatic retry: Default of 4 retries with exponential backoff
• Timezone support: Directly within the cron expression using TZ=Europe/Istanbul
• Event + time hybrid: Dynamic conditions such as “trigger if the user added an item to cart 2 hours ago but still has not purchased”

According to Inngest documentation, the free plan supports 50,000 function executions per month; TypeScript, Python and Go SDKs are officially supported.

Trigger.dev

Trigger.dev is an open-source platform for background tasks, AI agents and durable workflows. Version 4 went GA on August 18, 2025 as part of Launchweek 2, bringing warm start (100-300ms), waitpoints and run prioritization⁸:

export const dailyCleanup = schedules.task({
  id: "daily-cleanup",
  cron: "0 3 * * *",
  run: async (payload) => {
    await performCleanup();
  },
});

	Trigger.dev	Inngest
Architecture	Managed workers execute your code	Event-driven, calls your HTTP endpoints
Language support	TypeScript	TypeScript, Python, Go
Warm start	Yes (v4)	N/A (serverless)
GitHub stars (2026-05)	~15,100	~5,400

Upstash QStash

QStash is a serverless HTTP-based message queue and task scheduler⁹. It operates by sending HTTP requests to target URLs and provides retry, dead letter queue and scheduling support. The free plan includes 1,000 messages per day and 10 active schedules.

AI Agents and Scheduled Tasks

In 2019, cron jobs were simple triggers that “ran a script when the time came.” By 2026, they have become a heartbeat mechanism that manages the lifecycle of AI agents.

Heartbeat Pattern

Rather than running continuously, an agent is awakened by cron at specific intervals, performs its task and goes back to sleep. This approach provides significant cost savings¹⁰:

Every hour (cron) -> Agent wakes up -> Analyzes data -> Sends report -> Agent sleeps

Continuously running agent: 24/7 compute cost, idle waiting. Scheduled agent: Cost incurred only for execution time. Ideal for batch and periodic tasks.

MCP and Cron Integration

MCP (Model Context Protocol), standardized by Anthropic and donated on December 9, 2025 to the Agentic AI Foundation (AAIF) under the Linux Foundation, enables AI models to communicate with local files, databases, and tools.

In modern usage, a cron job no longer just runs a Python script; it triggers an MCP server to awaken an AI agent with a specific context:

Cron (every night at 00:00)
  -> Connect to database via MCP
  -> Fetch last 24 hours of sales data
  -> Send as context to LLM
  -> Issue "find anomalies" command
  -> Report results to Slack

Purpose-built MCP servers exist for this use case: mcp-cron can schedule shell commands or AI prompt tasks using cron expressions¹¹. scheduler-mcp can manage shell commands, API calls and AI tasks with cron, interval and date-based triggers.

Event + Time Hybrid Triggering

It is no longer limited to “run on Friday.” Conditional triggering is now possible:

"If stock drops below 10% (event)
 AND it is after 18:00 (time condition)
 -> Run the AI purchasing agent"

Inngest and Trigger.dev natively support this type of hybrid structure. The agent is triggered when the event occurs, but the time condition must also be satisfied.

Semantic Cron: A New Approach to Data Analytics

Modern cron workflows process data during transit rather than merely moving it:

• LLM-based data cleansing: Using AI to predict and populate missing category names in data fetched via cron
• Automated hypothesis testing: Weekly pivot table generation from e-commerce data, followed by asking an AI agent “Why is there a decline in this category compared to last week?” to generate hypotheses
• Token optimization: Sending pivoted and flag-annotated summary tables to AI instead of raw data, reducing costs and improving accuracy

Identity and Authorization Context

Identity management platforms such as Clerk and Auth0 connect to cron operations through webhooks:

• User maintenance: Tasks like “deactivate users who have not logged in for 30 days” are managed through scheduled functions triggered by Clerk webhooks
• Subscription management: Synchronization with payment systems such as Stripe or Paddle is performed through periodic tasks on edge services
• Token renewal: Periodic renewal of API tokens and certificate rotation

Cron in Gaming and Real-Time Systems

Cron jobs are used not only in data analytics and DevOps, but also in gaming and real-time systems:

• Energy replenishment: Refilling in-game energy systems at specified intervals
• Daily rewards: Reward mechanisms that reset each day
• Economy balancing: Periodic updates to in-game economy parameters
• Leaderboard updates: Recalculating ranking tables at defined intervals

These tasks are now managed through globally distributed cron triggers (Cloudflare Workers, AWS EventBridge) rather than a centralized server clock.

2026 Best Practices Guide

Simple Task (Classic Cron)

# Backup every night at 03:00
0 3 * * * /opt/scripts/backup.sh >> /var/log/backup.log 2>&1

Reliable Task (Inngest)

inngest.createFunction(
  { id: "nightly-backup", retries: 5 },
  { cron: "TZ=Europe/Istanbul 0 3 * * *" },
  async ({ step }) => {
    await step.run("backup", backupAndVerify);
    await step.run("notify", () => slack.send("Backup completed"));
  },
);

Edge Cron (Cloudflare Workers)

# wrangler.toml
[triggers]
crons = ["0 */6 * * *"]

Scenario-Based Recommendations

Scenario	Recommended Platform	Rationale
Simple script, VPS	crontab	No additional dependencies
Production server, Linux	systemd timers	Logging, resource control
Serverless, low cost	Cloudflare Workers Cron	Edge, pay as you go
Fault-tolerant workflow	Inngest / Trigger.dev	Durable execution, retry
Simple data fetching, free	GitHub Actions	Free on public repos
AWS ecosystem	EventBridge Scheduler	14M/month free
AI agent heartbeat	Inngest + MCP	Event + time, durable
E-commerce report pipeline	Inngest	Step-based, retry, Slack integration

Conclusion

Cron, as one of the cornerstones of Unix philosophy, has served for decades with the principle of “run it when the time comes.” However, in modern development workflows, this simple mechanism has been enriched with serverless platforms (Cloudflare Workers, Vercel), durable execution tools (Inngest, Trigger.dev) and event-driven architectures.

With the proliferation of AI agents, cron has moved beyond being a mere scheduler and has become the gearbox of autonomous agents. Cron tasks integrated with MCP servers provide agents with database and file access context, automating the cycle of data analysis, hypothesis generation and action.

In 2019, cron was a scheduler. In 2026, it is an orchestration tool within cloud architecture.

For tools commonly used with cron, see rsync, wget, and grep. For modern automation alternatives, see Pipedream.

Footnotes

1. cronie - Cron Daemon ↩
2. Linux Task Scheduling: cron vs systemd timers ↩
3. Cloudflare Workers Cron Triggers ↩
4. Vercel Cron Jobs ↩
5. GitHub Actions - Scheduled Events ↩
6. AWS EventBridge Scheduler ↩
7. Inngest - Scheduled Functions ↩
8. Trigger.dev v4 ↩
9. Upstash QStash ↩
10. Ambient Agents and Always-On Intelligence ↩
11. mcp-cron - MCP Server for Scheduled Tasks ↩

Key Takeaways

• 01 Cron jobs have evolved from server-dependent setups to serverless and event-driven architectures
• 02 systemd timers offer advantages over crontab in production environments, including logging, resource control and dependency management
• 03 Inngest and Trigger.dev provide fault-tolerant scheduled workflows through durable execution
• 04 For AI agents, cron has become a cost optimization tool through the heartbeat pattern
• 05 Cloudflare Workers Cron Triggers support 5 triggers on the free plan and 250 on paid plans

Frequently Asked Questions (FAQ)

+ What is the difference between systemd timers and crontab?

While crontab offers simple single-line scheduling, systemd timers provide full journald log integration, the ability to catch missed tasks with Persistent=true, resource control via cgroups, and dependency definitions on other service units. However, systemd only works on Linux, whereas crontab is available on BSD, macOS and all Unix systems.

+ What is serverless cron and why should it be preferred?

Serverless cron refers to cloud services that run scheduled tasks without requiring a dedicated server. Platforms such as Cloudflare Workers Cron Triggers, Vercel Cron Jobs and AWS EventBridge charge only for execution time and require no infrastructure management. They offer a pay-as-you-go model instead of fixed monthly server costs.

+ How do Inngest and Trigger.dev differ from traditional cron?

Traditional cron triggers a command and fails silently on errors. Inngest and Trigger.dev offer durable execution: each step's result is persisted, automatic retries occur on failure, and the workflow resumes from where it left off. In addition to time-based triggering, they also support event-driven triggering.

+ How do AI agents use cron jobs?

With the heartbeat pattern, AI agents are awakened by cron at specific intervals (for example, every hour), analyze data and go back to sleep. This approach provides significant cost savings compared to continuously running agents. MCP servers can be triggered via cron to provide agents with database and file access context.