In January 2026, we migrated the entire L'Équipe11 some context for non-French readers: L'Équipe is the biggest sports media outlet in France, serving millions of users monthly website from Nuxt 2 to Node.js and Vue 3. It's been 6 months since then, and I get asked a lot about our work during meetups and interviews: the why and the how. Though I'm always happy to chat about it, I think 15 minutes of me rambling without slides won't do justice to the whole thought process behind it. So I decided to elaborate here on the different points I can cover, and to reflect on whether it was the right call or not.
The context
Well, we ran on Nuxt 2 and Vue 2 for a long time. When Vue 2 reached its end of life on December 31st, 2023, followed by Nuxt 2 on June 30th, 2024, the migration question was no longer an if but a when. As a matter of good practice, it's best to always run on up-to-date technology. We had been thinking about moving since long before June 30th, but we hesitated. The website was already very big on its own, and we also had performance challenges. Our ad partners relied on us to keep everything available at all times. Any amount of downtime could mean losing a huge amount of money. So we needed to be careful.
Choosing island architecture over Nuxt 3
The default choice for a framework you use is to just upgrade it. And most of the time, that's the best idea. This was not one of those times. Nuxt 2 runs on Vue 2 and Nuxt 3 runs on Vue 3: it's a total paradigm shift, I'd say. There were countless war stories at the time of developers failing the migration, even on small projects. It's not only the framework but the whole Vue ecosystem around it, since many package authors didn't port their packages to Vue 3. As someone put it, it's a rewrite, not an upgrade. The Nuxt team built Nuxt Bridge for the migration, but at the time, it didn't get good reviews either. That doesn't mean we couldn't do it. But it meant we had to be extra careful about it.
The beauty of a rewrite is that we can actually explore other solutions. When it comes down to it, why not try something else entirely? We wanted to maximize performance, so we went to look at the other JavaScript frameworks designed for it. Nuxt 3 offered better performance, but the gain was incremental, and for some, even negligible. I think if we had gone that way, we'd have been more on the incremental side than the negligible one. But our aim was a dramatic result.
So, during our search, we landed on Astro and its island architecture.22 Astro made island architecture popular, but didn't invent it: the term comes from Katie Sylor-Miller at Etsy in 2019, and Jason Miller, the creator of Preact, popularized it in 2020. And once we understood the concept, we judged that it might be the best course of action.
The concept
This analogy is not perfect, but suppose it's 9 AM and you need to carry a 60 kg (~132 lbs) bag of rice on foot to a restaurant two miles away. They must start cooking at 10 AM. 60 kg is heavy for that distance. You may end up late. So you reason: they don't need all the rice by 10 AM, as they won't cook everything at once. They don't even have that capacity. So what if I split it into 3 bags of 20 kg? I'll go there with 20 kg, they can start cooking it, and I'll come back with the rest later.
The bag of rice is JavaScript. The restaurant is your browser. SPA frameworks tend to send the JavaScript for the whole page up front and hydrate all of it, even the parts that will never be interactive, so that navigating afterwards is fast. Though my analogy makes it look like one is better than the other, it isn't. It actually depends on your use case. Well, with a little bias sprinkled in. For us, as our CTO wrote, the data showed that most people were just reading one page, through a link from a web search or social media. So we only needed enough JavaScript for that page. I mean, even that is too much: we could get away with only the JavaScript for the content displayed in the viewport. Was that confusing? Let me try again with a picture:

This picture is your browser. The clear part is the viewport: it's what you see on the screen. Below the "fold" is what's hidden: you need to scroll down to get there.
What we do is think about the minimum it takes to show something in the browser. Some things don't need any interaction at all, just content. These don't need JavaScript, so they are generated on the server. Things like the article and the footer.
Then we decided to build the system on Astro's architecture, but specifically with Vue. Why not just use Astro, then? Everything we had was already built in Vue. With Astro, our pages and layouts would have become .astro files, with Vue only living inside the islands. We wanted the whole app to stay Vue, down to the page shell, and a system tailored to our platform.
Some things do need JavaScript, but only for a specific screen size. Since you don't need the mobile menu on desktop, you don't need to load its JavaScript there. So we give it an attribute we call client:media, meaning we only enable its interaction when the screen is the right size.
Some things need interaction as soon as the page loads. Buttons, for example, need to respond as early as possible, so we hydrate those first. That's why we give the component the client:load attribute.
On the other hand, there are the ones that can wait. Once the browser is done running everything else (big scripts, long calculations), it goes idle, and at this point, some non-urgent components can get hydrated. That's client:idle. I gave a carousel as an example, but it can also be buttons I know the user won't click the moment the page loads because they're for something specific, like the button I put in place for reporting errors in AI content.
There are also components that can't load on the server, as they need client-side things like window or localStorage. A famous example is a map: it needs a third-party library, so it can only load client-side. Hence, client:only. The standard here is to write client:only="vue", but since we decided to stick with Vue for the whole app, I didn't see much reason for the extra detail.
Last but not least, this is where the viewport matters, and it's my favorite of them all: client:visible. The browser doesn't need to hydrate something you don't see. In a default SPA, all of these are hydrated on load. But here, components with client:visible only get hydrated when they're actually seen.
Our reluctance
To understand what we were about to do, you have to understand how the browser and the server work from first principles. We knew all the blog posts and all the writing about it, but nonetheless, only a handful of major platforms had adopted it (The Guardian being one of them). Personally, I was confident about the concepts and yet unsure whether we might have missed something. If we messed up, the consequence would be a financial setback for the whole company for at least a whole quarter.
So we did the reasonable thing. We were 5 developers and the engineering manager. Since the developers all had their plates full, the engineering manager, Jean-Baptiste Labouré, set up the foundation of the project with a small PoC. We met often to discuss progress. All the developers, me included, were to test the PoC against their own domains to check for issues down the line. We integrated a few components in our spare time to test it. We hit a few blocking points, but with some collaboration and a little perseverance, we made it through. It went back and forth for months, as we had deadlines on other things.
Then came the moment of decision. We did a round table and discussed it. Most of us had been reluctant the day the solution was proposed. But we had been testing the PoC for a few months by then, and we had to get somewhere eventually. On decision day, we asked each developer their level of confidence. On a scale of one to five, no one reached five, but everyone was above average. My concern was the things we don't know that we don't know yet. So we decided to go forward and deal with whatever came. That's part of the job: always finding a solution.
And so we moved forward with the architecture.
How did it go?
When we decided to do it, we first assigned one developer to work on it full time, to spot any roadblocks and set up the basis of each domain. He worked on it for 3 months and resolved many of the issues at the foundations. Then we joined him and went all in from September 2025 to January 2026. As I expected, there were indeed some problems we only ran into once we had gone far enough with the architecture. For example, the live listing. It needed to update every 15 seconds, and for that to happen, we needed to refresh the list. The issue was that the list was the whole page container, so we had to refresh a huge portion of the page.
We used AI, but back then, it wasn't as good as it is now. Most of us were on GitHub Copilot, though one lead was already on Claude Code. So AI helped, but not as much as it would if we had to do the work today.
We released it on January 13, 2026. Even with all the testing, there was a sizable number of error reports over the next few days. Fortunately, nothing major around the ads. By the end of week 2, we had cleared 98% of the regression bugs. The remaining 2% were things we would only run into months down the line. We still keep the old website running on a server somewhere, to compare any inconsistencies. We plan to shut it down by the end of the year.
The results were phenomenal in terms of performance. I talked about it in one of my case studies. But not everything was sunshine and rainbows. The DX of the new architecture degraded to some extent. But that was a tradeoff we accepted. We had just created a very custom solution for a big platform. Frameworks like Nuxt have a dedicated team working specifically on the developer experience, to make sure it's pleasant to use. We didn't have that dedicated team, as resources were mainly focused on the project. Nonetheless, it's still a net positive thanks to the performance gain, and we've made slow but steady progress on the DX since then.
No major regressions really happened, but we had two memory leak issues: one fixed in February, and the other only recently, once we had Fable 5 to track down its origin.
Was it worth it? Absolutely, but I wouldn't recommend it to everyone. We had a specific performance challenge, and a rewrite was unavoidable whatever we decided. I'm always on board with taking the boring path. If something worked for most people, chances are it works for you too. If you hire me to work on your performance, I'll exhaust every standard method first before going for alternatives. But either way, it's a matter of choice. If flashy is your way, that can work too.
I hope you learned something here! If you need help with your project or have any questions, don't hesitate to email me. I'd be glad to answer.
Notes
some context for non-French readers: L'Équipe is the biggest sports media outlet in France, serving millions of users monthly
↩Astro made island architecture popular, but didn't invent it: the term comes from Katie Sylor-Miller at Etsy in 2019, and Jason Miller, the creator of Preact, popularized it in 2020.
↩
Did this post speak to you?
