Process Billions of Background Jobs Without Losing Sleep

Name: Oban Pro
Author: Oban Pro

Thousands of Elixir and Python applications rely on Oban Pro for background jobs with durable workflows, distributed concurrency, optimized performance, and a trove of enterprise grade features.

Upgrade to Oban Pro in Minutes

Next Level Productivity on an OSS Foundation

From Oban's solid foundation, Oban Pro layers on the advanced features needed to scale complex background job systems, and Oban Web brings the whole cluster into one real-time dashboard.

Oban

Reliability

Durable background jobs with automatic retries, error handling, and transaction safety

Consistency

Transactional job insertion and at-least-once execution backed by your database

Observability

Built-in instrumentation and job retention for monitoring execution and historic jobs

Oban Pro

Orchestration

Durable workflows, decorators, signals, and relay to build complex job systems faster

Performance

Smart engine with advanced concurrency control, global limits, rate limiting, and burst mode

Flexibility

Granular queue partitioning, chaining, and dynamic configuration for every use case

Oban Web

Tour

Visibility

Every job, queue, schedule, and workflow across the cluster, streaming live in one view

Control

Pause queues, retry or cancel jobs, and trigger crons on demand without a deploy

Insight

Built-in metrics for throughput, queue depth, and execution time with no extra infrastructure

lib/myapp/workflow.ex

defmodule MyApp.Workflow do
  alias Oban.Pro.Workflow

  def invoke(params) do
    Workflow.new()
    |> Workflow.put_context(params)
    |> Workflow.add_cascade(:a, &foo/1)
    |> Workflow.add_cascade(:b, &foo/1, deps: :a)
    |> Workflow.add_cascade(:c, {0..1, &bar/2}, deps: :b)
    |> Workflow.add_cascade(:d, &foo/1, deps: :c)
  end

  ...

from oban_pro import Workflow

def invoke(params):
    return (
        Workflow()
        .add_context(params)
        .add_cascade("a", foo)
        .add_cascade("b", foo, deps="a")
        .add_cascade("c", (range(0, 1), bar), deps="b")
        .add_cascade("d", foo, deps="c")
    )

...

Durable Workflows

Oban Pro Workflows orchestrate multi-step processes that survive crashes, restarts, and deploys. Every step is checkpointed in Postgres and execution resumes from the last completed step. Perfect for AI tasks, billing pipelines, media processing, and reporting systems that can't afford to lose progress.

Durable by Default

Every step runs as a persistent job with automatic retries. A crash mid-workflow picks up where it left off without redoing completed work.

Fully Distributed

Any node can run any step, with coordination directly through Postgres rather than a separate orchestration service to deploy and scale.

Flexible Composition

Build workflows from plain functions with cascading context, fan-out and fan-in dependencies, and nested sub-workflows for reuse.

Smart Concurrency

Oban Pro's Smart engine provides advanced concurrency control across your entire cluster. With Pro you have global limits, rate limiting, partitioning for granular control, and burst mode to maximize throughput when capacity is available.

config/config.exs

config :my_app, Oban,
  engine: Oban.Pro.Engines.Smart,
  queues: [
    analysis: [
      local_limit: 5,
      rate_limit: [allowed: 500, period: {1, :minute}]
    ],
    imports: [
      global_limit: 10
    ],
    exports: [
      global_limit: 1,
      partition: [args: [:account_id]]
    ]
  ]

[queues.analysis]
limit = 5
rate_limit = {allowed = 500, period = 60}

[queues.imports]
limit = 5
global_limit = 10

[queues.exports]
limit = 1
global_limit = 1
partition = {args = ["account_id"]}

Granular Partitioning

Split a single queue into multiple partitions, each with its own concurrency and rate limits for independent job processing.

Distributed Rate Limiting

Control execution rates across your cluster by limiting how many jobs run within a specific time window, with limits enforced globally across all nodes.

Burst Performance

Maximize throughput temporarily by exceeding per-partition limits when there's available capacity in the system.

lib/myapp/payments.ex

defmodule MyApp.Payments do
  use Oban.Pro.Decorator

  @job queue: :payments, recorded: true, unique: true
  def generate_receipt(invoice) do
    # ...
  end

  @job queue: :emails, max_attempts: 3
  def deliver_receipt(receipt) do
    # ...
  end
end

with {:ok, receipt} <- Payments.relay_generate_receipt(invoice) do
  Payments.insert_deliver_receipt(receipt)
end

from oban import job

@job(queue="payments", unique=True)
def generate_receipt(invoice):
    # ...

@job(queue="emails", max_attempts=3)
def deliver_receipt(receipt):
    # ...


try:
    receipt = await generate_receipt.relay(invoice)
    await deliver_receipt.insert(receipt)
except RelayError:
    # ...

Productive Extensions

Oban Pro's powerful extensions boost productivity with decorators for any function, relay for distributed job execution, hooks for lifecycle events, recording for debugging, structured args for validation, chains for sequential job orchestration, and more.

Decorators

Decorated functions act as fully fledged background jobs with retries, scheduling, and the other guarantees you'd expect from Oban jobs.

Relay

Relay lets you insert and await the results of jobs locally or remotely across any number of nodes.

Chains

Chains link jobs together for strict sequential execution, ensuring downstream jobs run only after upstream jobs are completed.

Explore all Pro features

Support is Here

Need help using Pro features, scaling your system, or tackling gnarly troubleshooting? Expedite the support process with a pairing session!

Learn About Pairing Sessions

Fewer Queries, Faster Job Processing

Want more reasons to use Pro? The Smart engine delivers increased job throughput with dramatically reduced database load.

92%

Fewer Queries

96%

Fewer Transactions

Total queries to process N unique jobs (more is worse)

Insert Optimization

Less data over the wire with batched, paramaterized inserts
Async Tracking

Process jobs with far fewer transactions thanks to async tracking
Accurate Recovery

Accurate job retry after shutdown, without waiting for a timeout

┌─[CUSTOMER-A]─┐    ┌─[AI-API]─┐
│ ████████████ │    │          │
│ 80/100 req/h ├───►│ ▅▅▅▅▅▅▅▅ │
└──────────────┘    │          │
┌─[CUSTOMER-B]─┐    │          │
│ ██████░░░░░░ │    │          │
│ 60/100 req/h ├───►│          │
└──────────────┘    └──────────┘

Per-Customer Rate Limiting

  ┌─────────────────┐
  │    DECOMPOSE    │
  └─────────────────┘
       │ │   │ │
  ┌────┘ │   │ └────┐
  ▼      ▼   ▼      ▼
[RES] [ANA] [SYN] [RSP]
  ✓     ⚡     ⧗     ○

Agentic Task Decomposition

[PREP] ─► [TRAIN] ─► [EVAL] ─► [DEPL]
   │         │         │         │
   ▼         ▼         ▼         ▼
 ┌───┐     ┌───┐     ┌───┐     ┌───┐
 │ ✓ │     │ ✓ │     │ ✓ │     │ ✓ │
 └───┘     └───┘     └───┘     └───┘
 ┌───┐     ┌───┐               ┌───┐
 │ ✓ │     │ ✓ │               │ ○ │
 └───┘     └───┘               └───┘

Training Pipeline Orchestration

┌─[BATCH-001]─┐
│ * * * * * * │ ─► [TRANSACT] ──────┐
└─────────────┘                     │
┌─[BATCH-002]─┐                     ▼
│ * * * * * * │ ──► [SUMMARY] ─► [OUTPUT]
└─────────────┘                     ▲
                                    │
           2AM GPU TIME             │
          ▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅ ──────────┘
          LOW COST PERIOD

Scheduled Batch Processing

Oban AI

Oban AI uses machine learning to optimize your workflows and…syke! All you need is Oban Pro, it's ideal for building AI integrated applications.

Learn How to Use Pro with AI

Built for Enterprise

Tailored to organizations that want dedicated support, private chat, video pairing, priority access to new features, and ongoing configuration review.

Enterprise Features Schedule a Consult

“The best tooling decision we've made was Oban Pro for async tasks. We love the way our system functions with it as the backbone. Your work really takes ours to the next level.”

Britton Kowalk

Crew

“Oban is probably the greatest library I have ever used, especially with Pro on top. The value you get from Pro-for a very reasonable amount-is completely mind-blowing.”

Peter Ullrich

IndieCourses

“We 100% couldn't have put our new, monolithic ETL into production without Oban Pro. FLAME + Oban is actually a dream. Every time we double down on the BEAM, we win.”

Christopher Grainger

Amplified

Ready to build async systems with confidence?

Check Out Plans & Pricing