Why I Choose React.js Over Angular (And Why It Feels Right for Me)

React.js and Angular are both powerhouses for building modern web apps, but after years of shipping projects—most notably my movie trailer discovery app Trailer Base—I keep coming back to React. Not because it's "better" in some absolute sense, but because it aligns with how I like to think and build: fast iteration, freedom to choose tools, and no forced structure when I don't need it.

Angular gave the world structure when we desperately needed it. But today, with tools like TanStack Router and TanStack Query, React gives me that same enterprise-grade reliability—without the feeling that someone else decided how my folders should look or how my data should flow.

Angular's Historical Strengths (And Why They Mattered)

Back when I first learned Angular (around v2–v4 days), it felt like a relief. No more reinventing routing, forms, HTTP clients, or dependency injection. Everything was opinionated, consistent, and TypeScript-first. For big teams or enterprise apps where 20+ developers need to read each other's code without arguing, that structure is gold.

But personally? After a few months, the boilerplate started to feel like handcuffs. Decorators everywhere, NgModules that ballooned, RxJS chains that grew longer than my patience. I spent more time fighting the framework than building features. In Durban's humid heat, debugging a massive change detection cycle felt like punishment.

React's Flexibility: Freedom That Actually Feels Productive

React is just the view layer. That's it. And that's exactly why I love it.

I decide the routing (TanStack Router now), the data layer (TanStack Query), styling (Tailwind or CSS modules), forms (React Hook Form or Zod + TanStack), SSR (Next.js when I need it, plain Vite otherwise). No one tells me "this is the Angular way."

In Trailer Base, I started with a simple Vite + React setup. When I needed type-safe routing and data preloading for movie pages, I dropped in TanStack Router—no migration hell, no rewriting components. The stack grows only as much as the project demands. Adding search, infinite scroll for trailers, and hover-preloading? All slotted in naturally without rewriting half the app.

That flexibility isn't chaos—it's empowerment. I feel like I'm directing the orchestra instead of following a strict conductor. Late-night coding sessions in Durban become enjoyable again because I can experiment without guilt.

A Framework for Engineers Who Love Structure vs Developers Who Crave Flexibility

Here's the real divide I see in the community (and in myself):

• Engineers who prioritize structure love Angular (or Next.js with its conventions). They want predictable folders (

  code

  Copy

  src/app/features/movies

  ), enforced patterns, built-in everything. It reduces arguments in big teams, makes onboarding faster, and feels "professional." When the codebase is 100k+ lines and 50 people touch it, that opinionation prevents spaghetti. I respect that—it's smart engineering.

• Developers who love flexibility (me included) gravitate to React's ecosystem. We enjoy picking best-in-class tools for each job. We don't mind a bit of initial setup if it means zero compromises later. We prototype fast, iterate ruthlessly, and scale thoughtfully. For indie projects, side hustles, or tools that evolve quickly, this freedom is addictive.

I used to feel guilty for preferring the "messy" React way—like I wasn't a "real" engineer. But after shipping Trailer Base faster, with fewer bugs, and way better DX, I stopped caring. Structure is valuable—but only when the project actually needs it. For most of what I build, flexibility wins every time.

Matching (and Often Beating) Angular's Structure with TanStack Tools

TanStack Router changed everything for me. File-based routing (

/routes/movies.tsx

/movies

movieId: string

app-routing.module.ts

Add TanStack Query on top: automatic caching, stale-while-revalidate, mutations with optimistic UI, invalidation on route change. In Trailer Base, I preload trailer data on movie card hover—something that took custom resolvers and guards in Angular. Here it's three lines. Type safety? React + TypeScript + TanStack gives me compile-time checks that feel as strong as Angular's, without the framework tax.

The React Ecosystem's Dirty Secret: It Competes With Itself (And That's a Feature)

React doesn't have one "official" way—it's a thousand ways. That's both beautiful and exhausting.

• Routing? TanStack Router, React Router v6/7, Next.js App Router, Remix.
• Data fetching? TanStack Query, SWR, RTK Query, Apollo, Next.js fetch + caching.
• Meta-frameworks? Next.js (dominant), Remix (loved for forms/actions), TanStack Start (emerging contender with Vite + full type-safety), Astro islands, etc.
• State? Zustand, Jotai, Valtio, Redux Toolkit, Context + useReducer, server components...

This internal competition drives insane innovation. TanStack Router exists because React Router felt dated in some areas; TanStack Query because everyone hated manual caching logic; Next.js Server Components because client bundles got too fat.

But it also creates decision fatigue. I've spent entire weekends comparing routers before starting a feature. The flip side? Once you choose (and commit), the tools are usually better than any single built-in solution. Angular's router and HttpClient are solid—but they're frozen at "good enough 2020." TanStack tools evolve weekly, pushed by real-world pain points from thousands of devs.

In 2026, if you're willing to curate your stack, React lets you build something that feels custom-tailored. Angular gives you one well-maintained box. I choose the tailor every time.

Performance, Bundle Size, and Real-World Feel

React apps (especially with tree-shaking and modern bundlers like Vite) stay lean. Trailer Base loads fast even on spotty Durban 4G or load-shedding Wi-Fi. Angular's Ivy helped, but the full framework runtime still adds noticeable weight.

React's virtual DOM + selective re-renders + TanStack's caching = buttery smooth UX without fighting change detection zones. Scrolling through movie trailers feels instant.

Learning Curve: Hooks Won Me Over

useState, useEffect, custom hooks—once you get them, everything clicks. Angular's decorators, DI, RxJS observables? Steeper upfront. I can teach a junior React in days; Angular takes weeks. For self-taught or solo devs, that matters.

When I Still Reach for Angular

Big enterprise team, strict consistency needed, lots of forms and complex DI? Angular shines. But for my world—solo/small-team, rapid shipping, evolving requirements—React + TanStack is unbeatable.

Conclusion

I don't hate Angular. It built the foundation for modern frontend and still powers massive apps. But React, with its flexibility and ecosystem (even when it fights itself), lets me build the way I think: pick the right tool, move fast, stay type-safe, ship often.

If you're an engineer who sleeps better with structure—Angular is still king. If you're a developer who wants freedom and trusts yourself to choose wisely—React is home.

Check out Trailer Base to see this stack in production—search movies, watch trailers, hover-preload goodness, all typed and fast. Happy coding—choose what makes you productive, not what the timeline says is cool.