It's time for modern CSS to kill the SPA

https://www.jonoalderson.com/conjecture/its-time-for-modern-css-to-kill-the-spa/

by tambourine_man • 12 months ago

744 492 12 months ago

andix7• 12 months ago

This reads more like "ditch Next.js" for traditional SSR.

A good SPA has a lot of benefits. Because it can be interactive like a native app. It can only use those benefits, if it is interactive to some extent (like gmail or google docs). Smooth navigation is a very bad reason for picking a SPA.

varenc2• 12 months ago

What do you mean by 'interactive like a native app'? The article is focusing on two main parts of making things feel like an app: page view transitions and speed/preloading. To me, those seem like a big part of what makes a site/app feel interactive. And letting the browser do the work and having real URLs has other huge benefits I appreciate.

But agree that for things like GMail, etc, a SPA approach definitely makes sense. I just think most SPA sites I come across aren't in that category.

andix7• 12 months ago

Imagine Gmail, ChatGPT, Slack, and so on as server side rendered websites, but with smooth transitions. This wouldn't work at all.

Let's take slack as an example. We had those chat websites 20 years ago. The thread was in it's own frame and got periodically reloaded. It's just bad UX.

nfw212• 12 months ago

Those aren't the main parts of feeling like an app. Feeling like an app means taking an action doesn't load a new page. Feeling like an app means the concept of a page mostly goes away.

ndr• 12 months ago

I'm against bloat as anyone, but to see a wildly different perspective check out what people working on local-first have been doing.

You can pay some upfront cost and have wildly more performant apps.

ozim3• 12 months ago

Rolling eyes

Another person mixing up web apps with web sites.

We do need frameworks for web apps. Yes people were wrongly making websites using frameworks.

But I am busy building web apps and without frameworks it is not feasible to build one.

andix7• 12 months ago

Exactly. I remember the times when webmail clients were SSR applications. Roundcube and Gmail were game changers. Webmail finally felt smooth and usable.

Web shops are somewhere in the middle, they need a little bit of interactivity for the cart, especially if the user opens multiple tabs.

But static websites should never be SPAs.

austin-cheney5• 12 months ago

You really don’t need the frameworks for web apps either.

andix7• 12 months ago

I guess you never worked on a complicated web app that was 100% jQuery, because web frameworks were not a thing yet.

micromacrofoot• 12 months ago

I support a lot of this, especially for sites that don't need to be applications... but SPAs aren't just about flashy transitions and persistent elements. If you've got a bunch of live data you want to change on interaction an SPA is still hard to beat.

sergiotapia• 12 months ago

This article would benefit from an example page to show how these "feel".

prisenco2• 12 months ago

Here are a series of demos. They work in Chrome or Safari.

https://view-transitions.chrome.dev/

Here's an older, more designed demo that only works in Chrome.

https://live-transitions.pages.dev

9dev• 12 months ago

Run this snippet from TFA in the console on GitHub:

  document.startViewTransition(() => {
    document.documentElement.dataset.colorMode = 'dark' // 'light'
  });

Then try to update the attribute manually instead, and compare the butter-smooth transition with view transitions vs. without.

austin-cheney5• 12 months ago

I completely agree.

My SPA navigation solution is just simple CSS toggle of display none/block and then force it on page load if there is a matching URL fragment. Total JavaScript to make this SPA navigation is about 20 or so lines of JS. Everything else is CSS and WebSockets. The state management is almost as simple.

zeroq3• 12 months ago

SPA is not only about seamless transitions but also being able to encapsulate a lot of user journey on the client side, without the need of bothering server too much.

Let me give you an example - one of my biggest gripes about web ux is the fact that in 2025 most shops still requires you to fully reload (and refetch) content when you change filters or drill down a category.

A common use case is when you come to a shop, click on "books" (request), then on "fantasy" subsection (another request), realize the book you're looking for is actually a "sci-fi", so you go back (request, hopefully cached) and go to "sci-fi" (another request).

It's much better ux when a user downloads the whole catalogue and then apply filters on the client without having to touch the server until he wants to get to the checkout.

But it's a lot of data - you may say - maybe on Amazon, but you can efficiently pack sections of most shops in data that will enable that pattern in less kilobytes that takes one product photo.

I've been building web apps like that since ca. 2005 and I still can't understand why it's not more common on the web.

throwaway77832• 12 months ago

HTMX (and similar) solves a lot of this. It so happens that we end up building two apps one frontend and one backend with SPAs as built today. I'd rather build a lot of it on the server side, and add some dumb interactivity on the client (show/hide, collapse/expand, effects). There is still a place for SPA though.

naet• 12 months ago

HTMX does the opposite of this, it requires many more round trips to the server instead of using client side JS to do work.

da_chicken2• 12 months ago

I don't know, I think the most painful aspect of having to do a full reload is how I efficient the site is. The actual data is a few KB, but the page itself has to download 100 MB and the web browser is burning through a GB of RAM.

Like I don't find Hacker News to be egregious to navigate, and nearly every nav is a reload. It runs fine on my 2008 laptop with 4 GB of RAM.

But I go to DoorDash on the same device, and it takes 30s to load up a list of 50 items. They give you a countdown for a double dash, and I genuinely don't think it's possible to order some curry and get a 6 pack of soda in less than 3 minutes. And 2.5 minutes is waiting for it to render enough to give me the interface. Almost none of it is a full reload.

cosmic_cheese2• 12 months ago

Yeah, the enemy isn’t the need to reload, it’s reloading taking a long time due to too much garbage that’s not the content the user is interested in having to come down off the wire and render. A site that requires an occasional split second reload is always going to be preferred to a behemoth that doesn’t need reloading but has me staring at blank screens and loading spinners half the time I’m using it.

nine_k2• 12 months ago

An SPA can be lean and fast. React is the prevailing Web framework today? Preact is like 5 KiB of code.

What makes SPAs unwieldy is not the technology but the lack of desire to optimize. It loads fine on yesteryear's Macbook Air? Enough, push it.

I very well remember heavy, slow-loading websites of, say, year 2000, without any SPA stuff, even though lightweight, quick-loading pages existed even then, in the epoch of dial-up internet. It's not the technology, it's the desire to cram in more, and to ship faster, with least thinking involved.

mym1990• 12 months ago

Hmm, I would say comparing Hacker News to DoorDash is not exactly apples to apples. There may also be ulterior motives to make a website slow(or at least not optimized) if the company wants to funnel people towards an app on the phone.

dzhiurgis4• 12 months ago

Gmail takes 3s to load. And HN is a website, not an app.

Aurornis• 12 months ago

But I go to DoorDash on the same device, and it takes 30s to load up a list of 50 items.
And 2.5 minutes is waiting for it to render enough to give me the interface.

I have a very old MacBook Air (one of the painfully slow ones) that I use for development reference for what a slow machine looks like.

I just tried clicking around DoorDash and didn’t see anything nearly this bad. Not even close.

Every time there’s a Hacker News thread about how slow websites are, there are dozens of comments like this claiming extremely large latency numbers. I can’t tell how much of it is exaggeration for effect, or if some people have configurations with weird quirks that make them abnormally slow.

I suspect it’s a lot of this:

on my 2008 laptop with 4 GB of RAM.

Sorry, but I don’t think it makes sense for companies to optimize their websites for computers that are nearly two decades old and don’t even have enough RAM to run a modern operating system.

The intersection between people who spend money on a expensive luxury service like food delivery to their door and people who won’t spend the cost of a couple DoorDash deliveries to upgrade from a 2008 laptop to a 2018 laptop in 2025 is negligibly small.

ec109685• 12 months ago

In almost all cases the back swipe in the spa resets you to the top of the page, navigating out of the app and back in doesn’t work, etc. It’s really hard to build a multi page spa that feels good.

dzhiurgis4• 12 months ago

Never thought about scroll position (tho SPA I’ve built recently I think does it ok). How do you solve it?

zeroq3• 12 months ago

It's funny you've mentioned that.

It reminded me of the time when I joined Wikia (now Fandom) back in, I think it was 2006. One of the first things that landed on my desk was (I can't recall the context) deeplinking.

And I remember being completely flabergasted, as I came Flash/games background, and for us that problem was completely solved for at least 4 years at the time (asual swfaddress package). I felt kind of stupid having to introduce that concept to much more senior engineers that I was at the time.

ndriscoll• 12 months ago

You can do that with checkbox selectors. e.g. see [0]. Note that I don't really do frontend and I asked chatgpt to vibe code it, so this may not be the best way to do it.

[0] https://html-preview.github.io/?url=https://gist.githubuserc...

crazygringo2• 12 months ago

Generally speaking, companies don't want you to download their entire catalog. They don't want competitors to be able to analyze it easily like that.

And if a store is selling books, it might have hundreds of thousands of them. No, it's not a good experience to transfer all that to the client, with all the bandwidth and memory usage that entails.

zeroq3• 12 months ago

That's really weak argument.

If it's one their website the competitors can write a simple crawler and create that catalog.

And you don't have to send every single field you have in your database. Once the user selects a category you can send a metadata that enable the client to scaffold the UI. Then you cache the rest while user interacts with the site.

Barnes and Nobles - according to their FAQ - has 1 million unique items in their catalog. But they also have tons of different categories. A single book cover weights around 30kb.

I'll leave it as an excercise to figure out how much data you can fit into 30kb to make usable filtering system.

btw: opening their front page downloads 12.1MB already.

hollowturtle• 12 months ago

Thing is, and I believe it's a valuable example counterpoint, if I shift-click on a link, like sci-fi category, to open it in a new tab(very common thing people do), having a multi page application is zero work added, on an spa you have to manage that. If the link doesn't exist and categories can only be accessed by a select input then ux isn't that great

paffdragon2• 12 months ago

This is so annoying when SPAs break browser functionality like open link in new tab. Even if it works often it has to reload a bunch of JS again, which makes things veeery slow. This is why I really don't like Linear, I often open issues in separate tabs, which is every time a pain, browser freezes for seconds just to open a link in a tab...

brulard5• 12 months ago

Modern SPA frameworks give you this by default. You can deep link and get the specific page with all the parameters/filters etc applied server rendered in remix/react-router, next, sveltekit and most other frameworks. I agree that too many apps have basic things like CMD+click broken

ThatPlayer• 12 months ago

In a similar use, a few of my hobby projects are hosted on static web servers. So instead of rendering out everything into individual pages, which would've been tens of thousands of pages, I have a JSON file that gets rendered by the client in a SPA. I have even used Github Pages for this

I'm playing around with a newer version that uses a sqlite database instead. Sqlite officially has wasm builds, and the database file is already built to be separated into pages. With HTTP Range Requests, I can grab only the pages I need to fulfill any queries.

Sqlite full text search even works! Though I'm hesitant to call that a success because you do end up grabbing the entire FTS table for shorter searches. Might be better to download the entire database and build the FTS table locally.

danielscrubs3• 12 months ago

Pjax was the goat.

Zanfa2• 12 months ago

Please no. Whenever I see an online store as a SPA catalogue I shudder, because it usually breaks after browsing a bit in a weird state. And it resets to somewhere random should you hit back, refresh or try to send a link to somebody.

lblume• 12 months ago

Yes, SPAs should store simple user state in the URL as well.

SenHeng• 12 months ago

It's much better ux when a user downloads the whole catalogue and then apply filters on the client without having to touch the server until he wants to get to the checkout.

This is what we[0] do too. We have a single JSON with a thousand over BOMs that's loaded directly into the browser. Previously we loaded the inventory data via an API as is usually expected. The fact that there's even an API meant requiring progress and loading bars, API unavailability scenarios, etc.

Having it all as a single preloaded JSON meant that all of the above goes away. Response is instantaneous.

[0] https://chubic.com

brulard5• 12 months ago

This wouldn't work for 90% of apps out there. While I would love that approach, it has so many problems that in practice it never worked out for me. First problem is that data change. Either you edit it, or you need updates from server applied to your copy. This is quite complex (although there are some solutions, I had little luck in making this work reliably). Second - you don't want to share the whole catalog in one request. Third - in most cases there is a lot of data. It's not uncommon to have tens of thousands of items and for each you likely need some kilobytes. Four - you are downloading the whole catalog even for deep links which might not care about all but a tiny fraction of that data.

isleyaardvark• 12 months ago

In my experience, state is the devil, and the approach of filtering things on the client moves a bunch of state management from the back end to the browser, which is the worst place to handle state.

kerkeslager• 12 months ago

SPA is not only about seamless transitions but also being able to encapsulate a lot of user journey on the client side, without the need of bothering server too much.

True, but as a user, I don't want you encapsulating my journey. You can wax poetic about hypothetical book categories, but the reality of SPAs is that they break back buttons, have terrible accessibility anti-patterns, attempt to control my attention, and expose my computer to all your bad security practices. SPAs usually contain half-assed implementations of half the features that ship standard in a modern browser, and the only motivation for all that effort is to make the site more favorable to the server's owner.

When a site is implemented with simple HTML and careful CSS, I can configure it to my needs in the browser quite easily. That's a site that favors me, not your opaque blob nonsense.

uxcolumbo• 12 months ago

Why is this being downvoted.

I agree, as user make it fast and don’t break the web. I see so many SPAs with bad usability, like back button not working.

A shopping site doesn’t need to be SPA.

A drawing app, 3D modeller, collaborative whiteboard, video chat, those type of apps fit the SPA model.

LegionMammal9782• 12 months ago

There's still value in web applications what can perform most of their operations client-side, when feasible. Lots of websites seemingly operate under the assumption of "If the client manages to connect to the server once, then surely it can maintain a stable, low-latency connection in perpetuity." This renders those websites unusable on flaky connections or with very high latency. Of course, plenty of SPAs are guilty of using 15 million unnecessary round-trips, but I worry that the current SSR-everywhere push will worsen this effect.

Cthulhu_5• 12 months ago

Consider also the origins of SPAs and their accompanying backends - mobile apps. I've worked with various projects where both web and mobile frontends would be using the same backend.

In theory you could build a SSR on top of that same backend, but for some reason that feels wrong, like an extra layer of indirection.

sfn424• 12 months ago

This works for some websites, not all. And often it results in significant loading times, because you're loading tons of unnecessary data. In many cases it is much better to send requests more frequently, similarly to how a server side rendered website would behave. Instead of fetching 10,000 products, just fetch a page of products. Much faster. Have endpoints for filters and searches, also paginated. This can be fast if you do it right. Since you're only sending minimal amounts of data everything is fast. The server can handle lots of requests and clients don't need a powerful connection to have a good experience.

Network requests themselves are not slow. Even a computer with a bad connection and long distance will probably have less than 500ms round trip. More like 50 to a few hundred at most. Anything beyond that is not the client, it's the server. If you make the backend slow then it'll be slow. If you make the request really large then the bad connection will struggle.

It's also worth mentioning that I would much rather deliver a good service to most users than make everyone's experience worse just for the sake of allowing someone to load the page and continue using it offline. Most websites don't make much sense to use offline anyway. You need to send some requests, best approach is simply to make them fast and small.

LegionMammal9782• 12 months ago

Network requests themselves are not slow. Even a computer with a bad connection and long distance will probably have less than 500ms round trip. More like 50 to a few hundred at most. Anything beyond that is not the client, it's the server.

Not if the client is, e.g., constantly moving between cell towers, or right near the end of their range, a situation that frequently happens to me on road trips. Some combination of dropped packets and link-layer reconnections can make a roundtrip take 2 seconds at best, and upwards of 10 seconds at worst.

I don't at all disagree that too many tiny requests is the cause of many slow websites, nor that many SPAs have that issue. But it isn't a defining feature of the SPA model, and nothing's stopping you from thoughtfully batching the requests you do make.

What I mainly dislike is the idea of saving a bit of client effort at the cost of more roundtrips. E.g., one can write an SSR site where every form click takes a roundtrip for validation, and also rejects inputs until it gets a response. Many search forms in particular are guilty of this, and also run on an overloaded server. Bonus points if a few filter changes are enough to hit a 429.

That is to say, SSR makes sense for websites with little interaction, such as HN or old Reddit, which still run great on high-latency connections. But I get the sense it's being pushed into having the server respond to every minor redraw, which can easily drive up the number of roundtrips.

Personally, having learned web development only a few years ago, my impression is that roundtrips are nearly the costliest thing there is. A browser can do quite a lot in the span of 100,000 μs. Yet very few people seem to care about what's going over the wire. If done well, the SPA model seems to offer a great way to reduce this cost, but it's been tainted by the proliferation of overly massive JS blobs.

I guess the moral of the story is "people can write poorly-written websites in any rendering model, and there's no panacea except for careful optimization". Though I still don't get how JS blobs got so big in the first place.

Izkata2• 12 months ago

In many cases it is much better to send requests more frequently, similarly to how a server side rendered website would behave. Instead of fetching 10,000 products, just fetch a page of products. Much faster. Have endpoints for filters and searches, also paginated. This can be fast if you do it right. Since you're only sending minimal amounts of data everything is fast.

This is actually a great example of what I mentioned elsewhere about how people seem to have forgotten how to make a SPA responsive. These are both simpler implementations, but not really the best choice for user interaction. A better solution is to take the paginated version and pre-cache what the user might do next: When the results are loaded, return page 1 and 2, display page 1, and cache page 2 so it can be displayed immediately if clicked on. If they do, display it immediately and silently request and cache page 3 in the background, etc etc. This keeps the SPA responsive with few to no loading spinners if they take the happy path, and because it's happening in the background you can automatically do retries for a flaky connection without bothering the user.

This was how gmail and google maps blew peoples' minds when they were first released, by moving data to the frontend and pushing requests to the server into the background, the user could keep working without interruption while updates happened the background without interrupting their flow.

codingdave• 12 months ago

SPAs make sense when your users have long sessions in your app. When it is worth the pain to load a large bundle in exchange for having really small network requests after the load.

Smooth transitions are a nice side effect, but not the reason for an SPA. The core argument of the article, that client-side routing is a solution for page transitions, is a complete misunderstanding of what problems SPAs solve. So absolutely, if you shared that misunderstanding of SPAs and used them to solve the wrong problem, this article is 100% correct.

But SPAs came about in the days of jQuery, not React. You'd have a complex app, and load up a giant pile of jQuery spaghetti, which would then treat each div of your app is its own little mini-app, with lots of small network requests keeping everything in sync. It solved a real problem, of not wanting to reload all that code every time a user on an old browser, with a slow connection, changed some data. jQuery made it feasible to do SPAs instead.

Later, React and other frameworks made it less spaghetti-like. And it really took off. Often, for sketchy reasons. But the strongest argument for SPAs remains using them as a solution to provide a single-load of a large code bundle, that can be cached, to provide minimal network traffic subsequent to the load when the expected session time of a user is long enough to be worth the trouble of the complexity of an SPA.

buffalobuffalo• 12 months ago

I don't know if a bunch of sloppy jQuery modules were ever really a viable option for an SPA. People tried to do it, sure, but I'd say the SPA era really started with backbone.js

kassner3• 12 months ago

ExtJS/Sencha was quite powerful and complete. I’ve built tons of SPAs with it in the late 00s.

dsego2• 12 months ago

I mostly remember doing $(document).ready blocks in php templates :)

PaulHoule6• 12 months ago

I wrote my first SPA, a knowledge graph editor, using GWT (Google Web Toolkit) which compiled a dialect of Java to JavaScript circa 2006 or so.

TimTheTinker2• 12 months ago

Low-bandwidth/spotty connections (combined with aggressive caching) are one of the strongest cases in favor of SPAs (emphasis on the A for Application, not website). Visit (and cache) the entire frontend for the app when you have a good-enough connection, then further use of the app can proceed with minimal bandwidth usage.

andix7• 12 months ago

Latency might even be more relevant than bandwidth. Especially if it's a good SPA, that uses optimistic updates (or sync), and some kind of caching for fetching data (tanstack query or similar).

cosmic_cheese2• 12 months ago

It really depends. There’s a lot of SPAs which are practically unusable on a bad connection simply because it’s a challenge to even get the whole thing loaded in the first place. There’s been several occasions where I’ve had poor cell connectivity and a huge chunk of the web was effectively off limits due to this.

So in addition to aggressive caching, I’d say keeping the app’s file size down is also pretty important to making it useful on poor connections. That’s frequently something that’s barely optimized at all, unfortunately.

throw-the-towel• 12 months ago

This is not true. In practice SPAs break completely when some network request fails which happens a lot on bad connections.

wolpoli• 12 months ago

Honest question: Where are the places with low-bandwidth internet? Are we talking about cruise ships and satellites internet use cases?

andersmurphy• 12 months ago

I think with brotli over SSE you can do just fine with 3G and bad networks without needing to be a SPA. Keeping almost all state on the sever make realtime collaborative apps much simpler than data sync you need with SPA. This demo has zero client side state and handles concurrent interactions over a billion data points [1].

- [1] https://checkboxes.andersmurphy.com

chaps2• 12 months ago

Is this true? When I think of old SPAs I think of java apps running in a browser. Those are definitely older than jQuery.

(I love this silly site for downvoting this question.)

chrisweekly• 12 months ago

Java applets are entirely distinct from SPAs, at least as that term is used in the webdev community.

threatofrain8• 12 months ago

Those apps came from an era when these terms weren't even coined yet.

pstuart• 12 months ago

I think of java applets as being more akin to wasm; SPAs were/are a collection of html that recreate the experience of a "plain old" html web site.

brailsafe• 12 months ago

Java applets and ASP.Net did have a superficial answer to this, as well as Flash, but they varied in terms of their ability to actually function as raw web interfaces using the URL to navigate between sections.

Being able to reliably and programmatically interact with client-side storage and the url, as well as improvements in DOM apis and commodification of hardware with more ram and faster faster CPUs, among many others factors, seem to have contributed.

kassner3• 12 months ago

ExtJS came about in the late 00s, and it was possible to build SPAs with it, overlay/draggable windows, and had powerful grid/form components.

Cthulhu_5• 12 months ago

and load up a giant pile of jQuery spaghetti

I'll have you know I spent time on organizing and structuring my code with early JS design patterns like IIFEs to limit scope, lazy loading of modules, and minification.

Anyway, in my experience, AngularJS was the biggest attempt at making structured front-end applications, and it really appealed / appeals (Angular is still very popular apparently) to Java developers; biggest ones was its modularization (which wasn't a thing in JS yet), dependency injection, and testability.

When we started out with an app in Backbone (to replace a Flex app because it wouldn't work on the ipad), I actually advocated against things like testing, thinking that the majority of functionality would be in the back-end. I was wrong, and the later AngularJS rebuild was a lot more intensive in front-end testing.

Of course, nowadays I'm repulsed by the verbosity, complexity and indirection of modern-day Angular code. or Java code for that matter.

aryonoco2• 12 months ago

Angular not only appeals to Java developers, it also appeals to .NET developers. TypeScript of course borrowed a lot from C# (having the same designer) and dependency injection, MVC patterns etc closely resemble .NET patterns.

Interestingly, new Angular is slowly moving away from these, introducing Signals for state management and standalone components, and I see these developers actually struggling a lot to adopt new Angular patterns.

Still, I believe Angular is a really great platform for building B2B or enterprise apps. It’s testing and forms handling is far ahead of every other SPA, and it actually fees like a cohesive framework where people have spent time designing things the right way; something I absolutely cannot say about react frameworks such as Next.js or Remix.

aryonoco2• 12 months ago

PS and I forgot to mention, new Angular patterns such as Signals and standalone components great cut down on the boilerplate and the verbosity. It’s not (and will never be) something like SolidJS, but each new version is clearly moving away from the heavy OO-based and multi layered patterns.

paradox4602• 12 months ago

Wasn't there the Google closure compiler before angular?

QuadrupleA• 12 months ago

Side note, sick of jQuery being always associated with spaghetti in the tech lexicon.

Any Turing-complete system is spaghetti in the hands of bad programmers. And simple & clear in the hands of good ones who know how to design.

sverhagen• 12 months ago

Languages... (is jQuery a language, I guess so, let's go with that)... live in a context... there is culture, tooling, libraries, frameworks. Some languages have good culture, some have bad culture. I guess it's not even so black and white: language have good or bad culture in different areas: testing, cleanliness, coding standards, security, etc. If jQuery is misused in the hands of bad programmers ALL THE TIME, that becomes the culture. Not much to do about it anymore once the concrete has set. You can't still be an exception to rules, good for you! But that doesn't change the culture...?

bobthepanda2• 12 months ago

Jquery is good for dom manipulation, though most of the best ideas have become vanilla javascript standards.

It isn’t really equipped or opinionated on statefulness, which means that everybody was at one point kludging stuff onto it that didn’t make sense.

PaulHoule6• 12 months ago

It drives me crazy when it used together with React —- I want to have one authoritative copy of the state of my app, and jQuery bypasses that, at least if I’m using controlled forms.

Now I used to hate uncontrolled forms but now I like react-hook-form.

jiggawatts4• 12 months ago

The real reason SPAs are popular is because JavaScript is the new Visual Basic and there are millions of developers that know nothing else.

Workforce market forces like that have a vastly greater effect than “bandwidth optimisation”.

My evidence for this is simple: every SPA app I’ve ever seen is two orders of magnitude slower than ordinary HTML would have been. There is almost never a bandwidth benefit in practice. Theoretically, sure, but every app I come across just dumps half the database down the wire and picks out a few dozen bytes in JS code. There's a comment right here in this discussion advocating for this! [1]

Another angle is this: if you had a top 100 site with massive bandwidth costs, then sure, converting your app to a SPA might make financial sense. But instead what I see is tiny projects start as a SPA from day one, and no chance that their bandwidth considerations — either cost or performance — will ever be a factor. Think internal apps accessed only over gigabit Ethernet.

I’ve seen static content presented as a SPA, which is just nuts to me.

[1] "It's much better ux when a user downloads the whole catalogue" from: https://news.ycombinator.com/item?id=44688834

geraldwhen• 12 months ago

Can’t hire for anything else. Competence in development no longer exists. And AI is making this march to idiocy worse.

dsego2• 12 months ago

And the frontend-backend paradigm has seeped into the engineering culture and even the non-engineers on the team understand things in those terms. The main way we break apart work into tickets is API endpoints and client-side UI stuff.

nemothekid3• 12 months ago

every SPA app I’ve ever seen is two orders of magnitude slower than ordinary HTML would have been.

I'd argue then you don't have an SPA. However I don't see how you could have a application like Figma or Discord and say "ordinary HTML is faster" (or even possible).

Zanfa2• 12 months ago

Does a real-world example of bandwidth saving even exist for SPAs? It’s always the other way around where what could’ve been a single page load, ends up being 6 separate asynchronous calls to different APIs to fetch random bits and pieces while the user stares at spinners.

mattbrewsbytes• 12 months ago

If you work at a place that has a modern CI/CD pipeline then your multiple deployments per day are likely rebuilding that large bundle of JS on deploy and invalidating any cache.

HTTP 2 has been adopted by browsers for like 10 years now and its multiplexing makes packaging large single bundles of JS irrelevant. SPA’s that use packaging of large bundles doesn’t leverage modern browser and server capabilities.

wldcordeiro• 12 months ago

Lots of SPAs now are code-split too for what it's worth so you shouldn't really have large bundles to download if you're splitting things well.

paulryanrogers2• 12 months ago

Is this true everywhere? Isn't much of the world still on slow mobile networks?

youngtaff3• 12 months ago

HTTP 2 has been adopted by browsers for like 10 years now and its multiplexing makes packaging large single bundles of JS irrelevant

H2 doesn’t make packing irrelevant… there’s still an IPC overhead with many small files… and larger bundles tend to compress better (though compression dictionaries might help here)

Large Js bundles are a huge problem though

jongjong2• 12 months ago

SPAs are nice when your app requires complex state; multiple rows of nested tabs, modals, multiple interlinked select inputs which load data dynamically, charts or graphs which can lazy-load data and update on the fly in response to user actions.

There is a certain level of complexity beyond which you need to load data on the fly (instead of all up front on page load) and you literally cannot avoid an SPA. Choosing to build an SPA is not just some arbitrary whimsical decision that you can always avoid.

Sometimes people just go straight to SPA because they're unsure about the level of complexity of the app they're building and they build an SPA just to be sure it can handle all the requirements which might come up later.

One of my first jobs involved rebuilding a multi-page EdTech 'website' as an SPA, the multi-page site was extremely limiting, slow and not user-friendly for the complex use cases which had to be supported. There was a lot of overlay functionality which wouldn't make sense as separate pages. Also, complex state had to be maintained in the URL and the access controls were nuanced (more secure, easier enforce and monitor via remote API calls than serving up HTML which can mix and match data from a range of sources).

I think a lot of the critiques of SPAs are actually about specific front end frameworks like React. A lot of developers do not like React for many of the reasons mentioned like 'resetting scrollbars' etc... React is literally a hack to try to bypass the DOM. It was built on the assumption that the DOM would always be unwieldy and impossible to extend, but that did not turn out to the the case.

Nowadays, with custom web components, the DOM is actually pretty easy to work with directly but info about this seems to be suppressed due to React's popularity. Having worked with a wide range of front end frameworks including React for many years, the developer experience with Web Components is incomparably superior; it works exactly as you expect, there are no weird rendering glitches or timing issues or weird gotchas that you have to dig into to. You can have complex nested components; it's fast and you have full control over the rendering order... You can implement your own reactivity easily by watching attributes from inside a Web Component. The level of flexibility and reliability you get is incomparable to frameworks like React; also you don't need to download anything, you don't need to bundle any libraries (or if you do, you can choose how to bundle them and to what extent; you have fine-grained control over the pre-loading of scripts/modules), the code is idiomatic.

Tokumei-no-hito3• 12 months ago

i remember seeing web components years ago, it sounds like they've improved a lot.

what do you do about the lack of (i assume) ecosystem? due to the ready ubiquity there's practically a library for everything. do you find that using WC you are having to hand roll a lot? i don't mean to be a package slave but for complex and tedious things like graphs / charts.

dannye2• 12 months ago

there are no weird rendering glitches or timing issues or weird gotchas that you have to dig into to.

Ehm... define the Web Component render blocking in the head, because you want to prevent FOUCs. Then try to access the .innerHTML of your Web Component in the connectedCallback

https://dev.to/dannyengelman/web-component-developers-do-not...

wild_egg5• 12 months ago

in exchange for having really small network requests after the load.

I'd love to see examples of where this is actually the case and it's drastically different from just sending HTML on the wire.

Most SPAs I've worked on/with end up making dozens of large calls after loading and are far far slower than just sending the equivalent final HTML across from the start. And you can't say that JSON magically compresses somehow better than HTML because HTML compresses incredibly well.

Most arguments about network concerns making SPAs a better choice are either propaganda or superstition that doesn't pan out in practice.

raron• 12 months ago

I'd love to see examples of where this is actually the case and it's drastically different from just sending HTML on the wire.

There are complete CAD applications running in browsers for PCB and mechanical design with many layers, 3D view, thousands of components, etc.

For example: https://easyeda.com/ https://www.onshape.com

because HTML compresses incredibly well

Haven't compression under TLS have been mostly disabled after CRIME and BREACH attack?

8n4vidtmkvmk5• 12 months ago

With HTML you have to send both the template and the data. With json, it's just the data. So it's less information total. It should compress a little better, but I don't have stats to back that up.

cheema33• 12 months ago

...if you shared that misunderstanding of SPAs and used them to solve the wrong problem, this article is 100% correct.

Agreed. The article was a frustrating read. The author is an SEO consultant. SEO consultants likely have a heavy focus on marketing websites. Actual apps and not marketing websites do benefit significantly from SPA. Imagine building Google Maps without SPA. You can animate page transitions all you want, the experience will suck!

Tokumei-no-hito3• 12 months ago

to be fair to both points:

he has a really warped view that SPAs are somehow purely about routing.

he does correctly point out that a lot of sites could and should be treated as sites not apps.

cosmotic2• 12 months ago

Google maps is a mess these days. Its glitchy, slow, has broken navigation, and is overloaded with unpredictable dynamic content. It's even worse in the native android app. Id totally go for the original version but with the more recent vector maps.

danielscrubs3• 12 months ago

I 100% would like to see an MPA Google Maps.

Being able to come back to a webpage with previous directions? I think it would be glorious.

thro1• 12 months ago

But SPAs came about in the days of jQuery, not React.

(viper.pl 2000, philips.pl 2001 .. - are.. 'unreal' ??

'µloJSON': https://web.archive.org/web/20020702120539js_/http://www.vip...

historised chained htmls restart onerror: https://web.archive.org/web/20020402025320js_/http://www.aut... )

jQuery 2006, React 2013

youngtaff3• 12 months ago

SPAs make sense when your users have long sessions in your app. When it is worth the pain to load a large bundle in exchange for having really small network requests after the load.

Only for certain types of applications… the route change time for many SPA’s is way higher than for the equivalent MPA

KronisLV• 12 months ago

SPAs make sense when your users have long sessions in your app.

SPAs also make sense when you want to decouple the front end from the back end, so that you have a stable interface like a RESTful API and once AngularJS gets deprecated you can move to something else, or that when your outdated Spring app needs to be updated, you'll have no server side rendering related dependencies to update (or that will realistically prevent you from doing updates, especially when JSF behavior has changed between versions, breaking your entire app when you update).

When it is worth the pain to load a large bundle in exchange for having really small network requests after the load.

The slight difference in user experience might not even enter the equation, compared to the pain that you'd have 5 years down the line maintaining the project. As for loading the app, bundle splitting is very much a thing and often times you also get the advantage of scoped CSS (e.g. works nicely in Vue) and a bunch of other things.

jbreckmckye4• 12 months ago

This article is full of misrepresentations and lazy takes. The author has had other anti-JS polemics widely upvoted on HN, which were just as carelessly written. But people upvote it anyway.

What is the cause of this?

1. Bad experiences with JavaScript apps that have aggregated complexity (be it essential or incidental complexity)?

2. Non-JS developers mystified and irritated at a bunch of practices they've never really internalised?

3. The undercurrent of "frontend is not real programming" prejudice that existed long before React etc al. and will continue to exist long after it?

cleoxjefbjxis• 12 months ago

You miss the whole point and the author is correct about this:

Modern CSS is powerful, and HTML is the way to deliver web content.

Every web framework is _literally_ a hack to make the web something it isn’t. People who haven’t seen the evolution often pick up the bad habits as best practice.

For thise JavaScript people, I recommend trying Laravel or Ruby/Rails. And then once you realize that JavaScript sucks you’ll minimize it.

j0rd72• 12 months ago

I find myself agreeing with the article (although I also agree that it assumes you've chosen an SPA when you shouldn't have). To add my own perspective:

I work on an app, the front-end of which essentially consists of 6 nav tabs, 3 of which show an index of records with corresponding add/edit forms. We don't have any hyper-fancy interactive components that would require heavy JS libraries. And yet... we develop in React.

Yesterday, I needed to add 1 new field (representing by a checkbox input) to both our app and a corresponding back-end application we have, which uses Rails views.

I checked the git logs after to see how long each took. The Rails view took me literally 2 minutes to update (add field to model, add field to controller, add input to HAML with a class on the parent div). The React view took me 52 minutes, plus I later found out that I'd forgotten a damn type on some interface that's a shallow copy of our model.

Is this a problem with React itself? Not really. But it's a problem in the way that it's used, and our 6 nav tabs and 3 forms don't need all the overhead of React. So for people in a similar situation, this article really rings true.

psychoslave• 12 months ago

That is considering that front end dev is necessarily implying js, which is exactly the erroneous premise one should try to dodge.

wredcoll6• 12 months ago

Non-JS developers mystified and irritated at a bunch of practices they've never really internalised

My current explanation goes something like this:

"I'm a smart guy. Front end development looks simple. If I find it hard to do, that must be the fault of javascript somehow"

benreesman2• 12 months ago

I don't know that there's "real" programming, that seems like a hard fight to fight on either side, it's like arguing about whether animals are conscious or something. Are people? Who knows, pass the blunt.

But there's been this really sharp over-correction to where now an obvious thing that is just common knowledge and that was never taboo is now considered impolite to even allude to. Frontend programming is among the easier kinds of software work as measured by the number of people who can do it? I bet if I tried really hard, I could probably be pretty kickass at pickleball, small court, not a lot moving around. But to be like, that's the same thing as the NFL. No, no it's not. I would never have been able to try out for the NFL, not if I live a thousand times.

There's pickleball and pro football in programming too.

reactordev• 12 months ago

I don’t know, I think reducing bundle sizes and bloated javascript in favor of built in support for view transitions warranted a blog post against one of the primary arguments for why SPA.

I agree with the author. I love React. I shouldn’t need two dozen more dependencies. We ditched server side for client side in 2010 for speed. Now that we have 200x more compute power, more powerful CSS, more robust html (with web components), we can go back to server side rendering and only send what’s required for the user at the time of action.

mdavidn• 12 months ago

Some of us have been building web apps since before Node.js existed, and we remember the problem that CSS was invented to solve.

hasanhaja5• 12 months ago

Are we aligned with the claims in the article that a SPA architecture is not a suitable baseline architecture for content-focused sites with shallow sessions (low number of interactions)?

twelve402• 12 months ago

When it is worth the pain to load a large bundle in exchange for having really small network requests after the load

...and yet, i keep running into web (and even mobile apps) that load the bundle, and subsequent navigation is just as slow, or _even slower_. Many banking websites, checking T-Mobile balance... you wait for the bundle to load on their super-slow website, ok, React, Angular, hundreds of megs, whatever. Click then to check the balance, just one number pulled in as tiny JSON, right? No, the website starts flashing another skeleton forever, why? You could say, no true SPA that is properly built would do that, but I run into this daily, many websites and apps made by companies with thousands of developers each.

jazzypants2• 12 months ago

Yeah, I see a lot of poorly written back-end APIs too.

layer84• 12 months ago

It solved a real problem, of not wanting to reload all that code every time a user on an old browser, with a slow connection, changed some data.

Why would the browser have to reload the code (JS files) on every page transition, with proper caching headers?

jazzypants2• 12 months ago

Click on a link on Amazon and take notice of all the kb of data in the head of every document that doesn't get cached.

camillomiller• 12 months ago

Not sure what kind of clients you work with, but in my experience this is actually accurate and you won’t believe how many times I had to put my hands and fix SPAs that should have been a static website to begin with. I think this is a consequence of a generation of webdevs, especially front-end, that graduated from bootcamps teaching them only JS frameworks and React as if that’s the only way the Web works. They were given a hammer, told how to use it, and everything then just looks like a nail.

tomhallett• 12 months ago

Depends on the definition of SPA, but in the days of jquery, I hardly consider any of that single page app. For example, the server rendered page had most of the html initial rendered, jquery would attach a bunch of listeners, and then on an update it incrementally. If lucky, we had a duplicated x-template-mustache tag which had a logic-less template that we could use to update parts. Jquery and duplication was the “problem” which drove everyone to SPAs.

matwood• 12 months ago

A SPA also makes it much easier to package your site into an app that you can put on the stores.

prisenco2• 12 months ago

The View Transitions API is beautiful and I can't wait for it to become widely available.

I've soured on SPAs in the past few years. So much more can be done with standards than people realize. SPAs were best for specific use cases but we made them the default for everything. Marketing pages are built in React! Basic pages with marketing copy have a build step and require hundreds of megabytes of dependencies.

Like the author I've transitioned to a mantra of "let the web be the web."

But we have a whole generation of developers and designers that have come of age with SPA and mobile-like ux as standard. Getting everyone back to basics and understanding hypermedia, markup languages and cascading styles is a big ask.

725686• 12 months ago

"The View Transitions API is beautiful and I can't wait for it to become widely available."

a few comments below

"The view transitions API is a disaster."

I love HN.

revskill• 12 months ago

i hate it.

dickersnoodle• 12 months ago

Less is more, usually.

nosefurhairdo• 12 months ago

This argument is tired and ignorant. Try building linear.app without a SPA framework. The idea that "Native CSS transitions have quietly killed the strongest argument for client-side routing," is dubious at best.

0xCMP• 12 months ago

This doesn't seem fair to say. Linear is special even among SPAs; it's by far not the norm. No one said "ban SPAs and remove javascript from the browser".

Linear's speed comes from being "offline-first", but I challenge you to name almost any other product in common usage that does it that way. It's just not common. On the other hand if I want to buy tickets I'd rather most of that website be SSR and do SPA where you actually still need it. Or forums, news sites, blogs, and informational sites.

There is so much out there that would be better developed with SSR and then use CSS to make it feel SPA-like than to actually be a SPA.

nfw212• 12 months ago

The article's title is it's time to kill SPAs

epolanski5• 12 months ago

No one said SPAs have no place, but 99% of websites out there don't need to be one.

zarzavat2• 12 months ago

SPA means single page app. For example, Google docs, Figma, Google calendar, etc. Apps that use web technologies instead of being native apps.

A long time ago some webdevs started abusing the SPA concept to build simple websites. However that is not within the original meaning of the term SPA, because simple websites are not web apps. The author assumed that everyone would just understand that they are talking about SP"A"s and not SPAs, because for a certain subset of webdevs working on websites, the antonym of SPA is MPA, and it's normal to refer to your website as an "app". However for a certain other subset of webdevs, the antonym of SPA is simple website, and what the author is talking about are not SPAs at all.

nfw212• 12 months ago

What does it's time to kill SPAs mean to you other than they have no place.

unsupp0rted• 12 months ago

One of the reasons people like SPA so much is componentization.

Here's my header component, and all its scoped CSS, and here are the 5 subcomponents that make it up, and all their individual scoped CSS.

Page transitions are 0.001% of the desire to go the SPA route.

TheRealPomax• 12 months ago

Fun fact: custom elements exist. They're just as hard to work with as React components (i.e. complete nonsense until you stop fighting them and do it right). Except they don't violate the browser model and don't require you to be married to a specific framework.

threatofrain8• 12 months ago

I don't know what universe this SEO-consultant author lives in. The author gives Next & Nuxt as an example of the kind of frameworks going against his prescription, but that is so wrong.

1. Next won the war in the west, big time. Very very big time. Whenever people talk about new React apps they inadvertently mean Next. On the Vue side Nuxt is the default winner, and Nuxt is just the Next of Vue. That means that by default, by reflexive instinct, people are choosing Next and MPA as their strategy. If you want to correct the overly extreme pendulum motion then you should be telling people to try out SPA. The last 8 years has been a feverish push for MPA. Even the Facebook docs point straight to Next, totally deprecating Create React App. This is also Facebook ceding their battle to Next.

2. Whenever people complain about the complexity of Next, they are complaining about the difficulties of cutting edge MPA strategy, which evolves on a year to year basis. SPA on the other hand is a story that has frozen in time for who knows how many years. Almost a decade?

3. Doing MPA is strictly harder than doing SPA, much much harder. You have to observe the server/client distinction much more closely, as the same page may be split down the middle in terms of server/client rendered.

4. If you're writing an SPA and want to be more like MPA and load data at the time of hitting a user-navigable endpoint, that's on you, benefits and costs and all. You can also load data with anticipation so the client navigation is basically instant.

5. For every sexy SEO-able front-facing property you're going to have many teams with internal apps or dashboards backing that front-facing property. That's where many React devs are employed. Do not unnecessarily take on burden because you're so eager to ship the first "frame" of your app in a perfect way.

ivape4• 12 months ago

There was a war? News to me. Saying Next won is like saying React won. Nothing won, everyone just latched on to what they thought the crowd vetted. The blind can't lead each other. Most people that stuck to Angular or minimal or no-frameworks are truly wondering what the fuck are all these people talking about?.

Even the Facebook docs point straight to Next

Startups and SV jerk each other off by promoting each other (think affiliates). None of it means shit.

Next is probably a garbage framework, but it's people's livelihoods. It's very hard to erase something that literally defines people (yes, your resume is YOU).

threatofrain8• 12 months ago

Startups and SV jerk each other off by promoting each other (think affiliates). None of it means shit.

No, this is FB ceding the battle. They absolutely didn't want this. They dropped CRA because social media celebrities were shitting on CRA. Dan Abramov had to do a complete 180 in a single day, after writing a long thoughtful essay in defense of CRA.

frollogaston4• 12 months ago

Kinda is a war unless you're working solo, cause you're gonna get forced to use something or another. When I tried a few solo web projects instead of just being a backend guy, I picked up React on my own because it was the only thing that makes sense. The page does what the code says. And that was after trying other things.

Now I gotta occasionally use Angular, and it's boilerplate hell. Adding one button involves editing 30 classes and files even if you don't use templates. I took a course at work where even the instructor got confused adding a button. Why would anyone ever use this besides Google, or do they even use it?

brulard5• 12 months ago

How did next win the React framework war? Is it not few years already that see exodus from next to remix/react router, and more recently to tanstack start etc. because of unnecessary complexity, difficulty to run next on anything but vercel, misguided API changes etc.?

You mentioning facebook docs pointing to next, when they explicitly mention remix and other is quite misleading.

threatofrain8• 12 months ago

Well, you must know how to look at download stats, search metrics, GitHub activity, social media temperature, or job posts. I feel that seeing is believing with your own eyes is sufficient for anyone who wants to investigate the issue of whether there’s any winner in popularity.

To not be misleading I wouldn’t have brought up the existence of remix lest people think Microsoft belongs in the same discussion as my software consultancy.

To be clear I’m using Tanstack Start right now.

jbreckmckye4• 12 months ago

I don't know what universe this SEO-consultant author lives in.

After looking over the author's blog I can see

1. Very high output

2. Lots of AI images

3. Weird writing and editing lapses in several posts

I am moderately confident this post was written with an AI. It may not be totally AI produced, I think the author has probably edited the work, but I think we are mostly debating synthetic content.

lunarcave• 12 months ago

I don't know how I feel about this one, honestly.

Build a site like a site. Use HTML. Use navigation. Use the platform.

Sure, but what about all the other problems that aren't solved by View Transitions? There's some truth to the fact that frameworks like Next.js has jumped the shark. But they're not solving the problems of _just_ the SPA.

ivape4• 12 months ago

Websites and apps that feel like quality are generally made by people who can achieve it. You'll get shit static sites or shit SPAs if you have shitty devs. It's not beyond reason. If you are shitty chef, your food is going be shitty. So yeah, here's the big secret about programmers:

They are mostly shitty

---

Interestingly, every landing page or website for recent AI apps have looked AMAZING. Designers and standard website developers are totally on point. It's just, crappy developers who can't create a rich experience on top of incredible design that's the issue. CSS is not going to fix what can't be fixed (some people are not supposed to be in this profession, but hey, it pays ... for another three or so years).

calvinmorrison• 12 months ago

SPAs and packaging your app inside a chrome container needs to die a hard death. Why is everything in 1 window. Why in 2025 can i not have multiple chat windows open?

davidfiala• 12 months ago

SPAs are not about view transitions. TFA implies that fancy transition is important between pages (wrong!) and blames a "CMO" or "brand manager" rather than challenging their own preconceptions and exploring the value an SPA does add:

- excellent frameworks for client side logic (interactivity) - separation of concerns (presentation logic vs. backend) - improved DevEx => inc. speed of development => happiness for all

The sad thing is that an article like this will get plenty of eyeballs due to comments like my own adding to the algo, but it should have never made it above the fold.

CSSer• 12 months ago

It's because it's catchy and repeatable, which really fits with this guy's broader claimed focus (SEO). I found it really ironic because I've built plenty of SPAs without page transitions of any kind (because it wasn't a relevant requirement) and only started adding them because view transitions made them easy.

racecar789• 12 months ago

What does TFA stand for?

Contax• 12 months ago

Among others (e.g.: "trans fatty acid"), in this particular case either "today's featured article" or "the f**ing article". I guess the latter.

jenscow• 12 months ago

Page transitions aren't the reason we're creating single page web apps

epolanski5• 12 months ago

I'm fully convinced that it's time to kill SPAs on 99% of websites and that the community is too defensive on the topic.

kavok• 12 months ago

It’s because the people that built and maintain the SPAs were beat into submission with the “SSR” bad message. Now people want them to do SSR again.

Cthulhu_5• 12 months ago

You're kind of already answering your own statement; websites should not be SPAs and vice-versa. Personally I think that an SPA should be something that lives behind a login.

MentallyRetired2• 12 months ago

I agree. SSR that hydrates to an SPA is a pain in the butt and not necessary most of the time. This is why I favor something like Astro for websites... I can drop in a react embed when I need to. It's just a right-tool-for-the-right-job situation imo.

woutr_be• 12 months ago

I absolutely love Astro, and it's my default for new projects. And I honestly feel like it's the only framework using React/Vue for their intended purposes; which is as an interactive layer on top of your SSR UI.

yoz-y• 12 months ago

For me the promise of SPAs has nothing to do with fluidity and all to do with having a separate data API and separate frontend (that can be native or web or both)

That’s why I don’t like SSR mixed with client side rendering. Either do a website or an app.

mexicocitinluez2• 12 months ago

Not just for you, but for most people.

The author of this article is making shit up to justify writing an article where they can show of their CSS skills. It's lame and dumb.

markbao• 12 months ago

The point of SPAs was never page transitions. I can’t name a single major SPA that does good page transitions, can you? They all just replace the content. And to take a popular SPA framework as an example, it’s almost impossible to do page transitions in Next.js because of the way routes are loaded. I know this because I added proper page transitions to Next.js and it has been an absolute nightmare.

There are two good reasons for SPAs that I can see:

1. Your app probably needs interactivity anyway; for most apps, it’s not just going to be HTML and CSS. Writing your app in some unholy combination of React and HTML is not fun especially when you need to do things like global state.

2. Loading the structure of pages up front so that subsequent data loads and requests are snappy. Getting a snappy loading screen is usually better than clicking and getting nothing for 500ms and then loading in; the opposite is true below I’d say 100ms. Not needing to replace the whole page results in better frontend performance, which can’t really be matched today with just the web platform.

Basecamp has probably invested the most in making a fairly complex webapp without going full SPA, but click around for like 30 seconds and you’ll see it can’t hold a candle in performance to SPAs, never mind native apps.

With that said, I agree that I’d want the web to work more like the web, instead of this weird layer on top. All the complexity that Next.js and SPAs have added over the years have resulted in more responsive but sometimes more tedious-to-build apps, and gigantic bundles. I just don’t think you can match the performance of SPAs yet with just HTML.

causal• 12 months ago

3. APIs. If you already have a client facing API for your iOS and Android apps, and maybe one for developers, a SPA is just another app to plug into that backend.

pas2• 12 months ago

tiny correction Next is not an SPA (you can in theory write one using NextJS, but by default it's an MPA with aggressive prefetch)

gizzlon3• 12 months ago

Basecamp has probably invested the most in making a fairly complex webapp without going full SPA, but click around for like 30 seconds and you’ll see it can’t hold a candle in performance to SPAs

Really? I just started using it, and it feels fast. Most SPA's are slow and/or buggy (in the "fails to mimic real browser behaviour" kind of way)

rossdavidh• 12 months ago

I once worked at a place where (for involved reasons not worth rehashing for this conversation) some of the backoffice, admin pages got rewritten in SPA fashion, after they had already been written in server-side fashion. It was an accidental experiment that showed me that the backend code did not decrease in size, whereas the frontend ballooned up to the same size as the backend (for fairly simple functionality even).

Now, this means you will need approximately twice as many developers. On the plus side, more work gets done on the client-side, so you probably need fewer servers for your billion users, and you may save in servers (and sysadmins) more than it costs you in developers to handle approximately twice as much code.

Except...99.9% of the shops using SPAs don't (and never will) have enough traffic for that tradeoff to make sense. The devs want (or at least wanted, back in the day) to go work at a company that did, so they wanted to use tools that would make sense if you're Facebook-sized. But, for the great majority of shops that made SPAs, there was no good reason to do so. This isn't Facebook's fault, but it is a reason why SPA's are annoying to so many people; they are almost always used in places that don't need them, and shouldn't be using them, in order to pad out a resume.

Cthulhu_5• 12 months ago

Cost is one factor, but what about user experience? Rich front-ends that users spend a lot of time in can save them time and the company money. Case in point, I work at a company where one team works on the front-end for customer support employees. They have to run through certain legal processes from time to time, like sending customers emails with contracts and the like, or looking up various data from various services. Their efforts have helped save these agents a lot of time, and part of that is putting more and more into a rich, clear and convenient front-end.

Of course, a lot of the effort also went to tying together various systems, replacing outdated ones, developing smarter and better chatbots and voice bots to guide users towards answers or self-service, etc.

sfn424• 12 months ago

I completely agree that SPAs are overused, but I also disagree that they necessarily balloon in size. An SPA is supposed to be a view, it is only supposed to concern itself with view logic. People just overcomplicate them endlessly with unnecessary crap.

ConstrPlus8561• 12 months ago

Any website that is an app is going to need SPA like features.

Especially if they have some kind of AI integration feature.

andrewstuart3• 12 months ago

The view transitions API is a disaster.

I spent weeks trying to get it to behave predictably and failed entirely.

Don’t use this api if you value your sanity it’s the worst api I’ve used in a browser.

wizzwizz4• 12 months ago

What particular issues have you experienced?

andrewstuart3• 12 months ago

It’s extremely hard to use reliably.

Anyone enthusing about this API hasn’t done much with it.

game_the0ry• 12 months ago

CSS is uderrated and almost never even discussed in front end interviews. Its all javascript javascript javascript.

Javascript is over-rated.

CSS > JS

Cthulhu_5• 12 months ago

I don't know if CSS is underrated, but it's definitely a speciality that a lot of software developers don't (want to) specialize in. It's like the front-end equivalent of SQL; so much is possible in SQL, but most logic is built in application code because SQL is scary.

nfw212• 12 months ago

Most logic is built in application code because it makes it easy to structure, reason about, and test. Developers should be scared of code that is hard to test and reason about.

briandw• 12 months ago

Sounds like the major complaint here is trying to make the web into something it's not. It's something like 17 years since the iPhone app store. Web apps were not comparable to native apps then, and while they've made progress, web UX is still much poorer than a good native app. The Youtube mobile app has its problems but is so much better than the web interface.

Native and web have different strengths, that's ok.

SoylentOrange• 12 months ago

I’d like to add to the reasons for why you want an SPA over something with SSR:

* You have a large number of users compared to your resources and you can’t afford for your user base to always hit your server. Comparatively, deploying API-only apps is far cheaper when you’re resource-starved (eg early stage startup).

* You don’t care about SEO, for example you’re building internal tooling. You then don’t need to care about hydration at all. Much simpler to separate concerns (again esp at the beginning).

* Offline mode (eg PWA or reusable code in Electron) or cases where you want to be resilient to network failures. In the case that your app is dependent on the server for basic functionality like navigation, you can’t support any type of offline mode.

suralind• 12 months ago

Great post. Didn’t know about these new features.

yahoozoo• 12 months ago

lol who even used SPAs because of “smooth transitions”? I’ve never noticed anything resembling a transition on any React/Vue site

ninetyninenine• 12 months ago

The reason SPAs became the default wasn’t because they were better. It was because, for a while, they were the only way to deliver something that felt fluid – something that didn’t flash white between pages or jank the scroll position.

This was NOT the reason why.

SPAs are better because it offloads as much processing as possible to EDGE cpu's. The idle compute among all users aggregates to a massive amount so might as well use it and minimize html construction and routing on the server side.

pawelduda• 12 months ago

When SPA framework in CSS?

karaterobot• 12 months ago

A lot of people are responding with other technical considerations that may lead you to consider using an SPA pattern. But, note that the article is about responding to the stakeholder's request that it should 'feel like an app', and his point is that you can make it feel like an app without being an SPA. Non-technical stakeholders rarely bring up deep technical considerations, they almost always talk about what something should feel like. So, I think his argument, while unlikely to work on anybody, is valid.

dusted• 12 months ago

but is it ever going to be time to kill the CSS ?

gerdesj2• 12 months ago

"... someone says the words. A CMO. A digital lead. A brand manager. ... it’ll be an SPA."

Why not spell out CMO and SPA and a civilian such as myself will not have to toddle off and dig out a search engine?

If you are going to get all assertive and pissed off, please be inclusive too.

MentallyRetired2• 12 months ago

The problem is he's confidently wrong in believing Single Page Applications are about page transitions. Not at all. It's more about keeping state and an application-like experience. Like playing a song on spotify and changing to the search page and the song keeps playing... that type of thing.

gerdesj2• 12 months ago

Thank you for giving me a starting point to work with.

FFS, I have a degree in Civ Eng but if I start wittering on about bridges and roads I will define abbreviations. Its common courtesy.

With regards your analogy involving Spotify: I ripped all my CDs to FLAAC some years ago. The tapes and records took a little longer. No idea what a Spotify is. Well I do, I'm an IT consultant, but I don't actually care, I'm a 50 something IT consultant! I bought my music years ago and listen to it on my gear and from my gear alone.

This SPA thing sounds like it is getting out of hand and it also sounds like there are tribal divisions being drawn up. IT does love a tribe! We even have multiple internal tribes: devops, webdev and so on.

I'm nominally a PHB ...

fleebee2• 12 months ago

It's worth noting that the Speculation Rules API and the View Transition API are not stable in Firefox and therefore aren't supported by all major browser.

fcpguru• 12 months ago

yeah, if it's not in firefox it doesn't count.

https://bugzilla.mozilla.org/show_bug.cgi?id=1823896

also mobile safari so basically all iphones.

bornfreddy• 12 months ago

Basically it is supported just in Chromium & derivates then. Hard pass.

mattvr• 12 months ago

It does appear to be supported by iOS Safari 18.2+, which is the majority of iOS users.

https://caniuse.com/?search=view%20transitions

ethan_smith• 12 months ago

This browser compatibility gap is a crucial point - without Firefox support, these APIs can't be considered production-ready for sites that need cross-browser consistency, undermining the article's central argument.

adamredwoods• 12 months ago

For me, this is the key takeaway from the article, leveraging experimental browser extensions for preloading future pages. In other words, exactly what a properly thought-out SPA does.

Hackbraten• 12 months ago

The site feels so laggy on my mobile browser that I had to stop reading. Looks like CSS is not inherently performant.

davidbanham• 12 months ago

I was completely unaware of view transitions and speculation rules. All of my products are server rendered for speed and simplicity. It’s amazing how snappy the interface is when your pages just load quickly because your software is performant. These seem like a great way to add an extra 10% of flavour.

niutech4• 12 months ago

I agree. What is more, you can even use HTMZ instead of JS frameworks and Pure HTML Out-Of-Order Streaming using Declarative Web Components: https://github.com/niutech/phooos

jfvinueza• 12 months ago

The thing about SPAs is that computation can be done in the customer's machine. That usually makes it worse for everyone, both devs and users (although sometimes it doesn't). I personally believe that we can create better experiences routing more pages with more imagination, but at times this industry is quite vocal on what "user expectations" are.

andrewaylett• 12 months ago

What counts as "SPA" and what's an "MPA"? I've got a NextJS site (my personal website, you can probably find it given you know my last name and that I'm in the UK) that renders pretty much everything server-side. Technically it's still an SPA because if you turn on Javascript it'll load RSC and do client-side navigation.

If you turn off Javascript? Pages with client-only components (like the 100% client-rendered QR code generator) will show their fallback, everything else will load and render perfectly -- if a little less quickly -- than if you let Next do its thing. It's all rendered into the HTML, and it's actually more effort to not render components on the server. Progressive enhancement for the win!

skydhash• 12 months ago

What counts as "SPA" and what's an "MPA"?

By how many times the Window's load event fire for your app.

etchalon• 12 months ago

If you think SPA's became the dominated architecture because of page-to-page transitions, I'm not sure how to have a productive conversation with you.

onehair• 12 months ago

Props for teaching me about View Transition API.

Absolute disagree with the way you're arguing though.

867-5309• 12 months ago

Single-page Application

rezmason• 12 months ago

The author looks like Edward Norton.

"I am Jack's native declarative transition."

jmull• 12 months ago

The author is living in some crazy land bubble... or I am.

I can't relate to the situations, problems, or solutions this article seems to just take for granted.

user3939382• 12 months ago

If full page requests have an ability to persist complex state, cache to the point of imperceptibility parts of the page that aren’t changing and never blink, I guess?

jraines• 12 months ago

I wonder if my slop radar is oversensitive to em dashes and the construction: “it’s not just about foo, it’s about bar” because this post seems human written but the indicators are flashing

Anamon3• 12 months ago

There are also many non sequiturs. The sentences only read fine if you don't think about what the author might be trying to say. I also think that this reads like the "author" was an LLM and, therefore, isn't trying to say anything.

À propos of nothing – I'm human and I like using special characters, including en dashes. ;)

wyuenho• 12 months ago

I swear if I see another "SEO" guy or some rando web dev who joined the workforce after Covid complaining about SPAs by misrepresenting it, I'm gonna explode.

As someone who's been developing web apps since the 2000s, let me tell you the origin of SPA has few things to do with the "false promise of SPAs" he listed, but largely due to companies in the late 2000/early 2010s wanting to go "mobile first". This usually meant they still had a desktop second somewhere, which implied they were architecting the entire system to completely separate the frontends and the backend.

Before, what web devs meant by frontend was essentially server-side rendered HTML templates with perhaps a little bit of jQuery running on the client-side. Now, since mobile and desktop web apps are to share some business logic and the database somehow, people had to rediscover REST by reading Roy Fielding's Phd dissertation that inspired the original HTTP. This meant now every company was moving to service-oriented architecture and started exposing their backend APIs onto the open internet so their mobile apps and SPAs running in the browser can share the same APIs. This was a cost saving measure.

This period also coincided with the steady decline of full-stack webapp frameworks like Ruby on Rails and Django because for a couple of years, these frameworks had no good ways to support an API only applications. Django hadn't even reached 1.0 back then. This was a time when NodeJS was really starting to pick up momentum. Once people had started being more comfortable with JS on the server-side, lots of people suddenly realized they could push a lot of business logic to increasing powerful desktop browsers and phones, application hosts people now call "edge devices".

This is the true impetus of SPA. How is CSS going to kill this need?

incomplete• 12 months ago

i see "SPA" and my mind immediately reads that as "special purpose account" lol.

fnord77• 12 months ago

there's lots of SPAs that look like normal web pages. Twitter for instance.

bpev2• 12 months ago

Most of my personal app projects are SPAs, because it’s easy to just pop some static files in my static file server and serve a whole app with routing and functionality without having any server logic. Way simpler to maintain, since I can just sync my ‘apps’ dir and all my mini-projects are deployed.

wordofx3• 12 months ago

Can do all that without a SPA.

bpev2• 12 months ago

Not really... like sure if you want a static site, but I'm talking about static apps. Like if you want to handle /id/$id routes with data based on user-generated content saved in localStorage... you'll have to handle routing somewhere. Basically, what I'm saying is that if you have an stateful app that doesn't require server state, I think SPA+PWA is pretty ideal.

diegof79• 12 months ago

Ok, now try to implement a tree component in an MPA. But not a crappy tree component that only opens one branch at a time, like in a page from 1998. A tree component that remembers the open/close state of each branch.

Before the SPA, these were common issues. That’s why there were a gazillion Java server pages frameworks to solve them. You also have frameworks that tried to encode the UI state in some way. My favorite was Seaside, which used continuations to store the UI state.

The following article should probably be titled “It’s time for modern bloggers to kill the clickbait titles” and discuss the trade-offs of each architectural decision more balancedly.

dkarl• 12 months ago

I think this article is unfair to SPAs. SPAs are a lot more effort, but they are better. For a long time they have been the only way to "make it feel like an app." (I think the author says "make it feel like an app" because they know we all resent app fatigue, all the apps we have to download that should just be web sites, but I think we also all know that when something really is an application, it's rare for a "web app" to match the experience of a local native application, and an SPA is the only way to make a sincere attempt.)

The comparison of bloated SPAs with lean web sites is bogus. If someone takes the effort to make their web site lean, they'd do the same with an SPA. If someone makes a slow, bloated SPA with megabytes of Javascript, they'd make a slow, bloated web site with megabytes of Javascript. I think we've all seen enough of the web to know this is true.

I click on articles like these because I've seen the effort that goes into a good SPA, and I'm interested in anything that would allow people to deliver an equivalent experience with less effort. All I see here is a tiny bit of cosmetic polish. Polish is appreciated, but this doesn't seem like something that would tip the balance between building an SPA or not. Am I missing something?

adamtaylor_13• 12 months ago

“But they are better”

By what measure?

nfw212• 12 months ago

Performance, developer experience, user experience

calrain• 12 months ago

I like how client side state is managed in a SPA more than an MPA

martinald4• 12 months ago

Everyone is completely missing the point of this article, which I find amusing and terrifying in equal measure.

He is _not_ talking about a SaaS dashboard SPA. He's talking about marketing sites and other content heavy stuff like blogs, landing pages, etc. It mentions this in many places if you go past the headline.

He is completely correct. SPAs should not be used for marketing sites full stop. Perhaps there are some edge cases where it may make sense (though I cannot think of any) but in general, if you are building anything that resembles a blog or landing page with nextjs et al you have done it wrong, close the code editor and start again. I'll give you a pass if you are developing an MVP of something and you need something up very quickly, but if you have any commercial traffic you will thank my later.

I have done a lot of audit work for this kind of stuff. Things I've seen:

10MB+ of React/JS libs to load a simple blog page

Putting images in the bundle, base64d. So badly that the page crashes OOM on many devices.

And my favourite of all time - shipping 120MB (!) of JSON down for a catalog. It literally loaded _the entire database_ to the front end to show _one_ product. It wasn't even an ecommerce site; it was literally a brochure of products you could browse for.

robertoandred3• 12 months ago

You of course don’t need 10MB of JS for a React blog or 120MB for an e-commerce site.

You’re not mad at SPAs, you’re mad at bad developers.

martinald4• 12 months ago

But even the most well optimized nextjs/react 'blog' or ecom site performs and order of magnitude worse than a SSR version, simply because you have to bring in runtime stuff? I'm giving extreme examples; but I've seen very very able development teams totally shoot themselves in the foot with this.

sidcool• 12 months ago

Good article. But could have shown some examples.

bstar77• 12 months ago

This guys is really on a mission. Is there really a war against SPAs? Well designed SPAs can be incredible.

rustystump• 12 months ago

Once again people totally miss the point of SPA. What does SPA stand for? Hint, there is no website in there.

Id argue all the grousing of spa is because people made websites as apps when they should have been websites instead.

Btw view transitions are pretty slick and require zero js to get snazzy transitions.

Edit: there are some significant limitations with view transitions around performance and a few other gochas I should mention when they are used with pure css. I still love em tho.

frollogaston4• 12 months ago

CSS is a mess for anything besides basic static layout. You can force it to do fancy things, but it's hacky and gives you code that doesn't really say what it does. You can do scss, sass, etc, but still eh.

senfiaj• 12 months ago

Yeah, like this https://lyra.horse/fun/tic-tac-nohtml/ tic tac toe without JS and HTML, only a <style> tag.

I mean it's incredible, but you know what will happen to you if you write a production code like this.

oc1• 12 months ago

As others have noted this guy isn't qualified to write about this topic as he doesn't understand the difference between MPA and SPA.

ken47• 12 months ago

The main premise of this article is that SPA frameworks are primarily about transitions. This is yet another passionate argument built on a false foundation.

positron26• 12 months ago

It's time for...

No, you found some tradeoffs and decided that the drawbacks are worse than the advantages. If industry disagrees, they tend to have their reasons, but as we love being tortured artists and really feeling our individualism, offbeat hot takes are always in demand.

That's all I see in quite a few HN titles ;D

40four• 12 months ago

This article is getting a lot of pushback from the SPA champions, deservedly so, but it makes some good points to. I can’t be the only one, but I myself am getting very tired of the amount of websites where I have to sit and look at a skeleton loading for way too many seconds, then the data loads and it looks nothing like the skeleton. There is an over abundance of really crappy SPAs out there. Sorry not sorry

pyman4• 12 months ago

I thought about your comment, and IMO the reason some (or most) SPAs are badly built comes down to the inexperience of developers and hiring managers. They don't know much about performance, they don't measure it, they don't handle errors properly, they ignore edge cases, and some are learning as they go.

Bottom line: they build the SPA, but leave behind a terrible UX and tech debt the size of Mount Everest.

maccard6• 12 months ago

They would have done the same thing with a MPA too though.

tossandthrow6• 12 months ago

This is not intrinsic to SPAs.

You'd likely have to wait an equal amount of time for a non SPA - just without any skeleton

sibeliuss• 12 months ago

SPAs are _applications_ folks. Just like app-apps are made -- spas are apps for the browser. SPAs in themselves are not complicated. State in an app is complicated. This is such a tired misunderstanding.

nektro• 12 months ago

might wanna consider redesigning your site, it looks like AI spam

rhet0rica• 12 months ago

Yeah, it's really missing the charm you'd expect from a AI-free spam site. Maybe more flashing text?

65• 12 months ago

The SPA test should be: can you keep a picture-in-picture video element playing while navigating between pages?

If the vanilla web can't do this easily, then it's not a good solution to your need for a SPA.

d--b• 12 months ago

Yeah… Let’s see how less terrible those MPAs with CSS tricks are.

np18102• 12 months ago

On one hand, SPAs took off and became massively popular. On the other, I’m still curious why PWAs—especially the kind with service-worker-powered offline access—never really did. I don't like SPAs only if I find them bloated and with a messed up browser history that back button moves you out of the website.

Imagine an e-commerce site that lets you review your order history and product pages offline (even if a bit outdated). That kind of experience feels genuinely useful—much more so than the "you're offline, here’s a cute dog (I love the pictures though)" fallback most sites provide.

Over the weekend, I experimented with service workers for the first time (assisted by Vibe coding). My initial impression was honestly a bit magical—“this website works offline, unlike most mobile apps these days that are just WebView-wrapped SPAs and crash offline.” [1]

That said, debugging was rough. Vibe coding output had subtle issues I found hard to untangle as a newcomer, cache saved v/s cache matching was being done incorrectly in the code, which LLM wasn't able to point out (cors/non-cors requests had issue).And Chrome’s DevTools made debugging manageable, but Firefox’s service worker support felt clunky in comparison (personal take).

Curious if others feel the same—are PWAs underused because of DX hurdles, lack of awareness, or just industry momentum around SPAs?

[1] https://ball-sort-game.vercel.app/

gabesullice• 12 months ago

Offline is good for things like your ball sort game or a calculator. But the developers of that sort of thing want to make money, so they sell apps in the app store.

Offline order history is only a marginal improvement on the e-commerce experience from a customer and business perspective, so it's more appealing to us engineers who appreciate it as a feat of engineering prowess.

In other words, offline isn't PWAs killer feature. Besides, native apps can do it too.

PWA's killer features are circumventing the app store and the app store tax and not maintaining two codebases for Android and iOS.

Another Hacker News client would be a good example of a good PWA that you might install to your phone. It could have niceties like "save for later" or special styles applied to your favorite commenters. Offline support would be useful too, of course but not the main reason to develop a PWA.

Uncensored, paid content is another significant use case.

np18102• 12 months ago

PWA's killer features are circumventing the app store and the app store tax and not maintaining two codebases for Android and iOS.

Agreed, I wish we lived in world where PWAs had atleast an equal share compared to mobile apps. Apps winning, mostly have been a suicide for privacy.

Coincidentally, there's another HN story with even more relevance to our discussion. [1]

[1] https://news.ycombinator.com/item?id=44689059

softwreoutthere• 12 months ago

"It is a couple MB payload, so its bad" never really reasonated with me.

YouTube serves hundreds of MB payloads to serve information. Even a bloated SPA is tiny in comparison.

Although, I think YouTube is also an SPA.

Some websites serve hundred MB payloads to show a hero video.

Why is JS optimization the great evil when there is often so much more waste in media or design choices?

gethly• 12 months ago

I strongly disagree with this. SPA has its place and a very important one. It is not just about replacing JS animations with CSS animations. Of course it depends on the use case - SPA makes little sense in many cases and a lot of sense in few. But it still has it's stable place.

From my own point of view and experience, SPA makes the most sense when you do not want to bundle backend and frontend together in your server code. Having a separate FE and BE with clearly set API(json) is very important in many many many cases and it allows you to use the same BE for different FE, like desktop website, mobile website, desktop client(electron), mobile application... trying to do this on the server would be hell. Also worth mentioning is that if you want to make changes in your FE, you have to bring down you BE in order to deploy them, whereas if you have BE and FE separated, you can deploy the FE without any downtime.

There is a lot more that could be said but the main point is that moving data rendering into FE and letting BE just serve raw data is the way to go in many situations.

We have been moving computation between FE and BE for decades now, but I think the tech is now sufficient to not force us to pick one over the other but chose what works best.

Personally, I think that rendering the UI on BE is archaic and should be handled on the client via some bundled thin client code, ala SPA. So I will always prefer client-rendering over server-rendering, no matter the setup.

PS: You might be interested in https://data-star.dev/ which came out of dissatistfaction with HTMX and I think will be the way to go about bridging FE and BE in the future.

aatd86• 12 months ago

Some people download mobile apps everyday but are afraid all of a sudden of SPAs which is a similar development model. Doesn't make sense.

nromiun8• 12 months ago

Lots of pushback here in the comments. But I can't think of the last time I enjoyed using a SPA website over a multi-page one. The initial loading feels delayed, the page scrolling feels unnatural and jarring (completely opposite of how a native app feels).

Also, one of my banks recently changed their old website to a new SPA one. And it is now completely useless. It can't load information in time, so most of the forms are empty. You can't even go back because it is a SPA. So I can only log out, log in and try again. Kind of scary when you are handling a lot of money.

And it is not just one website. As I said I can't recall ever using a good SPA website. So yeah, I can't wait until they are all gone.

kertoip_1• 12 months ago

Yeah, the worst thing is when parts of the same application are under the hood different SPAs.

First example that comes to my mind: web version of ProtonMail. Going to settings feels like loading a completely separate website. Or OVH dashboard.

tossandthrow6• 12 months ago

But I can't think of the last time I enjoyed using a SPA website over a multi-page one.

You likely don't even notice that most of what you browse are SPAs.

The reason why there is pushback is because the article is straight up misinformation.

nromiun8• 12 months ago

Actually the static address bar and the refresh button behavior makes it obvious.

croes• 12 months ago

You think bad programming is restricted to SPAs?

If they botch the back button in an SPA they will botch other things in an MPA

nromiun8• 12 months ago

But this bank's old MPA worked pretty well. By trying to modernize it they completely broke it instead.

maccard6• 12 months ago

The toupee fallacy strikes again here. Gmail, slack[0], Netflix and Spotify are top tier examples - they actually work. Most are true garbage though.

[0] I am firmly on the slack-performance-is-a-disgrace train, but their web client is a great example of a well done SPA - it’s miles better than the app other than notifications.

nromiun8• 12 months ago

Gmail really? The same one that takes 10-20 seconds on 5G to even show the loading page? What is it doing in that time? Loading emails or downloading an AAA game? It is not just a one time penalty either, you reload and get the same loading page again.

Just a few days ago I had to get an OTP via email and it was completely frustrating. No indication nothing, just a loading circle. The old MPA version was much better.

austin-cheney5• 12 months ago

SPAs do not exist to benefit the user. They exist to benefit the developer who writes them.

elendee• 12 months ago

I like the pushback because it means less competition in the native framework space

jeremy88832• 12 months ago

if you're receiving jarring page scrolling, it is not the fault of the spa, it's something else at play. it is not they typical spa experience.

if the back button doesn't work, the site was poorly programmed, since any routing library will handle that for you.

jpc0• 12 months ago

I don’t want to write an article but I think when SPAs are called for they are the least worst option.

Usually I want to ship an app to customers, but for that I need an app the targets Apple platforms, hopefully I can built it to target iOS, iPadOS and MacOS but maybe those are three different apps. I need an app that targets Android. I also need an app that targets Windows, and I need a linux app.

Then I need to distribute all those apps, so I need to get onto the AppStore for MacOS, the play store for linux, and whatever Huawei/other Chinese manufacturers use, and whatever amazon uses, and probably have an “official” APK available for stuff like fdroid.

I need a windows installer, maybe a portable package for windows, and get onto MSStore (which will then cover winget).

I need to pick some collection of linux distros to target, usually targeting having a deb release and rpm can be good enough. And you can build an “installer” yourself if you are so inclined.

Or I could just ship an SPA, I had to build out the same servers if the data was not local anyway.

eric-burel• 12 months ago

TL;DR: article means traditional websites with server navigation (now dubbed MPAs, multi page applications) have evolved positively with better handling of page transitions. But they choose to frame this idea by trashing SPA, while both MPA and SPA have a role to play.

Pavilion2095• 12 months ago

The reason SPAs became the default wasn’t because they were better. It was because, for a while, they were the only way to deliver something that felt fluid.

So they were better.

aswerty• 12 months ago

I'm not a fan of the SPA, or at least in practice, but there is something very attractive about going with a solution that everybody knows.

At work we are building a new "website like" frontend and it is a SPA (that internally operates as a MPA) built with React. The main reasons are we: know this setup well and know when hiring we will find people who know this setup as well. Beyond that, it will allow us to build out more application like features in the future if needed.

This approach has been popular in the industry for over 10 years now. Whereas most of the current discussion and tech on the frontend feels like churn and betting on the next thing. A lot of people just want tools that are mature and can get the job done regardless of them being the best tool under specific criteria.

tossandthrow6• 12 months ago

This is the biggest mess of an article I have read for a long while.

The concerns of SPAs and CSS are completely orthogonal.

vasco• 12 months ago

It's incredible to write an article about UX with a main argument of "this way is as good as that way" without visual examples to prove they actually behave the same.

bigtones• 12 months ago

Right, I would like to see some examples of what he is talking about considering his tone of voice - he is literally telliong people to change their ways and use modern CSS and the entire article is devoid of such css.

Einenlum• 12 months ago

Honestly, I never used an SPA because of transitions. I recently decided to use one because of the persistent state. Not sure how CSS solves this.

victorbjorklund• 12 months ago

I see some people claim that client-side routing isnt the strongest argument for SPA:s. And that is probably true from a technical point of view. However, lots of times users/clients want that even if they dont care about the rest (which is why I love how easy HTMX and Astro make it to add client side routing on top of a normal MPA).

maccard6• 12 months ago

Astro is a breath of fresh air in this space really.

mrb• 12 months ago

SPA = single page app

DrStartup• 12 months ago

is the author secretly the ceo of htmx?

curtisblaine• 12 months ago

Not only SPAs are here to stay, but they're eating up native app on the desktop (with Electron et al., it's much easier to hire TS devs and write your app once rather than have different native codebases for Windows, Macos and Linux).

Now, I understand the argument that simple article-based websites shouldn't necessarily be SPAs. Page transitions are perfectly doable in pure HTML and CSS. But if you have less then trivial local state and complex + specific components, forcing the MPA pattern will only complicate your codebase.

wlll• 12 months ago

It's time for sending HTML rendered on server with CSS, and JS for enhancement only to kill the SPA.

I'm not talking about this from a technical standpoint, though there are many reasons that in most cases this is the best technological fit.

I'm talking about this from the position of "what I want to use". I'm sick of loading and navigting overly JS heavy, overly styled, fragile "apps". When I encounter a "proper" website that loads fast, and I can understand easily it's like a breath of fresh air.

withakay• 12 months ago

If this wasn’t written by Claude then Claude was trained on the authors posts!

rorylaitila• 12 months ago

CSS, URLs, links, forms, POST-Redirect-GET, page reloads. Efficient and user friendly on the modern web. HTML & browsers have smoothed out a lot of rough edges.

nsonha• 12 months ago

what a nonsensical title, clearly written by people that only program skins around applications instead of applications themselves. CSS and SPA do not even solve the same problem.

I'm sure there exist (foolish) efforts to make CSS somehow able to do some UI logic, but that is never a good idea. CSS is a poorly made/overly complex spec that deserves to die. It's too late to make that argument unfortunately, but to want even more of CSS in the modern web stack is kinda lunatic.

mexicocitinluez2• 12 months ago

Native CSS transitions have quietly killed the strongest argument for client-side routing

What? This guy wanted to show off how much he knew about CSS and decided the only way to do it was completely make stuff up about a hot-button topic in webdev.

adamddev1• 12 months ago

SPAs are good for making offline-available apps/sites. Not everyone has (or wants to have) an internet connection all the time.

Alifatisk• 12 months ago

Speculation rules works the same as instant.page, by prefetching the url onhover. Right?

larodi• 12 months ago

it makes more sense than ever to deploy a semantically correct page with clearly distinguished templatnig, styling, animation logic and most importantly - data semantics. so that the robots and LLMs can slurp it without clicking too much. all the styling can follow in a very standards-compliant manner.

insane_dreamer• 12 months ago

SPA was primarily about reducing ajax-type calls to make the page more responsive, not CSS-type transitions.

(I do agree that SPA is waaaaaay overused and most of them would work just as well with server side logic with less complexity.)

Bridged77562• 12 months ago

"It’s faster, simpler, and better for everyone."

For who? In the modern day and age most devices can handle some JavaScript just fine. The DX provided by front end frameworks/libs is just unrivaled. Vanilla JS/jQuery work fine for small stuff, things quickly get out of hand in complex projects, when you have to bake in things like UX, validations, and have to program around the limitations of HTML. I'm confused as to why make such a claim as "Don't do SPAs for websites" and then throw in a dumb broad statement like "Just do vanilla". Yes, you can use CSS and achieve a lot of complex functionality. Yes you can use the existing HTML tags for a lot of things. Is it more maintainable than just using React? No.

You can't live in a silo. Yes, if plain HTML works for your website, why bother with anything else? Just do forms for any submit, input validation, there you go. But for a company competitive in the industry, particularly B2C SaaS, UI/UX does matter. And lagging behind, more than a trend, means customer perception.

We tend to be biased in our takes as tech-literate people (I do), but the average person gets lost if a button isn't emphasized enough.

mantas• 12 months ago

A lot of website-in-spa break basic web stuff that simply works in old school HTML. It’s possible to do all that stuff correctly in react, but vast majority of people working on those simple websites seem to not give a damn.

Vast majority of information/portfolio websites have best UI/UX with classic HTML with some JavaScript sprinkled on top where it matters. Nothing says competitive-in-the-industry like contacts page that takes ages to load.

sirsinsalot• 12 months ago

The DX provided by front end frameworks/libs is just unrivaled

How? I spent 6 months exploring React, Vue, Node, Next,...

The DX for all of them sucks. The documentation sucks. Everything is wrappers of wrappers of npm scripts of wrappers of bootstrappers of boilerplate builders of...

Seriously. The worst.

Bridged77562• 12 months ago

Sucks compared to what?

Vite (build tool) + React is all you need, and a command line away from setting up React with TypeScript. If you don't like how "heavy" it is, you can use Preact. Similarly, for a Node (express) project, all you gotta do is `npm i express`, with additional setup if you want TS and other dev. niceties. Or just use a batteries included framework like Nest/Adonis and skip all that.

It's not that complicated, the frontend targets the browsers, so you have to transpile if you want to ensure compatibility, prevent theft, reduce the size, or not, and you could just wing it using the plain source code.

Again, it's the best for writing APPS. For an app, with complex navigation, features, UI states, it find it asinine that your biggest complains are about the packages.

moribvndvs• 12 months ago

Native CSS transitions have quietly killed the strongest argument for client-side routing

Huh? We didn’t build my company’s product as a SPA because of transitions. We did so because it is a shared codebase with native and because it has an offline mode.

franey• 12 months ago

For anyone looking to use this, I recommend using this CSS before the closing body tag. It disables the fade effect for visitors who prefer reduced motion, and the old page fades out while the new one fades in. (I've got an optional rule that keeps my header in place while the rest of the content fades out/in)

  @media (prefers-reduced-motion: no-preference) {
    body > header {
      view-transition-name: header;
    }

    @view-transition {
      navigation: auto;
    }

    ::view-transition-old(root) {
      animation: fade-out 0.3s ease;
    }
    ::view-transition-new(root) {
      animation: fade-in 0.3s ease;
    }

    @keyframes fade-in {
      from { opacity: 0; }
      to { opacity: 1; }
    }
    @keyframes fade-out {
      from { opacity: 1; }
      to { opacity: 0; }
    }
  }

VikRubenfeld• 12 months ago

Plus which, the author says that the next page will be conveniently pre-loaded when the user hovers over the link. Plenty of time there's ~0 hover time, especially for experienced users. So the user is still going to be looking at a spinner while the full page (which could be pretty beefy) is loaded in from the server.

odyssey7• 12 months ago

I looked up the compatibility table: https://caniuse.com/cross-document-view-transitions

Safari has supported this on both desktop and iOS since last year. But I had to look, because the article makes it sound like Chrome and its family are the only browsers that are modern enough for the feature. Safari uses WebKit, not Chromium.

"Modern browsers – specifically Chromium-based ones like Chrome and Edge – now support native, declarative page transitions. With the View Transitions API"

kristopolous2• 12 months ago

Ie4 had these. It was pretty cool. I forget how they implemented it. Maybe active x?

palmfacehn• 12 months ago

It is possible to deliver a lite, PWA/SPA with vanilla JS and no loading spinners. Users can install it on their mobile device. I've done as much with blockchain dApp front ends. It isn't necessary to hijack the address bar or abuse the back button to achieve this. Modal dialogs, collapsible elements, tabs and simple anchor elements are enough. Yes, you can allow in-app back buttons to return to the previous modal's state, although that might suggest that the UI pattern should be simplified.

"State management" from a framework seems ridiculous. Developers should be able to handle their application's state with JSON objects representing reasonable abstractions of concerns. Typically, this would be similar to the data you query from the web. Therefore, upon launch, you can populate your document using <template> elements from cached data in localStorage or some of the newer options. When network connectivity is available, you can update the state using the same functions.

Perhaps this isn't something you would trust your large enterprisey team to do competently, but for a solo developer with a distaste for React and heavy frameworks, it seems like the obvious approach.

Interested to hear how others building sans frontend frameworks. If you love React and loading spinners by all means feel free to ignore this. To each their own.

Surac• 12 months ago

But designers will always find a way to make our live miserably. They are told to never accept same behavior and always press users to there way of navigation and thinking. The bullshit they call design is there way of expression

ptsd_dalmatian• 12 months ago

is this a growth hack article trying to get attention on SPA hate on HN?

swyx• 12 months ago

i think this is good for websites but my current struggle with Astro is the long build times for a blog with many many pages. current build time is 10 minutes and it does not spark joy.

fmajid• 12 months ago

To be frank, I tried the cross-page fade transition on my Hugo static site, hosted on AWS ClousFront, and I couldn't see the difference. It's probably only relevant if your site is bloated to begin with.

It's time for modern CSS to kill the SPA

Related Stories