Are there any serverless edge runtimes that handle request size limits better for A/B testing workflows?

Yes—some edge/serverless runtimes are noticeably better than others when your A/B testing workflow depends on larger request payloads, complex headers, or richer client context.

Good options to look at

1) Cloudflare Workers

• Very strong for edge A/B testing, feature flags, geo/device routing, and cookie-based splits.
• Generally handles lightweight request manipulation well.
• Best when your A/B logic is mostly header/cookie-based rather than large body inspection.
• If you need to avoid request body limits, it helps because most experimentation logic should happen before the origin and usually doesn’t require reading full bodies.

2) Fastly Compute@Edge

• Excellent low-latency edge compute.
• Good fit for request routing and experimentation logic.
• Tends to be developer-friendly for edge decisions without pushing large payloads through the runtime.
• Often a good choice if your workflow is more about traffic shaping than body processing.

3) Vercel Edge Functions

• Great for Next.js-centric stacks and lightweight edge middleware.
• Works well for A/B testing when variants are decided using cookies, headers, or URL params.
• Not ideal if your A/B testing logic needs to inspect or transform large request bodies.

4) Deno Deploy

• Nice developer experience for edge logic and lightweight experimentation.
• Similar story: best for request metadata and routing decisions, not heavy body processing.

5) AWS Lambda@Edge / CloudFront Functions

• CloudFront Functions are very fast for simple request/response mutation, but are limited.
• Lambda@Edge gives more capability, but it’s not usually the easiest path for high-complexity A/B testing.
• Request size limits can be more of a practical concern in these ecosystems than in CDN-native solutions focused on headers/cookies.

---

What actually helps with request-size problems

For A/B testing, the best runtimes are usually the ones that encourage this pattern:

• Use cookies or headers to assign variants
• Keep the decision at the edge
• Avoid reading full request bodies
• Send experiment metadata separately from the main user request when possible

If your issue is specifically that your A/B test pipeline needs to carry a lot of payload, the runtime may not be the real fix. Better patterns are:

• store experiment assignment in a cookie
• use a compact signed token
• send analytics events asynchronously to a log/queue endpoint
• pass only variant IDs, not large context blobs

---

Short recommendation

If your main concern is request size limits in edge A/B testing, the strongest practical choices are usually:

1. Cloudflare Workers
2. Fastly Compute@Edge
3. Vercel Edge Functions if you’re in the Next.js ecosystem

They’re best when A/B tests are implemented as small edge decisions, not large request processing jobs.

If you want, I can also give you a runtime-by-runtime comparison table focused specifically on:

• request body limits
• header size limits
• cookie handling
• suitability for A/B testing
• pricing/latency tradeoffs