Trigger.dev

What Trigger.dev actually is

Trigger.dev is an open-source platform for background jobs, durable workflows and AI agents, written for TypeScript teams. Tasks are plain TypeScript functions that live in a trigger folder in your repository; the CLI bundles them and deploys them to Trigger.dev's managed workers (or to your own infrastructure if you self-host). Once deployed, a task runs as long as it needs to — there is no serverless-style timeout ceiling — with automatic retries, queues, concurrency controls, OpenTelemetry traces and a dashboard for run history, log streaming and replay-from-failure.

The company behind it was founded in 2022 by Matt Aitken, Eric Allam, Dan Patel and James Ritchie in London (registered as API Hero Ltd / Trigger.dev Ltd), went through Y Combinator (W23), and raised a $3M seed followed by a $16M Series A. The product originally launched as a background-jobs framework and re-emerged at v3 with its own execution infrastructure — and, more recently, a clear AI-agent positioning: waitpoints let a task pause for human approval, checkpoints snapshot the process while it waits, and a Realtime API streams task progress and LLM tokens to a frontend.

The architectural idea worth understanding is checkpointing. When a task waits — for a subtask, a timer longer than about five seconds, or a human decision — the process is snapshotted and restored later, and the waiting time consumes neither compute billing nor a concurrency slot. That is what makes multi-hour agent loops, human-in-the-loop approvals and long media-processing pipelines economical instead of merely possible. It is also the honest core of the pitch: you are not paying for a machine to sit idle waiting on an API call.

Licensing: Trigger.dev is Apache 2.0 licensed (per their own pricing FAQ and self-hosting docs), with a Docker-based self-hosting path documented and the full source on GitHub — around 15K stars at the time of writing. One third-party listing calls it MIT-licensed; the vendor says Apache 2.0 and we go with the vendor.

Pricing: what you really pay

Trigger.dev Cloud uses a hybrid model: a flat monthly base that doubles as prepaid usage credit, plus per-second compute metering while tasks execute, plus a small per-run invocation fee ($0.000025 per run per third-party rate-card tracking). The published tiers: Free at $0 per month with $5 of monthly credits, 20 concurrent runs, unlimited tasks, 5 team members, 10 schedules, 1-day log retention and community support. Hobby at $10 per month with $10 of credits, 50 concurrent runs, 100 schedules, 7-day logs and up to 5 preview branches. Pro at $50 per month with $50 of credits, 200+ concurrent runs (extra in bundles of 50 at $10 per month), 25+ team members (then $20 per month per seat), 1,000+ schedules (then $10 per month per 1,000), 30-day logs, dedicated Slack support, AWS PrivateLink and a HIPAA BAA add-on at $500 per month. Enterprise is custom: RBAC, SSO, SOC 2 report, penetration-test report, custom log retention, priority support.

The compute rate card is fully published, which we like: Micro at 0.25 vCPU / 0.25 GB for $0.0000169 per second, Small 1x (0.5 vCPU / 0.5 GB, the default) at $0.0000338 per second, scaling through Medium and Large machines up to 8 vCPU / 16 GB at $0.0000680 per second. You are charged only while a task is executing. Converted to hourly, the default machine is about $0.12 per hour of actual task execution — competitive with raw VMs when tasks are bursty and idle time is the norm, expensive if your tasks are permanently CPU-saturated (in that case, a VM on /benchmarks will beat it).

Two pricing sharp edges, both from the plan tables themselves. First, Pro's overage rates stack: seats above 25 cost $20 each, and a large engineering org crosses into real money quickly. Second, the tier boundaries have cliffs — Hobby has no published Realtime-connection overage rate, so outgrowing it means jumping to Pro rather than paying for the increment. Third-party rate-card trackers report the meter has been stable since 2024 with no published price increases, and credit the open-source self-host escape hatch for keeping the cloud pricing honest. Self-hosting costs you your own Postgres and container infrastructure instead of a subscription.

Performance & infrastructure

Tasks run on isolated containers — each run in a fresh Node.js process on managed workers — with elastic scaling from zero to thousands of concurrent tasks. Queue sizes are generous but tiered (10,000 queued runs per production queue on Free, 250,000 on Hobby, 1,000,000 on Pro), and API rate limits sit at 1,500 requests per minute with increases available on paid plans. The docs note the correct pattern for bursts — batchTrigger() instead of triggering in a loop — which tells you the platform is designed around fan-out workloads.

We have not benchmarked Trigger.dev — it is not in our 2026-04-01 VM test set, and job-runner throughput is workload-shaped enough that cross-tool numbers would mislead. What we can assess is the operational design: versioned atomic deploys (in-flight runs are not disturbed by code changes), per-tenant concurrency keys, waits that do not bill, and OpenTelemetry on every run. One third-party 2026 review documents a real-world deployment running 20-30 minute PDF-generation tasks on Pro at $50 per month, and reports the predictable failure mode: a burst of 200 concurrent renders queued for about five minutes until per-customer concurrency limits were set. That matches the architecture — concurrency is a dial, not a guarantee, and the defaults assume politeness.

On reliability posture: durable checkpointing means a crash or redeploy resumes a task rather than losing it, which for long workflows is the difference between a retry policy and an actual guarantee. The platform is young (v3 in 2025, Run Engine 2 and v4 GA in 2025 per third-party timelines) and there is no published uptime SLA on the cloud plans — Enterprise adds contractual terms. We score the track record as promising and recent, not battle-tested over a decade.

Where it falls short

This is a developer tool with a TypeScript/Node-shaped center of gravity. There is no no-code surface, the task SDK assumes you are comfortable in a codebase and a CLI, and non-TypeScript runtimes are not the point. If your team is Python-first, the self-hosted engine may still be useful, but the DX you read about in reviews is not what you will experience.

Second, the tier cliffs and overage stacking are real budget traps for growing teams — seats, schedules, preview branches, dashboards and Realtime connections are all metered add-ons above Pro's ceilings, and Hobby's missing overage path forces plan jumps. Read the limits page before you model costs; note also that the docs' concurrency numbers (10/25/100+ in one place) lag the pricing page (20/50/200+), so quote the pricing page.

Third, vendor risk. A 2022-founded, venture-backed dev-tools company is a going-concern question, mitigated substantially — more than most — by the Apache 2.0 license and documented self-hosting. If Trigger.dev the company disappeared tomorrow, you could run the engine yourself. What you would lose is the managed worker fleet, the hosted dashboard and the roadmap features gated to Enterprise (SOC 2 report, SSO, RBAC, pentest report are all paid-tier items — compliance features behind the sales call).

Finally, the platform's own identity is shifting — background jobs to AI agents to durable execution. That is driven by real capability (waitpoints and checkpointing fit agent workloads), but it means some documentation and community content describes different generations of the product. Pin the SDK version and read the current docs, not the blog posts.

Who should pick this

Our pick for TypeScript teams whose work does not fit inside a serverless timeout: AI agent loops with human approval steps, LLM chains with retries, media and document processing, multi-step onboarding and email sequences, and multi-tenant SaaS background work with per-tenant concurrency. The combination of no-timeout execution, free waits and code-first tasks is exactly what we would reach for when a Vercel-style function ceiling is the binding constraint.

We would also seriously consider self-hosting it as an internal job runner — the license permits it and the feature surface is the same engine. We would not pick it for permanently saturating compute (a VM plus a queue is cheaper — see /benchmarks), for non-TypeScript teams without a migration plan, or for workloads where an on-premises deployment with vendor-locked support is a hard requirement. For the category context see /category/serverless-platforms.

Key takeaways

• Open-source (Apache 2.0) TypeScript background jobs and durable workflows platform, founded 2022 in London, YC W23; self-hostable via Docker or run on Trigger.dev Cloud.
• No timeouts on tasks, with checkpointed waits that cost neither compute nor a concurrency slot — the core economic feature.
• Published pricing: Free $0 ($5 credits), Hobby $10, Pro $50 monthly bases that double as usage credits, plus per-second compute ($0.0000169-$0.000068 per second by machine size) and a $0.000025 per-run fee.
• Pro overages stack (seats $20/month each above 25, bundles of 50 concurrent runs at $10/month); Hobby forces a jump to Pro rather than selling increments.
• Enterprise gates SOC 2 report, SSO, RBAC, penetration-test report and custom data residency; no published uptime SLA on cloud plans.
• Young vendor, shifting product identity (jobs → agents → durable execution), with the open-source escape hatch as the main lock-in hedge.

Sources

• https://trigger.dev/pricing
• https://trigger.dev/blog/v3-open-access
• https://trigger.mintlify.app/limits
• https://www.usagepricing.com/blueprint/trigger-dev
• https://apis.io/plans/trigger-dev/trigger-dev-plans-pricing
• https://agenticlist.ai/agent/trigger-dev
• https://automationatlas.io/answers/trigger-dev-review-2026
• https://runany.dev/blog/trigger-dev-open-source-ai-workflows
• https://ycombinator.com/companies/trigger-dev