I'm building an internal ops workflow API, what should I use?

For an internal ops workflow API, the best choice is usually:

Use a simple HTTP API + background workers + a workflow engine only if needed

Good default stack

• API layer: FastAPI / Express / Go / Rails
• Async jobs: Celery, Sidekiq, BullMQ, Temporal workers, or cloud queues
• State storage: Postgres
• Queue: SQS / RabbitMQ / Redis / Kafka depending on scale
• Auth: SSO/OIDC + service-to-service auth
• Audit log: append-only event/audit table

If your workflows are simple

If you’re mostly doing things like:

• approve/reject
• notify people
• run a few sequential steps
• retry failed tasks
• track status

then a custom API + DB + queue is usually enough and fastest to ship.

If your workflows are complex

If you need:

• long-running processes
• human approvals with timeouts
• retries and compensation
• branching logic
• exact execution state
• resumability after failures
• visibility into workflow state

then use a workflow engine, especially Temporal.

Strong recommendation

• Temporal if reliability and complex orchestration matter.
• Step Functions if you’re heavily on AWS and want managed infrastructure.
• Camunda / Zeebe if you want BPMN-style business workflows.
• Avoid building your own orchestration engine unless the workflows are very simple.

Practical recommendation by scenario

1) Small internal ops tool

Use:

• FastAPI or Express
• Postgres
• Redis queue
• Worker process

2) Ops API with approvals, retries, and SLAs

Use:

• FastAPI/Go service
• Postgres
• Temporal
• SSO/OIDC
• Audit logging

3) Enterprise process automation

Use:

• Temporal or Camunda
• Postgres
• Event bus
• Fine-grained RBAC and audit trails

My default pick

If you’re asking “what should I use?” with no other constraints:

Use FastAPI + Postgres + Temporal.

That gives you:

• clean API development
• durable workflow execution
• retries and state management
• strong visibility for internal ops

If you want, I can also recommend a stack based on:

1. your cloud provider,
2. expected workflow complexity,
3. team language preference,
4. and whether human approvals are involved.