Each replay uses a recreated ChatGPT interface so the placement can be read in its original conversational context. It is not a live or embedded chat.

1. ObservedJul 16, 2026Conversation1 turnsPlacementAfter turn 01 turns · After turn 0Replay chat
   Observed conversationJul 16, 2026 · interface recreation

   ChatGPTArchived view

   Handling background jobs. Custom workers, Asynq, Temporal, or something else?

   It depends much more on your workflow than on the libraries themselves. Here's how I generally think about the tradeoffs.

   If you need...	Use
   Simple background jobs (emails, webhooks, image processing)	Asynq
   Business workflows spanning minutes, hours, or days	Temporal
   High-throughput event processing	Kafka + workers (or NATS JetStream)
   Lightweight in-process jobs	Go goroutines + channels
   Maximum simplicity	Custom worker + PostgreSQL queue

   1. Custom workers

   A simple table like:

   jobs (
       id,
       type,
       payload,
       status,
       attempts,
       run_at
   )
   

   Workers poll:

   SELECT ...
   FOR UPDATE SKIP LOCKED
   

   Pros

   • No Redis dependency
   • Easy debugging
   • Transactions are straightforward
   • Good for small/medium systems
   • Reliable if built carefully

   Cons

   • You have to build retries
   • Scheduling
   • Backoff
   • Dead-letter queues
   • Metrics
   • Dashboard
   • Concurrency control

   I'd recommend this if:

   • <100k jobs/day
   • Small engineering team
   • Mostly CRUD application

   ---

   2. Asynq

   Probably the sweet spot for most Go applications.

   Pros

   • Redis-backed
   • Retries built in
   • Delayed jobs
   • Priorities
   • Scheduling
   • Dashboard
   • Middleware
   • Very mature

   Typical handler:

   func HandleEmail(ctx context.Context, task *asynq.Task) error {
       // send email
   }
   

   Excellent for

   • emails
   • thumbnails
   • webhook delivery
   • imports
   • report generation
   • notifications

   Downsides

   • Redis becomes infrastructure
   • Workflow logic is manual

   Example:

   Generate PDF
   ↓
   
   Upload S3
   ↓
   
   Notify user
   ↓
   
   Retry upload
   ↓
   
   Rollback?
   

   You're writing all that yourself.

   ---

   3. Temporal

   Temporal is not just a job queue.

   It's a workflow engine.

   Instead of:

   enqueue A
   
   A enqueues B
   
   B enqueues C
   

   you write:

   func SignupWorkflow(ctx workflow.Context) error {
       CreateUser()
   
       SendWelcomeEmail()
   
       WaitForVerification()
   
       ProvisionWorkspace()
   
       NotifySlack()
   }
   

   Temporal persists execution state automatically.

   If the server crashes after:

   CreateUser()
   

   it resumes from there.

   Not from the beginning.

   Huge difference.

   Pros

   • Durable execution
   • Long-running workflows
   • Human approval
   • Timers
   • Saga compensation
   • Versioning
   • Automatic retries
   • State recovery

   Amazing for

   • onboarding
   • payment workflows
   • subscriptions
   • billing
   • fulfillment
   • order pipelines
   • approval chains
   • AI agents
   • multi-step automation

   Cons

   • Learning curve
   • Operational complexity
   • New programming model

   ---

   4. Plain goroutines

   go sendEmail(user)
   

   Only use this when losing the work is acceptable.

   Bad for

   • payments
   • emails
   • invoices
   • anything important

   because a process crash loses the job.

   Fine for

   • cache warming
   • analytics
   • best-effort metrics

   ---

   5. Kafka / NATS

   These are event streaming systems, not job queues.

   Use them when:

   • many consumers
   • replay
   • event sourcing
   • streaming pipelines

   Not because you simply want "background jobs."

   ---

   My rule of thumb

   Startup / SaaS

   → Asynq

   It covers 90% of what most products need with minimal operational overhead.

   ---

   Internal CRUD application

   → PostgreSQL queue

   Keep it simple.

   ---

   Enterprise workflows

   → Temporal

   Worth the complexity if you're coordinating long-running, fault-tolerant business processes.

   ---

   Event-driven platform

   → Kafka or NATS

   Different problem space.

   What I'd choose today

   For a new Go web application, I'd generally start with:

   • HTTP API: Go (net/http, chi, or Gin)
   • Database: PostgreSQL
   • Cache & queue: Redis
   • Background jobs: Asynq
   • Object storage: S3-compatible storage
   • Observability: OpenTelemetry + Prometheus + Grafana

   I'd move to Temporal only when the application starts accumulating complex orchestration logic—for example, workflows with many dependent steps, long waits, compensating actions, or requirements to resume execution reliably after failures. In many systems, that transition never becomes necessary.

   A practical guideline is:

   • Asynq: "Run this task later."
   • Temporal: "Coordinate this business process until it completes, even if it takes days."

   For most Go teams, Asynq is the simplest and most productive starting point, while Temporal is an excellent choice once workflow orchestration itself becomes a core part of the application rather than just background processing.

   

   Temporal TechnologiesAd

   Build Reliable WorkflowsTurn payment, job, and pipeline failures into fault-tolerant, recoverable workflows.