Hosted Job Queue Platforms for Background Tasks

This post was written by an engineer at QueryPlane. QueryPlane is an app builder for your database: bring your own postgres db and you can create interactive applications to share with other developers, coworkers or even your customers. If you’re interested in trying it out, get started here.

---

Background job processing is essential for modern applications—sending emails, processing uploads, syncing data, running ML inference. While you can build a job queue with PostgreSQL, hosted platforms offer managed infrastructure, built-in observability, and advanced features like workflow orchestration.

This post covers the top hosted job queue platforms, from developer-focused tools to enterprise solutions.

In this post, we’ll cover:

• Hatchet - High-throughput task orchestration
• Inngest - Event-driven serverless workflows
• Trigger.dev - TypeScript-first background jobs
• Temporal - Enterprise workflow orchestration
• Cloud-native options - AWS Step Functions, Google Cloud Tasks

Hatchet

Hatchet is an open-source task queue focused on scale, reliability, and developer experience. Founded by Alexander Belanger and Gabriel Ruttner (both ex-CTOs from YC-backed companies), it’s designed for teams facing scaling challenges with their background job infrastructure.

Hatchet delivers sub-20ms task start times and handles over 200 million tasks per month on their cloud. The platform provides flow control through concurrency limits and rate limiting on a per-user, per-tenant, and per-queue basis. Tasks are durable and survive worker restarts and infrastructure failures. SDKs are available for Python, TypeScript, and Go. A real-time dashboard lets you monitor tasks, workflows, and queues with live updates.

Workflow support

Hatchet supports chaining tasks into workflows with dependencies:

const workflow = hatchet.workflow({ name: 'process-order' });

const validate = workflow.task({ name: 'validate', fn: validateOrder });
const charge = workflow.task({ name: 'charge', fn: chargePayment, parents: [validate] });
workflow.task({ name: 'fulfill', fn: fulfillOrder, parents: [charge] });

Pricing

Tier	Cost	Task runs/sec	Daily runs	Workers
Free	$0/mo	10	2,000	1
Starter	$180/mo	100	20,000	50
Growth	$425/mo	500	100,000	200
Enterprise	Custom	500-10k	Custom	Custom

Hatchet is fully open-source and can be self-hosted.

Inngest

Inngest is an event-driven platform that eliminates the need to manage queues or workers. Founded by Tony Holdstock-Brown (CEO) and Dan Farrelly (CTO, formerly CTO at Buffer), everything in Inngest is triggered by events, making it serverless-first.

The core philosophy removes traditional queue management entirely—events trigger functions directly without workers to deploy. It runs natively on Vercel, Netlify, and AWS Lambda without additional infrastructure. Retries are automatic with configurable backoff. Complex jobs can be broken into durable steps that survive failures. Branch environments are created automatically for development and staging.

Event-driven model

Instead of pushing jobs to a queue, you emit events and Inngest routes them to functions:

inngest.createFunction(
  { id: 'send-welcome-email', triggers: { event: 'user/signed.up' } },
  async ({ event, step }) => {
    await step.run('send-email', async () => {
      await sendEmail(event.data.email, 'Welcome!');
    });
  }
);

Pricing

Tier	Cost	Executions/mo	Concurrent steps
Hobby	$0/mo	50,000	5
Pro	$75/mo+	1,000,000+	100+
Enterprise	Custom	Custom	500-50,000

Pay-as-you-go pricing starts at $0.00005 per execution with volume discounts.

Trigger.dev

Trigger.dev is a TypeScript-first platform for background jobs and AI workflows. Its checkpoint-resume system handles long-running tasks on serverless platforms that would otherwise hit timeout limits.

The platform enables long-running tasks by checkpointing state and resuming past serverless timeouts. Workers scale elastically based on workload. Built-in observability includes logs, traces, and real-time monitoring. It’s designed for LLM orchestration and agent workflows. You can deploy workers on Kubernetes, Railway, Render, ECS, or any container platform.

Checkpoint-Resume

Trigger.dev’s standout feature handles serverless timeout limits:

export const processVideo = task({
  id: 'process-video',
  run: async (payload) => {
    // Long-running FFmpeg operation
    // Automatically checkpoints and resumes if it exceeds timeout
    await transcodeVideo(payload.videoUrl);
    await generateThumbnails(payload.videoUrl);
    await updateDatabase(payload.videoId);
  },
});

Pricing

Tier	Cost	Concurrent runs	Log retention
Free	$0/mo	20	1 day
Hobby	$10/mo	50	7 days
Pro	$50/mo	200+	30 days
Enterprise	Custom	Custom	Custom

Compute is charged per-second based on machine size ($0.000017-$0.00068/sec).

Temporal

Temporal is an enterprise-grade workflow orchestration platform. It’s the most powerful option but has a steeper learning curve.

Temporal workflows are durable and survive any failure—crashes, restarts, deploys. The platform supports multiple languages including Java, Go, Python, TypeScript, PHP, and .NET. It handles complex workflow patterns like sagas, compensations, and long-running processes that span days or weeks. Every workflow execution has full visibility into its history. The platform is battle-tested and used by Snap, Netflix, Stripe, and many large enterprises.

Workflow model

Temporal workflows are deterministic functions:

import { proxyActivities } from '@temporalio/workflow';
import type * as activities from './activities';

const { validateOrder, chargePayment, fulfillOrder, refundPayment } =
  proxyActivities<typeof activities>({ startToCloseTimeout: '1 minute' });

export async function orderWorkflow(orderId: string): Promise<void> {
  const order = await validateOrder(orderId);

  try {
    await chargePayment(order);
    await fulfillOrder(order);
  } catch (error) {
    // Automatic compensation on failure
    await refundPayment(order);
    throw error;
  }
}

When to choose Temporal

Temporal excels at complex, long-running workflows that span days or weeks. It’s well-suited for mission-critical processes requiring guaranteed completion and teams with engineering resources to manage the learning curve. Choose Temporal when you need multi-language worker support across a large organization.

Temporal offers both self-hosted (open-source) and Temporal Cloud (managed) options.

Cloud-native options

AWS Step Functions

Step Functions is AWS’s native workflow service. It integrates deeply with Lambda, DynamoDB, S3, SQS, and over 200 AWS services. A visual workflow designer lets you build workflows directly in the console. Pricing is $0.025 per 1,000 state transitions, with Express workflows available for high-volume, short-duration workloads at lower cost.

Best for teams already invested in AWS infrastructure who want tight integration with their existing services.

Google Cloud Tasks

Cloud Tasks handles distributed task execution on GCP. It dispatches HTTP requests to any endpoint with configurable rate limiting and automatic retries. App Engine handlers get first-class support. Pricing is based on operations at $0.40 per million.

Comparison

Platform	Best for	Latency	Pricing model
Hatchet	High-throughput task queues	<20ms	Per task run
Inngest	Serverless event-driven apps	Seconds	Per execution
Trigger.dev	TypeScript/AI workflows	Seconds	Per compute second
Temporal	Complex enterprise workflows	Seconds	Per action (Cloud)
Step Functions	AWS-native applications	Seconds	Per transition
Cloud Tasks	GCP HTTP dispatch	Seconds	Per operation

Choosing a platform

Choose Hatchet if you need high throughput with sub-second latency and want the option to self-host.

Choose Inngest if you’re building serverless applications and want to avoid managing queue infrastructure entirely.

Choose Trigger.dev if you’re building TypeScript applications, especially AI/LLM workflows, and need long-running task support on serverless.

Choose Temporal if you have complex, mission-critical workflows and the engineering resources to invest in the platform.

Choose cloud-native options if you’re committed to AWS or GCP and want tight integration with your existing infrastructure.

When to build your own

Hosted platforms add cost and external dependencies. Consider building a PostgreSQL-based queue if your throughput is modest (under 1,000 jobs per minute), you want to minimize external dependencies, you need deep integration with your existing PostgreSQL data, or budget is a primary constraint.

Many successful companies run PostgreSQL job queues in production—RudderStack handles 100k events/second with this approach.

Wrapping up

Hosted job queue platforms reduce operational burden and provide features that are difficult to build yourself: elastic scaling, built-in observability, and durable execution. The right choice depends on your language preferences, throughput requirements, and how much infrastructure you want to manage.

For most teams, starting with a platform like Inngest or Trigger.dev provides a good balance of simplicity and power. As needs grow, you can evaluate whether to migrate to more specialized solutions like Temporal or Hatchet.