Single-Page Apps
More than any other specialism here, the value I bring to single-page apps is often telling you not to build one. The SPA became the default way to build anything with a screen, and most of the time it’s the wrong default — a heavy, complex, SEO-hostile architecture applied to problems that wanted a server-rendered page. The people who bring me an SPA problem usually have one of two: they’re about to build something that shouldn’t be an SPA, or they already built one that shouldn’t have been and are paying for it. Both come down to one judgement call most teams skip.
The problems I solve here
The first is the SPA that’s about to be built by default. A team is planning a full client-side application for a product that’s mostly content, mostly forms, mostly conventional pages — because that’s how things are built now. I’m brought in before the money’s spent to ask the question nobody asked: does this actually need to be an SPA? Usually the honest answer is no, and a server-rendered approach with islands of interactivity would be faster to build, faster to load, better for search, and far cheaper to maintain.
The second is the SPA that was the wrong call and is now hurting. It loads slowly, search engines struggle with it, the bundle has grown unmanageable, and every feature is slower to add than the last. The work is to diagnose how much of it genuinely needed to be client-side and to map the cheapest route back — often moving the static and content-heavy parts back to server rendering and keeping the SPA only where the interactivity truly justifies it.
The third is the SPA that genuinely is the right architecture but was built badly. A real application — a complex internal tool, a live editor, a dashboard-heavy product — where the SPA was correct but the execution is fragile. There the job is to straighten the architecture, not to argue against the approach.
How I think about single-page apps
A single-page app is the right tool for a narrow set of problems: genuinely application-like interfaces where the user stays in one place doing complex, stateful, interactive work — editors, design tools, live dashboards, collaborative software. For those, the SPA model earns its weight, because the thing really is an application and behaving like one is the point.
For everything else — content, marketing, conventional product pages, most forms and flows — it’s overengineering with a real cost. You pay for it in slower first loads, worse SEO (search engines see an empty shell until the JavaScript runs), more moving parts, and a maintenance burden that compounds. The prevailing fashion treats the SPA as the modern default and server rendering as outdated, which has it exactly backwards: server rendering is the simpler, faster, more robust baseline, and the SPA is the specialist exception you reach for when the interactivity genuinely demands it.
So the only question that matters up front is whether you’re building an application or a document. Documents — anything you’d want indexed, anything mostly read rather than operated — belong server-rendered, with Vue or React added only on the interactive islands. Applications can justify the full SPA. Most things people call apps are documents in disguise, and getting that classification right before the build is where most of the money is saved.
How I’d actually do it
For most products, I’d build server-rendered pages and layer interactivity onto the parts that need it, rather than committing the whole thing to the client. That gives fast first loads, clean SEO, and far less to maintain, while still delivering every interactive feature exactly where it’s wanted. It’s the hybrid model, and it’s the right default for the large majority of products that aren’t genuinely application-shaped.
When a build truly is application-shaped, I’d still resist the maximal version. Start with the one core interactive flow, build it as a lean SPA, and grow from there rather than scaffolding an entire app framework for a scale that may not arrive. And in either case the data and logic stay on a backend you own — the front end is a presentation layer over systems you control, never the place your business logic quietly moves to live.
Where this connects
This is one of the specialisms I’m hired for. The SPA decision is really a front-end-weight decision, which is why it sits between React and Vue — the question of which, and how much, follows directly from whether you needed an SPA at all. When one was built wrong and stalled, the engagement is usually project rescue; when you’re deciding before building, it’s technical advisory. For the plain definition of the term rather than the judgement call, see what a single-page app is.
When you need a team instead
A large, genuinely application-shaped SPA under continuous development is team work — that’s my agency, Digital Royalty, with the crew to build and run it at scale. My lane is the call on whether you need one at all, and the lean build or the rescue. I’ll tell you straight which side of that line you’re on.
Who this isn’t for
If you’ve decided you want a single-page app because it’s the modern way and don’t want that challenged, I’m the wrong call — challenging it is the value I bring. I’m worth hiring when you want the honest answer about whether the architecture fits the problem.
Talk to me
If you’re about to build an SPA, or you’re stuck with one that’s gone slow and heavy, tell me about your problem. The most valuable thing I tell you may be that you never needed one.