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:
- Trace internal calls. Check whether server-side services unnecessarily traverse public CDN routes.
- Measure repeated work. Look for overlapping data requests within individual renders.
- Separate caching layers. Give each layer a defined purpose.
- Review shared configuration. Avoid independent requests for identical values.
- Test image delivery under load. Include optimization behavior, not just visual correctness.
- Isolate origin performance. Distinguish edge-served traffic from application execution.
- 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?




