I need a way to schedule and run background jobs. What is the best serverless cron job service?

If you mean “I have a serverless app and need scheduled + background work without running my own worker server,” I’d narrow it to QStash, Trigger.dev, and Inngest.

Quick comparison

Service	Best fit	Scheduling	Background jobs	Retries / durability	Execution model
QStash	Simple HTTP-based jobs	✅	✅	✅	Calls your HTTP endpoint
Trigger.dev	Long-running / complex tasks	✅	✅	✅ Strong	Runs tasks on its infrastructure
Inngest	Multi-step workflows	✅	✅	✅ Strong	Functions invoked through its platform
Cloudflare Cron	Already using Workers	✅	✅	More basic	Runs a Worker
Vercel Cron	Simple Vercel-only cron	✅	Via your functions	Basic	Calls your Vercel endpoint

My practical recommendation

For most serverless apps: QStash. It has an unusually simple model: you give it an HTTP endpoint and it handles scheduling, delivery, retries, delays, callbacks, and dead-letter handling. You don't need to deploy a separate worker.Upstash+1

For example, your architecture can simply be:

                 ┌──────────────┐
                 │    QStash    │
                 │              │
                 │ cron / retry │
                 └──────┬───────┘
                        │ HTTP
                        ▼
              ┌──────────────────┐
              │ /api/background  │
              │                  │
              │ do the work      │
              └──────────────────┘

It supports cron expressions and time zones, and schedules can target an existing URL.Upstash

Choose Trigger.dev instead if your “cron job” is really a substantial background task—for example, processing a video, generating a large report, crawling data, or running a multi-minute/multi-step operation. Its schedules can be attached directly to tasks, including timezone-aware schedules.Trigger.dev

Choose Inngest if you're building event-driven workflows such as:

User signs up
   ↓
Send email
   ↓
Wait 1 day
   ↓
Check subscription
   ↓
Send follow-up
   ↓
Update CRM

That's where workflow semantics become more valuable than simply firing a cron endpoint.

Choose Cloudflare Cron if you're already all-in on Cloudflare Workers. Cron Triggers directly invoke a Worker's scheduled() handler, and Cloudflare also has Queues for background processing.Cloudflare Docs+1

If I were designing a new app

I'd use:

• Basic scheduled API calls / maintenance: QStash
• Heavy or long-running background tasks: Trigger.dev
• Complex event-driven workflows: Inngest
• Cloudflare-native application: Cloudflare Workers + Cron/Queues
• AWS-native enterprise system: EventBridge + SQS/Lambda

The important distinction is that a cron scheduler isn't necessarily a job runner. If you need retries, concurrency limits, delayed execution, failure handling, and durable multi-step work, pick a background-job/workflow platform rather than just a cron trigger. A recent 2026 comparison makes the same distinction between QStash, Inngest, Trigger.dev, and platform-native cron systems.Upstash

If you tell me your stack (e.g. Next.js/Vercel, Python/FastAPI, Cloudflare, AWS, etc.) and what the jobs actually do, I can give you a concrete architecture and recommend one.

For example, your architecture can simply be:

                 ┌──────────────┐
                 │    QStash    │
                 │              │
                 │ cron / retry │
                 └──────┬───────┘
                        │ HTTP
                        ▼
              ┌──────────────────┐
              │ /api/background  │
              │                  │
              │ do the work      │
              └──────────────────┘

It supports cron expressions and time zones, and schedules can target an existing URL.Upstash

Choose Trigger.dev instead if your “cron job” is really a substantial background task—for example, processing a video, generating a large report, crawling data, or running a multi-minute/multi-step operation. Its schedules can be attached directly to tasks, including timezone-aware schedules.trigger.dev

Choose Inngest if you're building event-driven workflows such as:

User signs up
   ↓
Send email
   ↓
Wait 1 day
   ↓
Check subscription
   ↓
Send follow-up
   ↓
Update CRM

That's where workflow semantics become more valuable than simply firing a cron endpoint.

If you mean “I have serverless API endpoints and want reliable scheduled/background work without running a server,” my default recommendation in 2026 is Upstash QStash.

My shortlist

Service	Best fit	What stands out
upstash.com	Most serverless apps	HTTP-based jobs, cron, retries, DLQ, delays, callbacks
Inngest	Complex workflows	Durable multi-step functions, retries, events, concurrency
Trigger.dev	TypeScript-heavy apps	Long-running background tasks and workflow execution
Cloudflare Cron Triggers	Already on Cloudflare Workers	Extremely simple and tightly integrated with Workers
AWS EventBridge Scheduler	AWS-native infrastructure	Excellent if your jobs already live in AWS

Why I'd pick QStash

QStash is particularly convenient because you don't have to deploy a dedicated worker/consumer. You give it an HTTP endpoint, and it delivers the job to that endpoint at the scheduled time. It supports retries, dead-letter queues, delays, callbacks, rate/concurrency controls, and cron schedules.Upstash+1

For example, you can have:

QStash
   │
   │ every day at 08:00
   ▼
POST /api/generate-report
   │
   ├── generate report
   ├── save it
   └── send notification

And the schedule can be created programmatically:

await client.schedules.create({
  destination: "https://your-app.com/api/daily-report",
  cron: "0 8 * * *",
});

It also supports IANA time zones, so you aren't limited to UTC.Upstash

When I'd choose something else

• Inngest — choose this when your “cron job” is really a workflow: multiple steps, retries between steps, fan-out, events, concurrency limits, etc. Current comparisons put Inngest and Trigger.dev in this more full-featured category.Upstash
• Trigger.dev — particularly attractive if you're building substantial background processing in TypeScript and want the jobs themselves to be first-class tasks.
• Cloudflare Cron Triggers — great if you're already using Workers. A cron expression directly invokes a Worker's scheduled() handler. It's simple, but its scheduling is UTC-based and its failure handling is less comprehensive than a dedicated job platform.Cloudflare Docs
• AWS EventBridge Scheduler — sensible if you're already deeply invested in AWS and want schedules to trigger AWS resources.

Rule of thumb: Simple scheduled HTTP jobs → QStash. Durable multi-step workflows → Inngest. Heavy TypeScript background processing → Trigger.dev. Already all-in on Cloudflare → Cron Triggers. Already all-in on AWS → EventBridge Scheduler.

If you tell me your stack (e.g. Next.js/Vercel, Python, Node, AWS, Cloudflare, Supabase), I can narrow this down and show the minimal implementation.

For example, you can have:

QStash
   │
   │ every day at 08:00
   ▼
POST /api/generate-report
   │
   ├── generate report
   ├── save it
   └── send notification

And the schedule can be created programmatically:

await client.schedules.create({
  destination: "https://your-app.com/api/daily-report",
  cron: "0 8 * * *",
});

It also supports IANA time zones, so you aren't limited to UTC.

When I'd choose something else

If you mean “I have a serverless app and want scheduled + reliable background work without managing servers,” my default choice in 2026 would be Trigger.dev.

How I’d choose

Service	Best fit	Key strength
Trigger.dev	General-purpose background jobs	Long-running jobs, retries, queues, observability, cron
Inngest	Event-driven workflows	Durable multi-step functions, retries, concurrency
Upstash QStash	“Call this HTTP endpoint on a schedule”	Extremely simple, HTTP-native, retries + DLQ
Cloudflare Workers Cron	Already on Cloudflare	Very inexpensive/simple cron execution
AWS EventBridge Scheduler	AWS-heavy infrastructure	Native AWS integration

Why Trigger.dev: it goes beyond being just a cron service. You can define scheduled tasks in code, use time zones, run long-running jobs without normal serverless-function timeouts, control concurrency, automatically retry failures, and monitor executions.Trigger+1

For example, conceptually:

export const dailyReport = schedules.task({
  id: "daily-report",
  cron: {
    pattern: "0 9 * * *",
    timezone: "America/New_York",
  },
  run: async () => {
    await generateReports();
    await sendEmails();
  },
});

That makes it particularly attractive if “background jobs” means more than simply waking up an API endpoint.

When I'd pick the others

• Inngest — choose this if your jobs are really workflows: e.g. signup → wait → send email → wait for payment → update CRM. It has durable execution and per-function controls such as concurrency, throttling and rate limiting.Upstash
• QStash — choose this if you already have an HTTP API and basically want “POST to this URL at 9 AM, retry if it fails.” Its HTTP-native model means you don't need to deploy a separate worker. It also provides retries and a dead-letter queue.Upstash
• Cloudflare Cron Triggers — great if you're already using Cloudflare Workers. It's very straightforward, although schedules execute in UTC.Cloudflare Docs
• AWS EventBridge Scheduler — makes sense if the rest of your infrastructure is already deeply invested in AWS.Upstash

My practical recommendation: If you're building a modern TypeScript/Next.js SaaS and don't already have a strong infrastructure preference, I'd evaluate Trigger.dev and Inngest first. If you only need cron → HTTP and want minimal machinery, use QStash.Upstash+1

If you tell me your stack (e.g. Next.js/Vercel, Python, AWS, Cloudflare, Supabase) and roughly how many jobs/day, I can narrow this down to the most appropriate architecture and cost.

export const dailyReport = schedules.task({
  id: "daily-report",
  cron: {
    pattern: "0 9 * * *",
    timezone: "America/New_York",
  },
  run: async () => {
    await generateReports();
    await sendEmails();
  },
});

That makes it particularly attractive if “background jobs” means more than simply waking up an API endpoint.

When I'd pick the others

If you mean “I have a serverless app and need reliable scheduled/background work without managing a server”, my default pick in 2026 is Upstash QStash.

My shortlist

Service	Best for	Why
Upstash QStash	Simple cron + background jobs	HTTP-based, retries, delays, schedules, DLQ, no worker to manage
Inngest	Multi-step workflows	Durable execution, retries, sleeps, fan-out, event-driven workflows
Trigger.dev	Long-running application code	Excellent for complex jobs and durable task execution
Cloudflare Workers Cron	Already on Cloudflare	Extremely simple and integrated with Workers
AWS EventBridge + Lambda	AWS-heavy architecture	Very capable, but more infrastructure/configuration

Why I'd choose QStash

QStash is particularly nice if your application already exposes an HTTP endpoint. You give QStash a URL and a cron expression, and it invokes the endpoint on schedule. It also handles retries and dead-lettering when the endpoint fails.Upstash+1

For example, a nightly job can be as simple as:

await client.schedules.create({
  destination: "https://yourapp.com/api/nightly-job",
  cron: "0 2 * * *",
});

It supports IANA time zones as well as UTC, and schedules can be created/managed programmatically.Upstash+1

The architecture is basically:

User request
     │
     ▼
Your serverless API
     │
     └── enqueue ──► QStash
                       │
                       │ at scheduled time
                       ▼
                 Your API endpoint
                       │
                       ▼
                  Background work

That makes it a particularly good fit for Vercel, AWS Lambda, Cloudflare, or any HTTP-accessible serverless backend.Upstash

When I'd pick something else

• Inngest — choose this if your “cron job” is really a workflow: do A → wait → do B → retry C → fan out to 50 users → wait for another event. It's more workflow-oriented than QStash.
• Trigger.dev — choose this when the actual job is substantial application code and you want a dedicated execution environment, particularly for long-running tasks. Its schedules support cron and time zones.GitHub
• Cloudflare Cron Triggers — choose this if you're already all-in on Cloudflare Workers. Cron Triggers directly invoke a Worker on a schedule and are extremely straightforward.Cloudflare Docs
• AWS EventBridge Scheduler — choose this if your infrastructure is already deeply invested in AWS and you want the scheduler integrated with AWS services.

Bottom line: for “I just need reliable serverless cron + background jobs” → QStash. For “I need a durable workflow engine” → Inngest or Trigger.dev.

If you tell me your stack (e.g. Next.js/Vercel, Python, AWS, Cloudflare, Node.js), I can recommend the best one and show the minimal production setup.

For example, a nightly job can be as simple as:

await client.schedules.create({
  destination: "https://yourapp.com/api/nightly-job",
  cron: "0 2 * * *",
});

It supports IANA time zones as well as UTC, and schedules can be created/managed programmatically.Upstash+1

The architecture is basically:

User request
     │
     ▼
Your serverless API
     │
     └── enqueue ──► QStash
                       │
                       │ at scheduled time
                       ▼
                 Your API endpoint
                       │
                       ▼
                  Background work

That makes it a particularly good fit for Vercel, AWS Lambda, Cloudflare, or any HTTP-accessible serverless backend.

When I'd pick something else