Why I Still Bet on the Web in 2026

There's a ritual in tech where, roughly once a year, someone declares the web finished. Native is faster. AI will generate whole apps. Nobody visits websites anymore, only apps. And yet here we are: the most universal, most linkable, most durable way to ship software to a human is still a URL.

I keep betting on the web. Not out of nostalgia — out of leverage. Let me explain what changed and why I think the platform is in the strongest shape it's been in years.

The server came back (and that's a good thing)

For a long time the trend was "ship everything to the browser." We pushed more and more JavaScript down the wire, hydrated giant client apps, and then spent years optimizing away the weight we'd added in the first place.

The pendulum swung back, and sensibly. Server-first rendering — React Server Components, streaming, the whole modern Next.js model — means the default is now: do the work on the server, send the browser only what it actually needs to be interactive.

The mental model I've settled on:

• Server components for everything that's just displaying data. No JS shipped, no hydration cost.
• Client components only at the edges where there's real interactivity — a form, a menu, a chart.
• Streaming so the user sees something instantly instead of staring at a spinner while one slow query blocks the whole page.

It sounds like a small reshuffle. In practice it changed the default, and defaults are everything.

// The thing I love: this component touches the database directly,
// runs only on the server, and ships zero JavaScript to the client.
async function PostList() {
  const posts = await getSortedPostsData();
  return (
    <ul>
      {posts.map((post) => (
        <li key={post.id}>{post.title}</li>
      ))}
    </ul>
  );
}

The first time you write a component that just awaits your data and ships no client JavaScript, something clicks. A lot of the complexity we'd accumulated — loading states, fetch-on-mount, client caches for data that never changes — just evaporates.

The framework wars cooled off

A few years ago picking a stack felt like joining a faction. That energy has mostly drained out, and I'm grateful. The good ideas cross-pollinated: file-based routing, server rendering by default, islands of interactivity, smart bundling. Whatever you pick now, you inherit a decade of hard-won lessons baked into the defaults.

The best sign of a maturing ecosystem isn't a new framework every month. It's that the boring choice became the right choice.

My actual argument for the web

Strip away the framework talk and here's why I keep choosing it:

1. One link reaches everyone. No install, no app store, no platform gatekeeper. You send a URL and the software runs. Nothing else has that reach.
2. It degrades gracefully. Old browser, slow connection, screen reader — done right, the web meets people where they are.
3. It's the most durable target there is. Code I wrote for the web years ago still runs. Very little else in this industry can say that.
4. It composes with everything. Including the AI tools I now lean on daily — they understand HTML, CSS, and JavaScript better than any proprietary UI layer, which makes the web the easiest thing to build with a machine at your side.

What I'm watching

I'm not claiming the web is perfect. Build complexity is still real, the config rabbit holes are still deep, and "just make it fast" is still harder than it should be. But the direction is right: less shipped to the browser, more done ahead of time, better defaults out of the box.

So no, I don't think the web is dying. I think it quietly got really good while everyone was looking somewhere else. And for someone who likes shipping things people can actually reach — that's exactly the bet I want to be making in 2026.