Why I Still Reach for React in 2026

As a freelance senior frontend developer with over 15 years of experience, I've had the luxury, and sometimes the burden, of working with a lot of frameworks. Vue.js is my daily driver and the tool I'm most opinionated about. But React keeps showing up. And honestly, I keep letting it in.

Here's why.

It's not about loyalty, it's about fit

When I joined DPDK back in 2020, they were a Next.js shop. Dynamic marketing sites, tight motion design requirements, server-side rendering out of the box. Next.js made sense, and by extension, so did React. I didn't fight it. I embraced it.

That experience taught me something I still carry today: the best developers aren't married to a single tool. They understand what a project needs and pick accordingly. React's ecosystem, especially when paired with Next.js, is genuinely hard to beat for certain use cases.

What React gets right

After years of going back and forth between Vue and React, here's what I think React genuinely does well.

The mental model is clear (once it clicks). React's core idea, UI as a pure function of state, is elegant. When you internalize it, you stop fighting the framework. useState, useEffect, useReducer: they're not magic. They're well-named primitives that push you toward thinking declaratively.

function Counter() {
  const [count, setCount] = useState(0);
  return (
    <button onClick={() => setCount(c => c + 1)}>
      Clicked {count} times
    </button>
  );
}

Simple. Predictable. Testable.

TypeScript integration is first-class. I'm a TypeScript person. Always have been. React's type support has matured enormously. Between typed props, generics in hooks, and the excellent @types/react package, you get a solid DX that catches bugs before they ever hit production.

interface ButtonProps {
  label: string;
  onClick: () => void;
  variant?: 'primary' | 'secondary';
}

const Button: React.FC<ButtonProps> = ({ label, onClick, variant = 'primary' }) => (
  <button className={`btn btn--${variant}`} onClick={onClick}>
    {label}
  </button>
);

Explicit, self-documenting, zero surprises.

The ecosystem is enormous. Need a form library? You've got React Hook Form and Formik. State management? Zustand, Jotai, Redux Toolkit. Data fetching? TanStack Query is arguably the best in any framework. Animation? Framer Motion is stunning. The depth of the React ecosystem means you're rarely starting from scratch, which matters enormously on freelance projects where time is always a constraint.

Next.js changed the game. I can't talk about React in 2026 without talking about Next.js. The App Router, React Server Components, streaming SSR: these aren't incremental improvements. They're a fundamentally different way of thinking about the frontend/backend boundary.

// A Server Component: no "use client", no useEffect, no loading state
async function BlogList() {
  const posts = await db.post.findMany({ orderBy: { date: 'desc' } });
  return (
    <ul>
      {posts.map(post => (
        <li key={post.id}>{post.title}</li>
      ))}
    </ul>
  );
}

Zero JavaScript shipped to the client for this component. The data fetching happens on the server. It just renders HTML. This is powerful, and honestly, it's where the web is heading.

Where Vue still wins for me

I'll be honest: for most of my freelance work, Vue 3 + Nuxt is still my go-to. The Composition API is a joy to use. Single-file components keep logic, template, and styles co-located in a way I find highly readable. And the Dutch tech ecosystem I operate in has strong Vue adoption.

But the honest answer to "Vue or React?" is: it depends. Team familiarity, existing codebase, ecosystem requirements, hosting constraints. These all matter more than framework preference.

My advice to developers picking up React today

Start with TypeScript from day one. Don't shortcut this. Typed components and hooks will save you hours of debugging.

Learn the hooks deeply before reaching for libraries. Understand useCallback, useMemo, and useRef before you abstract them away.

Pick up Next.js early. Vanilla Create React App is effectively legacy at this point. Next.js is where the community has moved.

Don't ignore Server Components. They're confusing at first, but once they click, you'll wonder how you built without them.

Use TanStack Query for data fetching. It handles caching, refetching, loading states, and error states better than anything you'll write yourself.

Final thoughts

I've been building for the web for 15+ years. I've watched jQuery give way to Angular, Angular give way to the framework wars, and those wars slowly settle into a React-dominated landscape with strong challengers. React won the mindshare battle, and for good reason: it's composable, predictable, and backed by one of the largest developer ecosystems in history.

Is it perfect? No. The learning curve for hooks is real. Server Components introduce genuine complexity. The ecosystem choice paralysis is a genuine problem for newcomers.

But when a client asks me to join a React project, I don't hesitate. I know the tooling, I know the patterns, and I know how to ship production-quality code with it. That's all a framework needs to do.