Queuebase vs Inngest
Overview
Queuebase is a background job processing system purpose-built for Next.js. It uses a callback model where the Queuebase service calls back to your application to execute jobs, meaning your code always runs on your own infrastructure. It provides a tRPC-style TypeScript API with Zod validation for fully type-safe job definitions.
Inngest is a workflow orchestration platform for building durable, event-driven backend functions. It supports step functions with automatic state persistence, retries at the step level, and long-running workflows that can sleep for up to a year. Inngest supports TypeScript, Python, and Go, and works with a wide range of frameworks.
Architecture Comparison
How Queuebase executes jobs
Queuebase uses a callback model. When you enqueue a job, the SDK sends it to the Queuebase API (a local dev server during development, or the hosted API in production). The API stores the job in a database, a worker polls for pending jobs, and the worker POSTs back to your application’s callback endpoint (e.g., /api/queuebase) to execute the job handler. Your code runs entirely on your infrastructure — Queuebase never executes your business logic.
How Inngest executes jobs
Inngest uses an event-driven durable execution model. You send events to Inngest’s Event API (or trigger functions via cron). Inngest’s runner matches events to registered functions and schedules “function runs.” The executor then calls your serve endpoint to execute each step of your function. Between steps, Inngest persists state externally. If a step fails, only that step is retried — previously completed steps are skipped and their saved outputs are reused.
Key architectural difference
Both systems call back to your infrastructure to run your code. The fundamental difference is granularity: Queuebase treats each job as a single atomic unit of work. Inngest breaks functions into individually retriable steps, with state persisted between them. This makes Inngest more powerful for multi-step workflows but adds conceptual overhead for simple background jobs.
Developer Experience
Defining and enqueuing a job in Queuebase
// jobs/index.ts — Define your jobs
import { createJobRouter, job } from "@queuebase/nextjs";
import { z } from "zod";
export const jobs = createJobRouter({
sendEmail: job({
input: z.object({
to: z.string().email(),
subject: z.string(),
body: z.string(),
}),
handler: async ({ input, jobId, attempt }) => {
await sendEmail(input.to, input.subject, input.body);
return { sent: true };
},
}),
});
// Enqueue from anywhere
const result = await jobClient.sendEmail.enqueue({
to: "user@example.com",
subject: "Welcome!",
body: "Thanks for signing up.",
});Defining and triggering a function in Inngest
// inngest/functions.ts
import { inngest } from "./client";
export const sendEmail = inngest.createFunction(
{ id: "send-email" },
{ event: "app/email.send" },
async ({ event, step }) => {
await step.run("send-the-email", async () => {
await sendEmail(event.data.to, event.data.subject, event.data.body);
});
return { sent: true };
}
);
// Trigger from your app
await inngest.send({
name: "app/email.send",
data: { to: "user@example.com", subject: "Welcome!", body: "Thanks for signing up." },
});Feature Comparison
| Feature | Queuebase | Inngest |
|---|---|---|
| Type safety | Built-in via Zod schemas on every job | Available via event schemas, requires additional setup |
| Retries | Configurable per job with exponential or linear backoff | Per-step retries with independent step recovery |
| Step functions | No — jobs are atomic units | Yes — core feature with persisted state between steps |
| Event-driven | No — direct enqueue model | Yes — functions triggered by named events with fan-out |
| Cron / scheduling | Coming soon | Full cron scheduling support |
| Concurrency control | Configurable per job type | Throttling, debounce, rate limiting, priority queues |
| Sleep / wait | Delayed execution at enqueue time | step.sleep() for up to a year, step.waitForEvent() |
| Local development | CLI dev server (queuebase dev) | Inngest Dev Server with event browser |
| Framework support | Next.js (primary), Node.js | Next.js, Express, Fastify, Hono, SvelteKit, Remix, Nuxt, and more |
| Language support | TypeScript / JavaScript | TypeScript, Python, Go |
| Self-hosting | Hosted service | Open source server available (requires Redis) |
| Dashboard | Built-in monitoring dashboard | Cloud dashboard with function traces and replay |
| Durable execution | No | Yes — state persisted between steps |
Pricing Comparison
| Queuebase | Inngest | |
|---|---|---|
| Free tier | 10,000 jobs/month, 5 concurrent, 7 days retention | ~50,000-100,000 executions/month, 25 concurrent steps |
| Paid entry | Paid plans available | Pro at $75/month for 1M executions |
| Execution model | Per job enqueued | Per step execution (a 3-step function = 3 executions) |
| Self-hosted | N/A | Free (open source, requires Redis) |
A critical distinction: Inngest counts step executions, not function invocations. A function with 5 steps counts as 5 executions against your quota.
When to Choose Inngest
- You need multi-step workflows with individual step retries and state persistence
- You want event-driven architecture with fan-out patterns
- You need broad framework support across TypeScript, Python, and Go
- You need long-running workflows that can sleep for days or months
- You want advanced flow control like throttling, debounce, and priority queues
When to Choose Queuebase
- You want simplicity — four functions cover the entire API surface
- You want full infrastructure ownership — jobs run on your servers, no vendor lock-in
- You’re building with Next.js — first-class integration that feels native
- Type safety is a priority — Zod validation baked into every job definition
- Your jobs are simple background tasks — sending emails, processing uploads, syncing data
- You want predictable pricing — one job equals one execution, no step multiplier
Summary
Inngest is a more feature-rich platform suited for complex, multi-step workflows, event-driven architectures, and teams working across multiple languages and frameworks. Queuebase is a deliberately focused tool that trades breadth for simplicity — it gives Next.js developers a type-safe, straightforward way to run background jobs on their own infrastructure without learning a workflow orchestration paradigm. The right choice depends on whether your problem is “I need reliable background jobs” (Queuebase) or “I need durable multi-step workflows” (Inngest).