Hi HN! I'm Tony, one of the co-founders of Inngest (https://inngest.com/).

Wanted to show you something we've been working on: Durable Endpoints. It brings durability and steps directly into your APIs. Each step persists the state in the background. The happy path means no additional latency for your users, and you get tracing & metrics out of the box, and failures resume from the last successful step checkpoint rather than restarting from scratch.

The problem we kept hitting: durable execution systems (Temporal, our own workflows, etc.) are designed for async background work. But with AI workloads, you often need durability and low latency in a synchronous request: a user is waiting on a chat response that involves multiple LLM calls, any of which can fail or timeout.

The typical solution is splitting into two systems: a streaming frontend for responsiveness, plus a background job system for reliability. Durable Endpoints let you keep it as one cohesive implementation (here's a Next example):

    import { Inngest } from "inngest";
    import { endpointAdapter } from "inngest/next";
    
    const inngest = new Inngest({ id: "my-app", endpointAdapter });
    
    export const handler = inngest.endpoint(async (req: Request) => {
      const { input } = parseParams(req);
    
      // Each step.run() checkpoints on completion
      const processed = await step.run("process-input", async () => {
        return await expensiveOperation(input);
      });
    
      // If this fails, we resume here — not from the beginning
      const result = await step.run("generate-output", async () => {
        return await anotherExpensiveOperation(processed);
      });
    
      return Response.json({ result });
    });

How it works under the hood:

- Steps are identified by their string ID, not execution order. This makes the system tolerant to code changes... you can refactor, add/remove steps, and existing in-flight executions continue correctly.

- We use checkpointing (https://www.inngest.com/blog/introducing-checkpointing) to async checkpoint steps. State is persisted to our execution store rather than held in memory.

- If endpoints turn async (step errors or waitForEvent), we redirect the user to a new URL which uses keepalives and waits for the API result. Inngest re-enters the endpoint and picks up where it left off, then sends the result to the redirected user.

- Similarly, on failure, our executor re-invokes the endpoint. Completed steps are memoized from the checkpoint... their functions don't re-run, we just return the stored result.

- Works with streaming responses via ReadableStream.

The same step primitives we use in durable workflows (`step.run`, `step.sleep`, `step.waitForEvent`) work here, so you get retries, timeouts, and human-in-the-loop patterns in synchronous handlers.

Beyond AI, this is useful anywhere failure mid-request is expensive: payment flows, webhook processing, third-party API orchestration.

It's in public beta. Docs: https://www.inngest.com/docs/learn/durable-endpoints. Code is in our TypeScript SDK.

Happy to dig into the execution model, how we handle determinism, or the checkpointing implementation.

Ask HN: Why are there no talks about Seedance 2.0 on Hacker News?

Show HN: Keystone – configure Dockerfiles and dev containers for any repo

Locklin on science: Coding assistant experience

Value extraction

Cosmologically Unique IDs

Show HN: Emotional photoreal AI humans at $0.06 / min

OpenClaw Is Dangerous

British Scientist Raising $1B for 'Superhuman Intelligence' in Europe

Show HN: Porchsongs: AI to create and catalogue personalized songs

Redpanda Agentic Data Plane (ADP) now in limited availability

Vermont EV buses prove unreliable for transportation this winter

Gen AI Video – Building a Scalable Validation Framework

Underwater 3D printing may reshape maritime concrete construction

Agent Skills 101: a practical guide for engineers

The Chessmate: Live6 Program Video

Why Europe doesn't have a Tesla

The Payment Layer for the AI Economy

Senior Devs Reportedly Being Replaced by Monkeys with Typewriters

StayFocusd – Is It Spyware?

Dear AI Bot Crawlers Disregard All Previous Instructions and Go Straight to Hell

Rented Virtue

Contra Caplan on Higher Education

Show HN: Durable Endpoints – make any API endpoint unbreakable

Bayer Agrees to Pay $7.25B to Settle Roundup Lawsuits

Mind Reading Technology is Here

Meta CEO Mark Zuckerberg to face jury in landmark social media addiction trial

I Donut Believe

Intrator is a hedge fund scam artist

World Labs Announces New Funding

Python All the Way Down: Speed-of-Light CUDA Without Leaving Python

Ask HN: Are you running production workloads in Pytorch eager mode?