Logo
Solutions
Products
Industries
Customers
Resources
Company
Events
Get in touch

Next.js 15 Migration: How an Auction Platform Fixed Request Amplification Without Scaling Infrastructure

Explore how an auction platform resolved Next.js 15 migration challenges by eliminating redundant requests, optimizing internal routing, and improving performance without scaling infrastructure.


By Hemalatha S

Last updated: November 18, 2026 7:42 am

Contents

  • Introduction
  • What Is Request Amplification in a Next.js Application?
  • The First Obstacle: Image Optimization Under Load
  • Fix One: Remove the Public CDN Round-Trip
  • Key Lessons for Next.js Migration Teams
  • Frequently Asked Questions
  • Conclusion

Introduction

A framework upgrade can expose architectural problems that were previously hidden by caching. For a high-traffic auction platform, migrating from Next.js 14 to Next.js 15 revealed exactly that: internal network loops, duplicate content requests, and an incompatible image optimization pipeline.

Though the initial symptoms suggested insufficient infrastructure capacity, we decided to investigate it further and found a different story.

This field report examines how Infiligence's engineering team separated routing overhead from repeated data fetching, addressed each problem at the correct layer, and avoided unnecessary infrastructure scaling.

Source: Infiligence Engineering’s Next.js 15 Migration and the Request-Amplification Trap, prepared by Manoj Bhavvan. Figures and outcomes above are reported by the whitepaper, not independently benchmarked.

What Is Request Amplification in a Next.js Application?

Request amplification occurs when a page visit or render generates more downstream requests than the application needs. It can result from repeated data fetching, unnecessary network hops, or multiple components independently requesting shared information.

In this case, two distinct problems compounded the load:

  • Server-side content calls traveled through the public Cloudflare domain and back to the application.
  • Components requested overlapping CMS data without deduplication within the same render.

Fixing only one problem reduced the overhead but did not eliminate it.

The Platform: Next.js, Strapi, Azure, and Cloudflare

The application supported a global auction business, with more than 60 distinct page routes and a requirement to remain available during live event windows.

Its architecture included:

Layer

Technology

Application framework

Next.js App Router

Content management

Strapi with Redis-backed response caching

Search

Algolia

Edge services

Cloudflare

Application hosting

Azure App Service

Observability

Datadog and Azure App Insights

Supporting services

Authentication and customer/CRM synchronization

The migration involved more than changing a package version. Work included asynchronous route parameters, dynamic imports, lint configuration, TypeScript compatibility, and image handling.

The report also identifies patching known framework security issues as a reason for proceeding with the upgrade.

The First Obstacle: Image Optimization Under Load

After the upgrade, image optimizer requests became pending or were cancelled under load.

The team temporarily disabled server-side image optimization, serving images directly from their sources while evaluating a permanent approach.

This was a deliberate release decision, not the final architecture.

The lesson: An interim workaround should have an owner, a review date, and clear replacement criteria. Otherwise, a temporary stability measure can become an unmanaged production dependency.

Why Internal Requests Were Going Through Cloudflare?

The server-side content-fetching layer used the same public, Cloudflare-fronted domain as browsers.

Consequently, a content request could follow this path:

Application server → Cloudflare → Application server

A server-rendered component fetching header, footer, or page content therefore introduced an external round-trip into what should have been an internal service interaction.

The report describes production pressure involving an estimated two to three million requests. That figure represents reported request volume, not a verified count of users or page visits.

Fix One: Remove the Public CDN Round-Trip

The team redirected internal server-to-server calls to a dedicated internal-only origin address.

According to the report, this reduced request volume from approximately four times baseline to twice baseline.

That improvement established something important: the routing change worked, but a separate source of duplication remained.

Why Response Caching Did Not Solve the Remaining Problem?

With routing corrected, the application still made more content requests than a render required.

The team investigated response caching, but the attempted configuration did not address the relevant execution path. Content requests passed through an internal API handler that continued executing on each hit.

More importantly, the remaining issue was repeated work within a render, rather than simply how long content stayed fresh between requests.

Caching and Deduplication Solve Different Problems

Mechanism

Problem addressed in this architecture

Internal routing

Unnecessary external network hops

Per-render memoization

Repeated calls for the same data during one render

CMS response caching

Repeated content retrieval across requests

Edge caching

Repeated delivery of cacheable output to visitors

The takeaway: Before adding caching, identify whether the bottleneck is network routing, duplicate execution, cache freshness, or a combination.

How React cache() Addressed Duplicate CMS Calls?

The successful approach combined direct, in-process service calls with React’s cache() primitive.

Instead of repeatedly calling the application’s own CMS proxy endpoint, server-side modules invoked the underlying service functions directly. Memoization allowed components within a render to reuse previously resolved results.

The team applied this approach across roughly two dozen service functions.

In this implementation, internal routing removed the unnecessary network journey; per-render memoization addressed the remaining repeated work. Neither change alone solved both problems.

Shared Configuration Was Another Request Multiplier

The investigation uncovered a similar issue with the reCAPTCHA feature flag.

Forms independently fetched the same configuration across login, sign-up, password reset, and lead-generation experiences.

The team introduced a shared context provider near the root of the component tree. It fetched the flag once and exposed the value to its consumers, replacing independent requests across roughly a dozen components.

A useful review question: Which shared configuration values are being fetched separately by every consumer?

Choosing an Image Optimization Strategy

For the permanent image solution, the team compared two approaches:

  • Custom Azure pipeline: Azure Functions and Sharp for transformations, Blob Storage for generated variants, and Redis coordination.
  • Cloudflare Image Transformations: Transformation and caching at the existing edge layer.

The team selected Cloudflare based on the platform’s total cost of ownership and operational needs. A custom image loader generated transformation URLs for eligible images.

This was a workload-specific decision, not a universal recommendation against custom image pipelines.

Load Testing: Was the Test Measuring the CDN or the Origin?

An initial load test produced unexpectedly low application-server activity. Much of the traffic was being served from the edge, limiting what the test revealed about origin capacity.

The team then tested React Server Component request paths with 2,000 virtual users to exercise server-side behavior more directly.

The report records approximately 3% 5xx or timeout responses in that run, attributed to cache exhaustion on particular high-churn pages.

That is a remaining failure condition, not an error-free result. However, interpreting its scope helped the team distinguish targeted issues from a platform-wide capacity shortage.

Key Lessons for Next.js Migration Teams

Before scaling infrastructure in response to migration-related load:

  1. Trace internal calls. Check whether server-side services unnecessarily traverse public CDN routes.
  2. Measure repeated work. Look for overlapping data requests within individual renders.
  3. Separate caching layers. Give each layer a defined purpose.
  4. Review shared configuration. Avoid independent requests for identical values.
  5. Test image delivery under load. Include optimization behavior, not just visual correctness.
  6. Isolate origin performance. Distinguish edge-served traffic from application execution.
  7. Investigate failures explicitly. Document their causes and acceptance criteria before declaring readiness.

Frequently Asked Questions

Does a Next.js 15 migration always increase server load?

No. This report describes a particular application whose existing routing and data-fetching patterns became problematic during migration. It does not establish that every Next.js 15 upgrade increases load.

Will adding a CDN fix duplicate server-side requests?

Not necessarily. In this case, routing internal calls through the public CDN contributed to overhead. Duplicate calls within a render required a separate fix.

Is React cache() a replacement for Redis or edge caching?

Not in the architecture described here. React cache() handled per-render deduplication, while Redis and Cloudflare served different cross-request caching purposes.

Conclusion

The auction platform’s migration illustrates a practical engineering principle: high request volume does not automatically mean insufficient infrastructure.

By separating network overhead, repeated execution, image delivery, and test behavior, the team addressed the causes rather than scaling around the symptoms.

For teams planning a similar migration, the first question should be: What work is the application doing unnecessarily—and where?

Let’s Secure Your Next Build Together

Whether you're building from scratch or refining your stack, Infiligence partners with you to embed security into every step.

Let’s Secure Your Next Build Together
Company
About UsOur TeamCareersCertifications
Solutions
DevSecOpsVerification & ValidationModernizationAgentic AIData Engineering
Industries
HealthcareLife SciencesEvents & Auction
Resources
BlogsWhite PapersCase StudiesWebinarsPodcasts
Portfolio
Customers
Products
AI HarnessAI FoundryAgentic TEPValidation Co-Pilot
Contact Us
[email protected]
Locations
SF Bay Area, USA
Vancouver, Canada
Chennai, India
© Infiligence. All Rights Reserved 2026.
Privacy Policy