Trigger.dev

Trigger.dev is an open-source, TypeScript-native platform for building and deploying background jobs, durable AI agents, and long-running workflows — without serverless timeouts or brittle queue infrastructure. We rate it 84/100 — the go-to choice for TypeScript developers who need reliable, observable, and scalable task execution for AI applications and automation pipelines.

What is Trigger.dev?

Trigger.dev was founded in 2022 by Matt Aitken and Eric Allam, and went through Y Combinator's W23 batch. The project grew out of frustration with existing background job solutions — Sidekiq requires Ruby, BullMQ needs Redis babysitting, and serverless platforms impose ruthless timeout limits. Trigger.dev's answer was a TypeScript-first platform that treats background jobs like regular code you write alongside your app, backed by a fully-managed cloud or a self-hosted runtime.

As of March 2026, the project has accumulated 14,300+ GitHub stars, is on v4.4.3 (released March 10, 2026), and has raised a $16M Series A. The pivot to AI workflows — giving LLM-based agents durable, resumable execution with human-in-the-loop checkpoints — has significantly expanded its appeal beyond pure backend jobs work.

Key Features of Trigger.dev

• No Timeouts: Trigger.dev runs tasks for as long as they need — unlike AWS Lambda (15-minute cap), Vercel Functions (5-minute cap), or Cloudflare Workers. A single AI pipeline processing a 500-page PDF can run for hours without issues.
• Durable Execution & Checkpointing: Tasks can be paused mid-execution and resumed from exactly where they left off, enabling long-running AI agents that survive server restarts, deployments, and transient failures.
• Human-in-the-Loop Workflows: Programmatically pause a workflow and wait for a human to approve, reject, or provide feedback before continuing — critical for AI agents that need oversight on sensitive actions.
• Automatic Retries with Backoff: Define retry policies in code. Failed tasks retry intelligently with configurable exponential backoff, preventing cascading failures under load.
• OpenTelemetry Observability: Every run generates a distributed trace viewable in real time in the dashboard. Prisma calls, fetch requests, and AI SDK calls are auto-instrumented — no manual spans needed.
• Fair Queuing & Concurrency Controls: Set per-task concurrency limits, rate limits per second/minute, and run-level priority. The queue is fairness-weighted so no single tenant or workflow starves others.
• Elastic Auto-Scaling: The managed cloud scales worker capacity to match queue depth automatically. On the Pro plan, you get 200+ concurrent runs with the ability to expand at $10/month per 50 additional.
• Realtime Streaming: Subscribe to a live task run from your frontend and stream AI-generated content directly to the user, bridging background execution with real-time UI updates.

What Users Say About Trigger.dev

The sentiment across Hacker News and Product Hunt is genuinely positive for a developer tool — which is hard to earn. The YC W23 Launch HN thread praised the "this is what background jobs should look like in 2025" framing, and multiple commenters noted it fills a real gap between BullMQ (raw and manual) and Temporal (powerful but operationally heavy). On Product Hunt, reviewers consistently call out the Discord community and team responsiveness as a standout: "amazing product, amazing team, they actually listen to feedback."

The main recurring criticism is around pricing predictability — the usage-based compute billing (charged per second of active execution) can be hard to estimate for bursty workloads. A secondary complaint is that the self-hosted version requires more ops knowledge than the docs suggest, and the documentation for advanced concurrency patterns lags behind the actual features available. Some users on Reddit's r/node also note that for very simple fire-and-forget jobs, the Trigger.dev SDK adds overhead compared to a basic BullMQ setup.

Trigger.dev Pricing

Trigger.dev uses a combination of flat monthly plans and usage-based compute billing. Your plan includes a monthly compute credit; additional usage is billed per second of execution time.

Plan	Price	Included Credits	Concurrent Runs	Log Retention
Free	$0/month	$5 compute credits	20	1 day
Hobby	$10/month	$10 compute credits	50	7 days
Pro	$50/month	$50 compute credits	200+	30 days
Enterprise	Custom	Custom	Custom	Custom (SOC 2)

Compute overage is billed at $0.0000338/second for the default Small 1x worker size, and $0.000025 per run invocation ($0.25 per 10,000 runs). The self-hosted version is free under Apache 2.0 — you pay only for your own infrastructure.

Who Should Use Trigger.dev?

Best for: TypeScript/Node.js developers building AI-powered applications, automation pipelines, multi-step data processing, or any backend workflows that involve waiting (for external APIs, human input, or time delays). Especially valuable for teams using Vercel, Netlify, or other serverless-first stacks who've hit timeout walls running AI inference or document processing.

Not ideal for: Teams running a Ruby, Python, or Go backend where language-native solutions (Sidekiq, Celery, Asynq) are better fits. Also not the right tool for simple fire-and-forget notifications where a basic message queue (SQS, BullMQ) is sufficient and cheaper at high volume.

Pros and Cons

Pros:

• Zero-timeout execution model solves the most painful serverless limitation for AI workloads
• TypeScript-native with excellent SDK ergonomics — tasks are just annotated async functions in your codebase
• OpenTelemetry-based observability out of the box — no separate APM tool needed for tracing background jobs
• Open source under Apache 2.0 with a self-hostable option — no vendor lock-in
• Active development: v4.4.3 released March 10, 2026 shows weekly release cadence
• YC-backed with $16M Series A; team is responsive and community is active on Discord (4,400+ members)

Cons:

• Usage-based billing (per second of compute) is hard to predict for bursty workloads
• Self-hosting is more operationally complex than the docs imply — not truly plug-and-play for non-DevOps teams
• No native support for non-TypeScript runtimes; Python task support is limited to subprocess execution
• Documentation for advanced patterns (multi-tenant concurrency, priority queues) lags behind the actual feature set

Alternatives to Trigger.dev

Temporal is the most feature-complete alternative — battle-tested at Stripe and Coinbase scale — but it requires significant operational overhead to self-host and has a steeper learning curve. Inngest is the closest direct competitor, also TypeScript-first with a managed cloud, but is closed-source and has less observability depth. BullMQ is a solid choice for pure Redis-backed queue needs in Node.js but lacks durable execution, human-in-the-loop, and first-class AI workflow features. For most TypeScript teams building in 2026, Trigger.dev sits in the sweet spot between BullMQ's simplicity and Temporal's power.

Verdict: Is Trigger.dev Worth It?

Yes — particularly for teams working on AI-heavy applications in TypeScript. Trigger.dev solves a genuine, painful problem (serverless timeout limits, unreliable retry logic, opaque background job failures) in a developer-friendly way. The free tier is genuinely useful for prototyping, and the $10/month Hobby plan covers most indie developer workloads. The rating of 84/100 reflects its excellent developer experience and growing AI capabilities, held back slightly by billing complexity and self-hosting friction.

Frequently Asked Questions

Is Trigger.dev free?

Yes. Trigger.dev has a free plan that includes $5 in monthly compute credits and 20 concurrent runs. Paid plans start at $10/month (Hobby). The self-hosted version is free under the Apache 2.0 license.

Is Trigger.dev open source?

Yes. The core runtime, SDK, and dashboard are open source under the Apache 2.0 license. The GitHub repo at github.com/triggerdotdev/trigger.dev has 14,300+ stars as of March 2026.

How does Trigger.dev compare to Inngest?

Both are TypeScript-first background job platforms with managed clouds. Trigger.dev is open source and self-hostable; Inngest is proprietary. Trigger.dev has more granular observability (OpenTelemetry-native) and better support for long-running AI agents. Inngest has a slightly simpler pricing model.

Can Trigger.dev run Python tasks?

Directly, no — Trigger.dev is TypeScript-native. However, you can spawn Python scripts as subprocesses within a TypeScript task. Native Python support is on the roadmap but not yet available as of v4.4.3.

What platforms does Trigger.dev support?

Trigger.dev runs as a managed cloud service (web-based) or self-hosted on any Linux server with Docker. The SDK works in Node.js environments (Vercel, Railway, Render, EC2, etc.).