Nov 17, 202611 min read

Inngest Alternatives in 2026: Background Jobs and Durable Functions Compared

The main alternatives to Inngest for background jobs, scheduled work and durable workflows, how they compare on execution model, hosting and pricing, and how to run queues and cron jobs in your own AWS or GCP account.

Illustration for Inngest Alternatives in 2026: Background Jobs and Durable Functions Compared

Inngest lets you write background jobs as functions in your own codebase, triggered by events or cron schedules, and wraps each piece of work in step.run so a failed step retries on its own while the finished ones are not run again. Steps like step.sleep and step.waitForEvent let one function pause for days, and Inngest calls back into your app over HTTP to run each step.

That model gets expensive and indirect when most of your jobs are single steps that only need a retry, since every run and step is billed as an execution, when the job runner sits outside the AWS or GCP account where the rest of the backend and its data live, or when the workflow engine is one more service to learn for work a queue would cover. This guide compares the main Inngest alternatives on execution model, hosting and pricing, and shows how Encore runs queues with retries and cron jobs in your own cloud account from Go code.

Inngest alternatives at a glance

ModelWhere your code runsDurable steps and long sleepsPricing modelBest for
EncorePub/Sub subscriptions with retries, cron jobsYour AWS or GCP accountNostate lives in your databaseYour cloud billBackground jobs and schedules next to your services
Trigger.devDurable tasks with waitsTrigger.dev's managed workers, or self-hostedYesPer run plus compute per secondTypeScript jobs that run for minutes or hours
TemporalDurable workflows with event historyYour workers, with Temporal Cloud or a self-hosted clusterYeswith replayPer action on Temporal CloudLong-running, business-critical workflows
AWS Step FunctionsState machines in JSONLambda, ECS and AWS services in your accountYesup to a yearPer state transitionOrchestrating AWS services
HatchetDurable tasks on PostgresYour workersYesPer run after 1 million freeTeams that want a Postgres-backed task queue with workflows
BullMQRedis job queueYour workersNoYour Redis billNode.js job queues on Redis
InngestEvent-driven durable functionsYour app, called over HTTP, or connected workersYesPer executionStep functions inside a serverless app

Inngest prices are from its pricing page, checked November 17, 2026: the Free plan includes 50,000 executions and 5 concurrent steps a month, Pro starts at $99 a month with 1 million executions and then $50 per million, and Business starts at $499 with 10 million.

1. Encore

Encore

Encore is a backend framework with built-in infrastructure for Go and TypeScript, and for background work it gives you Pub/Sub topics and subscriptions with retry policies and dead-letter queues, plus cron jobs, declared in the same code as the services that use them. On AWS a topic becomes SNS with an SQS queue per subscription, on GCP it becomes Pub/Sub, and cron jobs are managed by the Encore platform with no extra cloud resources. Encore is not a durable workflow engine: there is no step.run, no sleep that survives a deploy and no replay, so a multi-step flow keeps its progress in your database and moves forward through events and schedules.

Set up the app

Get started
brew install encoredev/tap/encore &&
encore app create
Copy

Run in your terminal to get started locally.

~
$ encore app create onboarding --example=hello-world$ cd onboarding && mkdir -p trials/migrations

A common Inngest function sends a welcome email when a trial starts, sleeps for 11 days and then sends a reminder. Here the trial's progress lives in a table, with a column per email that doubles as the idempotency claim:

-- trials/migrations/1_create_accounts.up.sql CREATE TABLE accounts ( id BIGSERIAL PRIMARY KEY, email TEXT NOT NULL UNIQUE, trial_ends_at TIMESTAMPTZ NOT NULL, welcomed_at TIMESTAMPTZ, reminder_queued_at TIMESTAMPTZ, reminded_at TIMESTAMPTZ ); CREATE INDEX accounts_trial_reminder ON accounts (trial_ends_at) WHERE reminder_queued_at IS NULL;

The welcome email goes through a subscription, and an hourly cron job takes the place of the 11-day sleep by finding trials that end within three days:

// trials/trials.go package trials import ( "context" "errors" "strings" "time" "encore.dev/beta/errs" "encore.dev/cron" "encore.dev/pubsub" "encore.dev/rlog" "encore.dev/storage/sqldb" "encore.dev/storage/sqldb/sqlerr" ) // RDS on AWS, Cloud SQL on GCP, started locally by `encore run`. var db = sqldb.NewDatabase("trials", sqldb.DatabaseConfig{ Migrations: "./migrations", }) type AccountEvent struct { AccountID int64 } // Each event becomes a topic: SNS/SQS on AWS, Pub/Sub on GCP. var TrialStarted = pubsub.NewTopic[*AccountEvent]("trial-started", pubsub.TopicConfig{ DeliveryGuarantee: pubsub.AtLeastOnce, }) var TrialEnding = pubsub.NewTopic[*AccountEvent]("trial-ending", pubsub.TopicConfig{ DeliveryGuarantee: pubsub.AtLeastOnce, }) type StartParams struct { Email string `json:"email"` } type StartResponse struct { AccountID int64 `json:"account_id"` TrialEndsAt time.Time `json:"trial_ends_at"` } //encore:api public method=POST path=/trials func Start(ctx context.Context, p *StartParams) (*StartResponse, error) { email := strings.ToLower(strings.TrimSpace(p.Email)) if !strings.Contains(email, "@") { return nil, &errs.Error{Code: errs.InvalidArgument, Message: "valid email required"} } var r StartResponse err := db.QueryRow(ctx, ` INSERT INTO accounts (email, trial_ends_at) VALUES ($1, now() + interval '14 days') RETURNING id, trial_ends_at`, email).Scan(&r.AccountID, &r.TrialEndsAt) if sqldb.ErrCode(err) == sqlerr.UniqueViolation { return nil, &errs.Error{Code: errs.AlreadyExists, Message: "account already exists"} } else if err != nil { return nil, err } if _, err := TrialStarted.Publish(ctx, &AccountEvent{AccountID: r.AccountID}); err != nil { return nil, err } return &r, nil } // A failed handler is retried with backoff, then moved to a dead-letter queue. var _ = pubsub.NewSubscription(TrialStarted, "send-welcome", pubsub.SubscriptionConfig[*AccountEvent]{ Handler: func(ctx context.Context, e *AccountEvent) error { return sendOnce(ctx, claimWelcome, e.AccountID, "welcome") }, RetryPolicy: &pubsub.RetryPolicy{MinBackoff: 10 * time.Second, MaxBackoff: 10 * time.Minute, MaxRetries: 20}, }) var _ = pubsub.NewSubscription(TrialEnding, "send-reminder", pubsub.SubscriptionConfig[*AccountEvent]{ Handler: func(ctx context.Context, e *AccountEvent) error { return sendOnce(ctx, claimReminder, e.AccountID, "trial-ending") }, RetryPolicy: &pubsub.RetryPolicy{MinBackoff: 10 * time.Second, MaxBackoff: 10 * time.Minute, MaxRetries: 20}, }) // The hourly job replaces a step that sleeps for 11 days: it finds trials // ending within 3 days and publishes one reminder event for each. var _ = cron.NewJob("queue-trial-reminders", cron.JobConfig{ Title: "Queue reminders for trials ending in 3 days", Every: 1 * cron.Hour, Endpoint: QueueReminders, }) //encore:api private func QueueReminders(ctx context.Context) error { rows, err := db.Query(ctx, ` SELECT id FROM accounts WHERE reminder_queued_at IS NULL AND trial_ends_at <= now() + interval '3 days' AND trial_ends_at > now()`) if err != nil { return err } var ids []int64 for rows.Next() { var id int64 if err := rows.Scan(&id); err != nil { rows.Close() return err } ids = append(ids, id) } rows.Close() if err := rows.Err(); err != nil { return err } // Publish first, then mark: a crash in between republishes on the next // run, and the subscriber's claim drops the duplicate. for _, id := range ids { if _, err := TrialEnding.Publish(ctx, &AccountEvent{AccountID: id}); err != nil { return err } if _, err := db.Exec(ctx, `UPDATE accounts SET reminder_queued_at = now() WHERE id = $1`, id); err != nil { return err } } return nil } const ( claimWelcome = `UPDATE accounts SET welcomed_at = now() WHERE id = $1 AND welcomed_at IS NULL RETURNING email` claimReminder = `UPDATE accounts SET reminded_at = now() WHERE id = $1 AND reminded_at IS NULL RETURNING email` ) // sendOnce claims the email with a conditional UPDATE, so a redelivered // message does not send it twice. func sendOnce(ctx context.Context, claim string, accountID int64, template string) error { var email string err := db.QueryRow(ctx, claim, accountID).Scan(&email) if errors.Is(err, sqldb.ErrNoRows) { return nil // already sent } else if err != nil { return err } rlog.Info("send email", "to", email, "template", template) return nil }
~/onboarding
$ encore run$ curl -X POST localhost:4000/trials -d '{"email":"ada@acme.dev"}'{"account_id": 1, "trial_ends_at": "2026-12-01T08:22:26.542Z"}

encore run starts Postgres and delivers the trial-started message locally, so the welcome email is logged a moment after the request, and a second signup with the same email gets already_exists. A handler that returns an error is retried with backoff between 10 seconds and 10 minutes and moved to the subscription's dead-letter queue after 20 attempts. Each claim is a conditional UPDATE that returns a row only once, which was checked against Postgres 17, so a redelivered message or a cron run that republishes after a crash does not send a second email. Cron jobs do not run locally, so you call QueueReminders from the local development dashboard to test the reminder path.

The trade-off against Inngest is explicit state: the 11-day wait is a timestamp and an hourly query rather than a paused function, which is less code to read in the function but easy to inspect, change and backfill with SQL. On AWS the deploy creates the SNS topics, an SQS queue and dead-letter queue per subscription, and an IAM role for the service, as the AWS infrastructure docs describe. An AI coding agent adding a third email writes the column, the subscription and the publish call in one change and runs the flow locally before it ships.

Best fit: backend jobs that are mostly retries, fan-out and schedules, where you want the queues and cron jobs in your own AWS or GCP account next to the services that publish to them.

2. Trigger.dev

Trigger.dev runs long-running TypeScript tasks with retries, waits and queues, with no timeouts on its managed workers, and is open source under Apache 2.0 so you can self-host it. Tasks are deployed to Trigger.dev and run on its machines, billed per second of compute plus $0.25 per 10,000 runs, with a Free plan that includes $5 of monthly usage, Hobby at $10 and Pro at $50 a month, from its pricing page checked November 17, 2026.

Compared with Inngest, your task code runs on Trigger.dev's workers rather than inside your own app, which suits CPU-heavy or long jobs such as video processing or AI agent runs, and means database access from tasks crosses the network unless you self-host or use AWS PrivateLink on Pro.

Best fit: TypeScript teams with long-running or compute-heavy jobs that do not fit in a request.

3. Temporal

Temporal is the open source durable execution engine built by the creators of Uber's Cadence: workflows are code that the Temporal service records as an event history, so a workflow can wait for months, survive deploys and resume exactly where it stopped by replaying that history on your workers. Temporal Cloud bills per action, starting at $50 per million actions with $150 of free credits for 90 days, and the open source server can be self-hosted on Postgres, MySQL or Cassandra.

The model gives the most control of the options here and is also the most demanding, since workflow code must be deterministic, versioning changes to running workflows takes care, and you run the workers yourself.

Best fit: long-running, business-critical workflows such as payments, provisioning and order fulfilment that must never lose their place.

4. AWS Step Functions

Step Functions orchestrates Lambda functions, ECS tasks and over two hundred AWS service integrations as state machines defined in Amazon States Language, a JSON format, or drawn in Workflow Studio. Standard workflows can run for up to a year with exactly-once workflow execution, and Express workflows trade that for high-volume, short runs, as the workflow type comparison explains. Standard workflows cost $0.025 per 1,000 state transitions in us-east-1 after a free tier of 4,000 a month, and every retry counts as a transition, according to the pricing page.

Everything runs in your AWS account, though the workflow logic lives in JSON rather than in your application code, and local testing needs the Step Functions Local tooling or a deployed stack.

Best fit: teams on AWS orchestrating several AWS services, where a visual state machine is easier to review than code.

5. Hatchet

Hatchet is an open source task queue and workflow engine built on Postgres, with durable tasks, DAG-style workflows, concurrency limits, rate limits and a dashboard. Hatchet Cloud includes 1 million task runs and 1 million events a month, then bills $30 per million runs and $5 per million events, from its pricing page checked November 17, 2026, and the engine can be self-hosted.

Workers run in your own infrastructure and connect to Hatchet to receive tasks, so the code stays next to your database while Hatchet handles scheduling and retries.

Best fit: teams that want durable tasks and workflows with workers in their own infrastructure and a Postgres-backed engine.

6. BullMQ

BullMQ is a widely used Redis-backed job queue for Node.js, with retries, delayed jobs, repeatable jobs on a cron pattern, rate limiting and parent-child job flows. It costs nothing beyond the Redis instance and the workers you run, and jobs stay in your infrastructure.

It is a queue rather than a durable function engine, so a multi-step flow is a chain of jobs with state you track yourself, and Redis needs persistence and memory headroom configured with care, since an evicted key is a lost job.

Best fit: Node.js apps that already run Redis and want a job queue under their own control.

How to choose

Stay on Inngest if your jobs are multi-step functions with sleeps and waits, and running them through your app over HTTP fits your setup. Pick Temporal for long-running workflows that must resume exactly after any failure, Trigger.dev for long or compute-heavy TypeScript tasks, Step Functions to orchestrate AWS services, and Hatchet for durable tasks with your own workers on Postgres. Pick BullMQ for a Redis job queue in a Node.js app. Pick Encore when most of the work is retries, fan-out and schedules, and you want the topics, subscriptions and cron jobs declared next to your services and running in your own AWS or GCP account, with the SQS delivery guarantees handled by idempotent handlers like the ones above.

Frequently asked questions

What is the best alternative to Inngest?

For durable multi-step workflows with sleeps, waits and replay, Temporal and Trigger.dev are the closest alternatives, and AWS Step Functions fits teams that want a managed workflow service inside AWS. For background jobs that are mostly retries, fan-out and schedules, queues and cron jobs in your own cloud cover the work, for example BullMQ on Redis, or SNS, SQS and EventBridge on AWS.

Do I need a durable workflow engine for background jobs?

Often a queue is enough: sending emails, processing webhooks, resizing images and syncing data on a schedule are usually single steps that need retries and a dead-letter queue, which a queue and a cron job handle. A workflow engine earns its place when one run has many steps that must resume exactly where they stopped, wait days for a signal, or be replayed from history.

How much does Inngest cost?

Inngest's Free plan includes 50,000 executions a month, Pro starts at $99 a month with 1 million executions and then $50 per additional million, and Business starts at $499 a month with 10 million, from its pricing page checked November 17, 2026. Each function run and each step counts as an execution.

How do I run background jobs with retries and scheduled tasks on AWS without a workflow service?

With Encore you declare a topic with pubsub.NewTopic, handle it with pubsub.NewSubscription and a RetryPolicy, and schedule recurring work with cron.NewJob in Go. encore run delivers messages locally, and on AWS Encore provisions SNS and SQS with a dead-letter queue for each subscription, while cron jobs are managed by the Encore platform.

Deploy to your cloud on AWS and Google Cloud
without managing infrastructure

Encore lets developers and agents define application infrastructure directly in code, then automatically provisions it from local development to production in your AWS or GCP account.

~/orders — claude
Claude Code
Claude Code v2.1.180Opus 5.5~/orders