Building to Scale: My Experience with Next.js and Vercel in Production

Editor’s Note: This blog is adapted from a talk by Roman Fedytskyi at the Next.js US Meetup. In his session, Roman drew from years of experience leading frontend engineering at Orson to share what it takes to build applications that scale globally. He walked through how hybrid rendering in Next.js, combined with Vercel’s edge capabilities, simplifies performance challenges and accelerates delivery, turning scalability into an achievable reality.

Hi, I am Roman Fedytskyi, Vice President of User Experience and Frontend Engineering at Orson, a FinTech company. Over the past eleven years, I have worked across the entire spectrum of software engineering—from building products for small startups to leading teams behind massive enterprise systems. I have seen how technology choices can make or break scalability, and one question has followed me throughout my career: how do we create applications that scale without sacrificing speed, personalisation, or user experience?

When I was invited to speak at this meetup, I knew exactly what I wanted to share: not just theory, but practical lessons from running Next.js and Vercel in production. This combination has transformed the way we build and deploy applications at scale, and I want to explain why it works—and why I trust it.

Let us start with the reality most teams face today. Older applications, designed in a different era, simply cannot keep up with modern demands. When traffic spikes unexpectedly, these apps often crumble. Servers slow down or crash under pressure, leaving users staring at error screens. And here is the truth: users do not care about your deployment struggles. They expect instant load times and flawless performance, whether they are in New York, London, or Berlin. Anything less, and they leave.

I have seen this scenario many times. Traditional server-side rendering and early single-page applications were considered breakthroughs when they launched. But today? They are struggling. Why? Because the expectations are completely different. People want personalisation, localised content, and experiences that feel built for them. A static page alone no longer cuts it. Your app needs to be dynamic, globally performant, and always available. Downtime is no longer an inconvenience; it is a business risk.

And it is not just about the user. Scalability also means keeping developer velocity high. If your architecture is slow to build, deploy, and maintain, you will waste weeks before a feature goes live. In a world where speed is everything, that is unacceptable.

This is where Next.js steps in. It gives developers a level of control and flexibility that was unimaginable a few years ago. Instead of forcing you to choose one rendering strategy, it lets you pick the right tool for each page. That means server-side rendering (SSR) for dynamic pages, static site generation (SSG) for content-heavy sections, and incremental static regeneration (ISR) when you need the best of both worlds—pages that are fast but can update without a full rebuild.

One feature I love is how simple routing becomes. File-based routing may sound like a small thing, but it saves enormous time and complexity. No endless configuration files—just create a page, and the route is ready. Next.js also comes with a set of performance boosters built right in. Image optimisation, for example, ensures your media loads fast without breaking layouts. And the middleware feature allows us to run logic at the edge. This is where it gets exciting: you can handle authentication, A/B testing, or regional personalisation before the page even loads.

In one of my projects, this flexibility saved us. We had product pages that needed to show accurate pricing, which updated frequently. A purely static approach would not work; a purely dynamic one would slow everything down. Our solution? We combined ISR with real-time updates. Pages stayed fast because they were static most of the time, but they refreshed in the background every 60 seconds. Users never saw stale prices, and the load on the server stayed minimal. This is what modern scalability looks like—smart strategies, not brute force.

Of course, a framework is only one part of the story. Deployment and hosting can make or break your scaling strategy, and this is where Vercel changed the game for us. With Vercel, deployment becomes almost invisible. I push code to Git, and within seconds, the app is live globally. No complicated pipelines. No manual server setups. It is deployment without the headaches.

Performance at the global level is also built in. Vercel uses a distributed edge network, which means users everywhere—from Asia to Europe—get the same fast experience. Features like serverless functions and edge middleware allow us to move logic closer to the user. This reduces latency and increases personalisation without stressing the backend.

Another thing I appreciate is how Vercel simplifies collaboration. Every branch, every pull request comes with its own preview URL. This may sound like a small detail, but it transformed the way our teams work. Designers, developers, and marketing stakeholders can review live changes without waiting for a staging environment to update. Feedback loops that once took days now happen in hours.

For me, Vercel is not just a hosting platform; it is a productivity engine. It eliminates the need for a large DevOps team and gives developers the freedom to focus on building features instead of wrestling with infrastructure.

Theory is nice, but the real question is this: how does it hold up when everything is on the line? Last year, we faced one of our toughest challenges—a global Black Friday campaign for a major fashion brand. The stakes were enormous. Millions of visitors from different regions. Multiple currencies and country-specific promotions. Zero tolerance for downtime. And on top of all that, the experience had to feel personal.

Here is how we handled it. For product and listing pages, we used ISR to keep performance high while refreshing data in the background. Middleware handled region-specific content, so customers saw the right currency and promotions without an extra round-trip. API routes—running as serverless functions—validated promo codes instantly, without us spinning up a separate backend. Every branch had preview links, so our design and marketing teams could approve last-minute changes without slowing the developers down.

The result? Over two million pages served in seventy-two hours. Near-perfect uptime. Blazing-fast load times even under the heaviest traffic. And all of this without an army of DevOps engineers or sleepless nights fixing deployment scripts. That is what scalability should feel like: invisible, reliable, and stress-free.

Scalability is not just a technical challenge; it is a people challenge. If your developers are frustrated, if they spend days fighting build errors or waiting for deployments, you are losing time and money. With Next.js and Vercel, we have reached a point where developers are genuinely happy with their workflow. Features move from concept to production faster. Bugs get fixed faster. And that speed translates into business value.

This is something I always emphasise: good tools are not just about code; they are about culture. When your team can ship confidently, experiment safely, and iterate quickly, your business moves faster. That is what Next.js and Vercel enable.

Sometimes I hear people say, “Next.js and Vercel are great for small projects, but are they ready for enterprise?” Let me answer that clearly: yes. Absolutely. Companies like Hulu, Nike, and Notion are using them to serve millions of users worldwide. These are not marketing sites; these are real products handling real traffic.

For me, this stack is not just a trend—it is a foundation for the future. It fits perfectly into modular architectures, and it plays well with modern development patterns like microfrontends. You can run it inside a larger system, split responsibilities across teams, and still keep deployments fast and safe.

So, if you are wondering whether these tools can handle your next big project, my advice is simple: try them. You will not just see better performance; you will feel the difference in how your team works. For me, that is what true scalability is all about—not just serving more users, but doing it with speed, reliability, and joy.

Feel free to connect with me on LinkedIn if you want to continue this conversation. Let us build applications that not only scale but excel.