Task orchestration is a problem every backend engineer faces: how do you reliably execute background jobs and complex workflows without losing data or crashing under load? Hatchet takes a different path by building a durable task queue and workflow engine directly on Postgres, paired with idiomatic Go concurrency patterns. This combination provides a robust, fault-tolerant platform for running chained jobs and workflows expressed as directed acyclic graphs (DAGs).
what hatchet does and how it’s built
Hatchet is an open-source platform designed for managing background tasks and durable workflows with a strong focus on reliability and observability. Unlike traditional FIFO queues that treat jobs as isolated units, Hatchet models tasks and workflows as durable, stateful entities stored in Postgres, which acts as the single source of truth.
At its core, Hatchet provides a durable task queue with a workflow engine capable of orchestrating complex DAGs. This means tasks can depend on the successful completion of other tasks, enabling sophisticated chained workflows with retry and failure handling baked in.
The backend is written in Go, leveraging idiomatic concurrency primitives and patterns to manage task execution and scheduling efficiently. It provides SDKs for Go, Python, and TypeScript, allowing you to define and invoke tasks and workflows in the language that fits your stack.
Hatchet also includes a web dashboard for monitoring workflows and tasks, with observability features such as alerting and metrics to track system health and task status. This makes it easier to operate and debug distributed workflows in production.
why hatchet’s approach stands out
Using Postgres as the backing store is a deliberate tradeoff. It guarantees durability and consistency out of the box, without introducing external dependencies like Redis or Kafka. This choice simplifies the operational footprint since most organizations already run Postgres for their applications.
Under the hood, the code uses Go’s concurrency patterns—goroutines and channels—to manage workers and task execution. This idiomatic approach means the code is clean and maintainable, and performance benefits from Go’s efficient scheduler.
Hatchet’s task queue is durable, meaning tasks persist across application restarts or crashes. This is unlike many in-memory queues prone to losing tasks on failure. The system enforces workflow correctness by modeling dependencies explicitly as DAGs, preventing cycles and ensuring tasks run in the correct order.
Flow control is another highlight. Hatchet supports concurrency limits and rate limiting on workflows and tasks, protecting the system from being overwhelmed. This is especially useful in production environments where load spikes can cause cascading failures.
The tradeoff is complexity and performance overhead compared to lightweight queues. Postgres-based task queues can be slower than in-memory ones and require careful tuning to avoid bottlenecks. Moreover, while the multi-language SDKs increase adoption potential, the core logic and orchestration remain Go-centric.
quick start with hatchet
Getting started with Hatchet is straightforward thanks to its installation script and CLI:
curl -fsSL https://install.hatchet.run/install.sh | bash
hatchet --version
hatchet server start
This installs the Hatchet CLI, verifies the version, and starts the server locally. From there, you can explore the web dashboard and start defining workflows using the SDKs provided.
The official docs and examples guide you through creating durable tasks and DAG workflows, showing how to handle retries, failure alerts, and concurrency limits.
verdict
Hatchet is a solid choice for teams needing durable, fault-tolerant task orchestration without adding new infrastructure beyond Postgres. Its use of Go concurrency patterns and explicit DAG modeling makes it suitable for complex workflows that must survive application crashes.
The tradeoff is performance overhead and operational complexity compared to simpler queues. It’s best suited for projects where task durability and workflow observability are priorities, and teams comfortable with Go or willing to use the provided SDKs.
If you’re managing long-running or dependent background jobs and want a reliable, scalable foundation without introducing Redis or Kafka, Hatchet is worth a close look.
→ GitHub Repo: hatchet-dev/hatchet ⭐ 6,932 · Go