Skip to content
Search

Hatchet

lastmod 2026-02-16created 2025-04-083 edits

🪓 Run Background Tasks at Scale

A task orchestration platform built on Postgres

About

  • Open-source platform for large-scale background task processing, built on Postgres
  • Distributed Task Queue and workflow orchestration platform
  • Supports complex task workflows, failure recovery, scheduling, event-based triggers, and real-time monitoring
  • Provides Python, Go, and TypeScript SDKs
  • MIT license; self-hosted and cloud versions available

Key features summary

  • Queue management
    • Durable queue system built on Postgres
      • Key-based queuing (implements fair task distribution)
      • Rate limiting
      • Sticky Assignment and Worker Affinity
    • Automatic handling of task distribution, retries, and failure alerts
    • Python / TypeScript / Go examples provided
  • Task orchestration
    • DAG-based workflow composition
      • Conditional execution (e.g., sleep, event-based triggers, conditional execution based on parent task output)
      • Can handle complex branching logic
    • Define dependencies between tasks, run multiple tasks in parallel
    • Durable tasks support saving and recovering intermediate results
      • Durable function execution: caches intermediate state on failure and restores it on re-run
      • Also supports Durable Sleep and Durable Events
  • Flow Control
    • Per-user concurrency limits
    • Global and dynamic Rate Limiting
    • System stability through strategic task distribution
  • Task scheduling
    • Supports cron jobs, scheduled runs, and durable sleep
    • e.g., run daily at midnight, schedule for a specific time, wait for a set duration
  • Task routing
    • Sticky Assignment: pin tasks to the same worker
    • Worker Affinity: applies logic to pick the optimal worker
  • Event-based triggers
    • Can run tasks after receiving external events
    • Event/sleep conditions can be combined
  • Real-time web UI
    • Real-time dashboard and monitoring
    • View task logs, configure alerts (Slack/email)

When should you use Hatchet?

  • ✅ When you need DAG-based workflow composition
  • ✅ When retries and state preservation on task failure matter
  • ✅ Distributed task processing for applications with many users
  • ❌ When you only need a simple queue that can be set up quickly (Celery/BullMQ etc. recommended)
  • ❌ When a wide range of data connectors and integrations matters (Airflow/Prefect etc. recommended)

Comparison: Hatchet vs other solutions

  • Hatchet vs Temporal
    • Hatchet supports queues + DAG + Durable Execution
    • Temporal is optimized for Durable Execution
    • Hatchet is easy to self-host (only Postgres required)
  • Hatchet vs BullMQ / Celery
    • Hatchet has built-in task history storage + UI visualization + orchestration
    • BullMQ/Celery are lightweight queue libraries but lack monitoring features
  • Hatchet vs Airflow / Prefect
    • Hatchet offers fast execution, low latency, and its own worker management
    • Airflow/Prefect focus on data pipelines, with strength in integration connectors

Summary

  • Hatchet is a modern distributed task processing platform that runs on Postgres alone
  • Lets you build a Durable, Observable, Composable task system with a single tool
  • Supports both cloud and self-hosting; easy to integrate with Python/Go/TypeScript

See also

Favorite site

author Zer0 sitemap