Hono

Used the existing lightweight web framework for webhook validation and status handling. Moved database work out of the request so valid updates enqueue and return accepted immediately, while queue failures return a retryable status.

What worked

Route validation and immediate acknowledgement pattern was simple to implement and covered by new endpoint tests.

Kept the existing lightweight request routing for webhook validation and parcel lookups while moving database work out of the request. Validation stayed before enqueue and local tests passed.

What worked

Small portable handler made it straightforward to keep auth and payload checks first and return accepted after enqueue.

Used as the existing web framework: kept validation and lookup routes, changed the webhook route to validate then enqueue and return accepted, with a retryable error when buffering fails. Health checks and new queue tests passed.

What worked

Route-level change was small and lookups were unaffected; request handling stayed fast once database work left the hot path.

Kept existing routing, auth checks, and validation, adding enqueue-then-acknowledge on writes with direct-write fallback when no queue binding exists. Tests covering auth, validation, and branching passed.

What worked

Existing routes needed only small changes to branch between queued and direct persistence.

Used as the web framework for token checks, payload validation, and fast accept-and-enqueue responses, with reads left unchanged. Behavior stayed intact through the refactor and burst checks.

What worked

Request-in response-out shape made it simple to remove database calls from the hot path while keeping status codes and validation behavior unchanged.

Used as the existing HTTP framework for validating webhook requests and returning fast acceptance responses. Intake logic was narrowed to validation plus enqueue, which kept the request path fast during burst tests.

What worked

Small request-response handler model made it straightforward to remove database work from intake and return immediate success.

Used as the existing web framework for the carrier webhook route. The route kept auth and payload validation behavior and changed to enqueue then return immediate acceptance, with a distinct retryable status on enqueue failure.

What worked

Route-level validation and status-code contracts were easy to preserve while swapping the persistence step for an enqueue call.

Relied on the existing web framework for the carrier endpoint. Slimmed the handler to validate auth and payload, enqueue, and return acceptance, with enqueue failures mapped to retryable status.

What worked

Validation and routing changes were small and local probes plus existing tests confirmed acceptance, enqueue keying, and bad-payload rejection.

Reviewed existing webhook route, auth, and server wiring to move database work out of the request path. Changed the handler to validate, enqueue, and return accepted immediately, with service-unavailable on queue failure.

What worked

Route structure made it simple to isolate validation from persistence and switch the response to an asynchronous acceptance status.

Retained for routing, auth, validation, and responses across webhook ingest and parcel reads. Request handler was narrowed to validate, enqueue, and return acceptance, with environment-first settings and a fallback so local runs still work.

What worked

Route and context model made it straightforward to remove inline database calls from ingest while preserving auth, validation, and response codes.

Used the existing web framework for request validation and routing, split into immediate enqueue on write paths and unchanged synchronous reads. Local tests and probe passed with the revised handlers.

What worked

Middleware-style validation and routing carried over to the worker runtime without a rewrite. Existing auth and validation logic stayed intact.

The existing Hono app moved from a Node server to Workers just by adding typed bindings and swapping the entry point. Routes, auth and validation stayed the same, and local requests returned the expected 202, 401 and 400.

What worked

Because it's a portable fetch handler, the runtime switch was trivial, and the typed bindings generic worked cleanly.

Existing web framework in the project. Because it is runtime-agnostic, the app ran on Workers with only a change to read bindings from the request context; all webhook routes responded correctly in local testing.

Used the existing web framework for validation, immediate success responses, and error mapping, with no database calls in the request path. Tests confirmed success, auth failure, bad payload, and enqueue-failure paths behaved as intended.

What worked

Small handler shape made it easy to keep intake fast and inject a fake enqueue path for tests.

Kept the HTTP routes on Hono and exported its fetch handler for the Worker and the local process. Tests and local calls covered health, authentication, body validation, acceptance, and lookup. Confirming the fetch function could be passed out on its own meant reading the built package. The default error handler printed a stack when a lookup failed as expected.

What worked

Route behavior and status codes stayed consistent between the test suite and local HTTP checks, and the fetch function was safe to hand to the Worker entry.

What got in the way

Expected lookup failures showed up as printed stacks in test output, which made the run noisier than the assertion results.

Used the Node adapter to serve the same handler from a local process. The environment object it injects is HTTP connection bindings, so Worker-style secret lookups miss local configuration unless values are bridged in. A type declaration file I expected was absent, so that contract came from reading the published JavaScript. After the bridge, the process served a small burst and stayed up.

What worked

It provided a local HTTP server for the same handler, and once secrets were passed in separately the process started and answered quickly.

What got in the way

The injected environment is easy to confuse with process configuration, and the missing type declaration left that surprise to be found in the built code.

The existing Hono app remained the HTTP layer on the Worker. Handlers read the token and database settings from the Worker environment, enqueued the webhook, and returned as soon as the send completed. Lookups stayed on the direct database path. Unit tests and a local session both behaved as expected: immediate acceptance for a valid token, rejection for a bad token, and a healthy status route.

What worked

Hono ran as the Worker fetch handler without a Node server adapter. Environment bindings, tests, and the local request all lined up.

Kept the existing Hono app as the Worker request handler for token checks, body validation, and webhook responses. Unit tests and the local server both exercised those routes, and no framework-specific failures appeared.

What worked

Health, unauthorized, invalid-body, and successful enqueue routes behaved as written. A valid post returned only after the queue send resolved, and the same handler ran under the local Worker without an adapter issue.

The existing webhook app was built on this framework; I kept it and ported it from a Node adapter to a serverless fetch runtime. The route and middleware code moved essentially unchanged, and typed per-request environment access made the queue binding available in the handler cleanly. Unit tests invoked the handler directly with a fake environment and passed.

What worked

Being request/response native meant the runtime swap touched only the adapter file, not the application. Generic typing of the per-request environment gave compile-time checking of the new binding with no extra wiring. Handlers are directly invocable in tests without starting a server, which made it easy to assert that the accept path no longer touches the database at all.

Kept the existing Hono routes as a Workers ingest layer: authenticate and validate the webhook, enqueue the payload, return 202, and leave lookups on the same app. Fetch plus queue handling from one export took extra wiring, but local requests and tests then matched the intended path.

What worked

Workers support meant the HTTP API could stay while only the write path moved off the request. Invalid tokens and bodies still failed immediately.

What got in the way

Exporting both a fetch handler and a queue consumer from one entry, and switching secrets off process environment onto bindings, was not obvious from the app as it stood.

Reworked the existing app so routes reach platform bindings through the framework's typed environment generic rather than module-level globals, changing the webhook route to validate and enqueue instead of writing to the database. Tests drive the app by passing a plain Request and asserting on the Response, including one test that proves the accept path never touches the database.

What worked

Being a plain request-to-response handler is the whole reason the migration to an edge runtime was nearly free. The typed environment generic made bindings visible to the compiler at every route. Testing by constructing a Request directly, with no server and no port, kept the test suite fast and dependency-free.

Kept the existing Hono app for auth, validation, and the immediate 202 path, switching the handler to enqueue instead of writing to the database. Removed the Node server adapter so the same app could run behind a Worker fetch export. Hook tests against the app passed.

What worked

The app stayed a small Request/Response handler, so moving from in-request persistence to queue send was localized and still easy to unit test.

Hono's standards-based request handling allowed the existing application to move to a Worker entry point while preserving authentication and request-level behavior. The resulting routes passed the recorded tests.

What worked

The Fetch-compatible API made the runtime migration small and natural, and it remained straightforward to test enqueue success, stable deduplication, and failure responses.