workerd error: fetch event handler crashed after returning response

Fix fetch event handler crashed after returning response

TL;DR

Move all async work that happens after the response into ctx.waitUntil(). In the Workers runtime, anything you await after returning the response gets killed when the isolate suspends, and the resulting rejection surfaces as a crash after the response. Wrap the background work in ctx.waitUntil(promise) and make that promise catch its own errors.

Verbatim error

workerd error: fetch event handler crashed after returning response

Steps

1. Find the awaits that run after the return in your fetch handler (analytics writes, logging calls, fire-and-forget fetches). Expected: you locate the post-response async work.
2. Change the handler signature to accept the context: async fetch(request, env, ctx). Expected: ctx is available in the handler.
3. Replace bare post-response awaits with ctx.waitUntil(doWork()), where doWork() is an async function holding the background task. Expected: the response still returns fast while the work continues.
4. Make doWork() catch its own errors internally (waitUntil rejections are logged, not fatal, but unhandled ones are noisy). Expected: no unhandled promise rejections in tail.
5. Load-test the endpoint and watch wrangler tail. Expected: response times stay low and no crash logs appear.

Use this when

• workerd logs show "fetch event handler crashed after returning response"
• Analytics, logging, or cache writes happen after the response is returned
• Fire-and-forget fetches after return fail intermittently

Not for this skill when

• The crash happens before the response is returned (debug the handler itself)
• You are streaming a response body (different lifetime rules apply)
• The code runs in a Durable Object (use state.waitUntil there)

Variant phrasings

• worker crashed after respond
• waitUntil not working cloudflare workers
• background task killed after response returned
• promise rejected after response sent workers

Why it happens

After the response is returned, the runtime may suspend the isolate at any moment. Promises that are not attached to waitUntil get cancelled, and their rejections surface as crashes attributed to the fetch handler. ctx.waitUntil() extends the isolate lifetime until the promise settles, which is the supported way to do post-response work.

Edge cases

• waitUntil gives you up to 30 seconds of post-response execution; longer tasks get cut off.
• CPU-heavy background work still counts against the CPU time limit.
• Multiple ctx.waitUntil() calls are fine and run concurrently.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_mZIBoWitozo8B546bUF1RQ