Workly

Inngest alternative

Background jobs as plain HTTP requests, without an SDK in every handler.

Inngest and Workly both call your app over HTTP and retry until it works. Inngest runs functions written with its SDK, step by step. Workly sends an ordinary request to any route, in any language, and keeps every attempt. If your jobs are requests to endpoints rather than programs with state, Workly is the smaller tool.

A function in Inngest is a route in Workly.

With Inngest, a job is a function the SDK serves from one endpoint, and an event starts it. With Workly, a job is a request to a route you already have: the route doesn't import Workly to run, only to check the signature, and it can be in any language that answers HTTP.

Inngest
import { Inngest } from "inngest";

const inngest = new Inngest({ id: "my-app" });

// A function, served by your app at /api/inngest
export const sendWelcome = inngest.createFunction(
  { id: "send-welcome", triggers: { event: "user/signed.up" } },
  async ({ event, step }) => {
    await step.run("send-email", () => sendEmail(event.data.userId));
  },
);

// Elsewhere: send the event that triggers it
await inngest.send({ name: "user/signed.up", data: { userId } });
Workly
import { verifySignature, Workly } from "@worklydev/sdk";

const workly = new Workly(); // WORKLY_URL, WORKLY_API_KEY

// Enqueue a request to one of your routes
await workly.tasks.enqueue("emails", {
  url: "https://api.example.com/tasks/send-welcome",
  payload: { userId },
});

// app/tasks/send-welcome/route.ts: an ordinary route
export async function POST(request: Request) {
  const body = await request.text();
  try {
    await verifySignature(body, request.headers); // WORKLY_SIGNING_SECRET
  } catch {
    return new Response(null, { status: 401 });
  }
  await sendEmail(JSON.parse(body).userId);
  return new Response(null, { status: 204 });
}

Workly and Inngest compared.

Both deliver over HTTP, retry with backoff, run cron and can be self-hosted. The differences are in what a job is, how workflows are written, and the license.

InngestWorkly
ModelFunctions written with the Inngest SDK, triggered by events or cron. Inngest calls your app's serve endpoint for each step, or runs them over a connect WebSocket from long-running workersTasks delivered to any endpoint as signed HTTP requests. Workflows are DAGs of those endpoints, declared in workly.yaml or the API
Your handlerA function inside the SDK, served from one route; code outside step.run() runs again on every stepAn ordinary route that answers 2xx. No SDK needed in the handler, beyond checking the signature
LanguagesTypeScript, Python and Go SDKsAny: a handler is an HTTP endpoint. Python and TypeScript SDKs for enqueueing
Self-hostingOne binary, SQLite and an in-memory Redis by default; Postgres and Redis for more than one node. Server under the SSPL, with delayed publication under Apache-2.0One binary plus Postgres, Apache-2.0
Local developmentinngest dev: the Dev Server, with your app run in dev mode (INNGEST_DEV=1)workly dev: the same server as production, on SQLite, with the dashboard
Retries4 retries by default (5 attempts), 0 to 20 per function; a failed step retries alone5 attempts by default, backoff with jitter; honours Retry-After; you choose whether 4xx is retried
Flow controlConcurrency, throttle, rate limit, debounce, priority and event batching per function, each with an optional keyrate_per_second and max_concurrency per queue
Deduplicationidempotency key expression, for 24 hoursidempotency_key, for as long as the task is kept, and a stable Workly-Task-Id header
SchedulesCron triggers, UTC unless prefixed with TZ=Cron with a timezone, overlap policy, run history and run-now
WorkflowsSteps written as code: results passed between steps, branches, loops, sleeps and waits for events, within the plan's run length (30 days on Free)A DAG of HTTP steps declared up front; a step can wait for a task group; a failed run retries from where it stopped. No branching or outputs between steps
Fan-outOne event can trigger many functions; step.sendEvent starts moreTask groups: enqueue many tasks, get one callback with the counts when all have finished
After the last retryThe run fails and an onFailure handler can run; the trace is kept for the plan's historyKept as failed with every attempt, grouped by error; an alert by email or Slack; retry one or a whole group once the fix is in
VisibilityTraces and logs per run, kept 24 hours on Free, 7 days on Pro and 14 on BusinessEvery attempt with status code and response body, kept 7 days (30 on Pro); dashboard, MCP and Prometheus metrics when self-hosted
Step lengthUp to 2 hours per step, or less if your host times out firstUp to 30 minutes per attempt
Price50k executions a month free, with 5 concurrent steps; Pro from $99 a month for 1M. A run and each of its steps count as one execution eachFree to self-host. Hosted: 100k tasks a month free, Developer $19 for 1M. A task counts once, however many attempts

Inngest behaviour, limits and prices from its documentation, pricing page and README, November 2026.

See what your endpoint answered, every time.

Every task keeps its attempts: status code, error, response body and timing. Failed tasks are grouped by error, an alert goes to email or Slack, and once the fix is out you retry the whole group, from the dashboard, the CLI or your coding agent over MCP.

How debugging works →
A failed task in the Workly dashboard, explaining why it failed, with every attempt's response.

When Inngest is the better choice.

Your steps pass data and make decisions

Inngest functions branch on earlier results, loop, sleep for days and wait for an event before going on. Workly's workflows are a fixed graph of endpoints with no outputs between steps.

You think in events

One event can start several functions, and functions can be debounced, batched or cancelled by other events. Workly has queues you enqueue to, not events to subscribe to.

You want finer flow control

Inngest throttles, debounces and prioritises per function and per key, such as per customer. Workly limits rate and concurrency per queue.

Both push to your app over HTTP. How that compares with workers.

Questions

Both call my app over HTTP. What is the difference?
What arrives. Inngest calls one SDK route and runs your function a step at a time, with its state. Workly sends a plain request to whichever route you name and records how it answered: the handler needs no SDK, and any language can answer it.
Can I self-host Inngest?
Yes, since its 1.0 release, as one binary that uses Postgres and Redis for production. The server is under the Server Side Public License, with each release published under Apache-2.0 after a delay; check whether that works for you. Workly is Apache-2.0 today.
When is Inngest the better choice?
When a job is really a program: steps that pass results along, branch, sleep for days or wait for a user to do something. Workly fits when a job is a request to an endpoint, and a workflow is a few of them in order.
How do executions compare with Workly's tasks?
Inngest counts a run and each of its steps, so a function with five steps is six executions. Workly counts each task once, however many attempts it takes, and each step of a workflow as a task.
How do I move a function over?
Make each step an endpoint. A function with one step becomes a queue and a route. A function with several becomes a workflow in workly.yaml, one step per endpoint, with depends_on for the order. Anything that branches or sleeps stays in your code or in Inngest.

Try it in five minutes.

workly dev gives you a server and dashboard on your laptop with nothing else to start, and npm install @worklydev/sdk lets your app enqueue to it. Or sign in to hosted Workly and get a workspace and an API key in a minute, free on the Hobby plan.