Inngest Durable Functions

# Checkpointing for Performance Optimization

Guide to using Inngest's checkpointing feature for dramatically lower latency in real-time workflows.

## What is Checkpointing?

Checkpointing executes steps **immediately on your server** rather than waiting for orchestration from Inngest. Steps run eagerly with periodic state checkpoints sent to Inngest for safety.

### Performance Comparison

- **Without checkpointing**: ~50-100ms per step (HTTP round-trip to Inngest)
- **With checkpointing**: Near-zero latency between steps, periodic checkpoints

```typescript
// Traditional execution: Each step = separate HTTP request
const traditional = inngest.createFunction(
  { id: "traditional-execution", triggers: [{ event: "process/traditional" }] },
  async ({ event, step }) => {
    // Step 1: HTTP request to Inngest → response → continue
    const data = await step.run("fetch-data", () => fetchData());

    // Step 2: HTTP request to Inngest → response → continue
    const processed = await step.run("process", () => process(data));

    // Step 3: HTTP request to Inngest → response → complete
    return await step.run("save", () => save(processed));
  }
);

// Checkpointed execution: Steps run immediately, periodic checkpoints
const checkpointed = inngest.createFunction(
  {
    id: "checkpointed-execution",
    triggers: [{ event: "process/checkpointed" }]
  },
  async ({ event, step }) => {
    // All steps run immediately, checkpoints sent periodically
    const data = await step.run("fetch-data", () => fetchData());
    const processed = await step.run("process", () => process(data));
    return await step.run("save", () => save(processed));
  }
);
```

## Basic Checkpointing Setup

**Checkpointing is enabled by default in v4.** All functions automatically use checkpointing for optimal performance. You can configure `maxRuntime` for serverless environments or disable it per-function if needed.

### TypeScript Configuration

```typescript
import { Inngest } from "inngest";

// Checkpointing is enabled by default - no configuration needed
export const inngest = new Inngest({
  id: "my-app"
});

// Functions automatically use checkpointing
const realTimeFunction = inngest.createFunction(
  {
    id: "real-time-function",
    triggers: [{ event: "realtime/process" }]
  },
  async ({ event, step }) => {
    // Steps execute immediately with periodic checkpointing
    const result1 = await step.run("immediate-step-1", () =>
      process1(event.data)
    );
    const result2 = await step.run("immediate-step-2", () => process2(result1));
    const result3 = await step.run("immediate-step-3", () => process3(result2));

    return { result: result3 };
  }
);

// Configure maxRuntime for serverless environments
const serverlessFunction = inngest.createFunction(
  {
    id: "serverless-function",
    triggers: [{ event: "realtime/serverless" }],
    checkpointing: {
      maxRuntime: "4m45s" // Leave buffer before platform timeout
    }
  },
  async ({ event, step }) => {
    // Steps execute immediately with checkpointing
    const result = await step.run("process", () => process(event.data));
    return { result };
  }
);

// Disable checkpointing for a specific function if needed
const noCheckpointFunction = inngest.createFunction(
  {
    id: "no-checkpoint-function",
    triggers: [{ event: "legacy/process" }],
    checkpointing: false
  },
  async ({ event, step }) => {
    // Uses traditional step-by-step orchestration
    const result = await step.run("process", () => process(event.data));
    return { result };
  }
);
```

### Go Configuration

```go
import (
  "github.com/inngest/inngestgo"
  "github.com/inngest/inngestgo/pkg/checkpoint"
)

_, err := inngestgo.CreateFunction(
  client,
  inngestgo.FunctionOpts{
    ID:         "checkpointed-function",
    Name:       "Checkpointed Function",
    Checkpoint: checkpoint.ConfigSafe, // Enable checkpointing
  },
  inngestgo.EventTrigger("process/checkpointed", nil),
  func(ctx contex