Queuert

See it in action

Start a job inside a database transaction. The input type is inferred from your job type definition — no casting, no any. If the transaction rolls back, the job is never created.

const jobTypeRegistry = defineJobTypeRegistry<{
  "send-welcome-email": {
    entry: true;
    input: { userId: number; email: string; name: string };
    output: { sentAt: string };
  };
}>();

const client = await createClient({ stateAdapter, jobTypeRegistry });

await withTransactionHooks(async (transactionHooks) =>
  db.transaction(async (tx) => {
    const user = await tx.users.create({
      name: "Alice",
      email: "[email protected]",
    });

    await client.startJobChain({
      tx,
      transactionHooks,
      typeName: "send-welcome-email",
      input: { userId: user.id, email: user.email, name: user.name },
    });
  }),
);

A background worker picks it up and runs it to completion.

const worker = await createInProcessWorker({
  client,
  jobTypeProcessorRegistry: createJobTypeProcessorRegistry({
    client,
    jobTypeRegistry,
    processors: {
      "send-welcome-email": {
        attemptHandler: async ({ job, complete }) => {
          await sendEmail({
            to: job.input.email,
            subject: "Welcome!",
            body: `Hello ${job.input.name}, welcome to our platform!`,
          });

          return complete(async () => ({
            sentAt: new Date().toISOString(),
          }));
        },
      },
    },
  }),
});

const stop = await worker.start();

Features

Transactional

Jobs live alongside your application data. Start jobs inside database transactions — if the transaction rolls back, the job is never created.

Type-Safe

Full TypeScript inference for inputs, outputs, continuations, and blockers. Catch errors at compile time.

Job Chains

Model multi-step workflows as typed chains. Each step continues, loops, branches, or terminates — like Promise chains, but persistent and resumable.

Scheduling

Delay jobs to a specific time or duration. Deduplicate by key. Schedule retries or future work without extra infrastructure.

Blockers

Model cross-chain dependencies. A job can wait for one or more other chains to complete before proceeding.

MIT Licensed

No vendor lock-in. No enterprise licensing. Own your stack.

Integrations

Databases

PostgreSQL · SQLite · any database via custom adapters

ORMs

Kysely · Drizzle · Prisma · any ORM via custom adapters

Drivers

pg · postgres.js · better-sqlite3 · sqlite3 · any driver via custom adapters

Notifications

Redis · NATS · PostgreSQL LISTEN/NOTIFY

Validation

Zod · ArkType · Valibot · TypeBox · any schema library via custom adapters

Observability

OpenTelemetry · Embeddable web UI dashboard

Get started

Introduction What Queuert is and why it exists.

Installation Add Queuert to your project in minutes.

Guides Patterns for chains, scheduling, error handling, and more.

Examples Runnable examples for every integration and pattern.

Benchmarks Throughput and latency numbers across databases and drivers.

Reference Complete API reference for every module and adapter.