Chapter 12: Life After React - Finding Your New Framework Family

The Framework-Agnostic Developer: Final Form

You’ve made it through the journey. You’ve seen the alternatives. You understand the options.

Here’s what you’ve become: framework-agnostic.

Not anti-React. Not pro-Vue. Not Svelte-evangelist.

You’re a developer who picks the right tool for the job.

Choosing the Right Framework

There’s no one answer. There’s only “it depends.” Here’s the decision tree:

Content-Heavy Sites (Blogs, Docs, Marketing)

Best choices:

1. Astro - Zero JS by default, bring frameworks for islands
2. HTMX - Server-rendered with sprinkles of interactivity
3. Vanilla - Sometimes you just don’t need a framework

Why not React?

• Shipping megabytes of framework for static content
• Slower initial load
• SEO complexity
• Over-engineering

Interactive Widgets & Progressive Enhancement

Best choices:

1. Alpine.js - Minimal JavaScript, no build step
2. Vanilla Web Components - Standards-based, no dependencies
3. Lit - Web Components with better DX

Why not React?

• Too heavy for simple interactions
• Requires build step
• Framework lock-in

SPAs with Moderate Complexity

Best choices:

1. Svelte - Smallest bundles, great DX
2. Vue - Gentle learning curve, great docs
3. Solid - React-like syntax, better performance

Why not React?

• Larger bundles
• More boilerplate
• Performance requires constant optimization

Enterprise Applications

Best choices:

1. Angular - Opinionated, structured, batteries included
2. Vue - Good balance of flexibility and guidance
3. React - Huge ecosystem, large hiring pool

Why not others?

• Smaller communities
• Fewer enterprise-specific libraries
• Harder hiring

Highly Interactive, Real-Time Apps

Best choices:

1. React - Battle-tested for complex UIs
2. Solid - Fine-grained reactivity shines here
3. Svelte - Great performance for games/tools

Why not others?

• HTMX isn’t built for this
• Alpine is too simple
• Vanilla gets messy at scale

Design Systems & Component Libraries

Best choices:

1. Lit - Works everywhere, web standards
2. Vanilla Web Components - Future-proof
3. Framework-specific (Vue, React, Svelte) - If you’re committed to that framework

Why not others?

• Framework lock-in
• Can’t share across teams using different frameworks

When React Is Actually the Right Choice

Let’s be honest: React isn’t always wrong.

React makes sense when:

1. You’re building something like Facebook
   • Complex, highly interactive
   • Real-time updates
   • Massive scale
2. Your team is all React developers
   • Retraining is expensive
   • Productivity matters more than bundle size
   • You need to ship now
3. The ecosystem is critical
   • You need that specific React library
   • No equivalent exists elsewhere
   • Time to market trumps all
4. You’re maintaining existing React code
   • If it works, don’t break it
   • Migration cost exceeds benefit
   • Technical debt is manageable

React isn’t evil. It’s just not always the answer.

Moving Forward Without useEffect-Induced PTSD

Recognizing the Patterns

After React, you’ll see patterns everywhere:

Component-based thinking:

• Every framework has components
• The syntax changes, the concept doesn’t

Reactive data:

• React: useState, useReducer
• Vue: ref, reactive
• Svelte: let (it’s just reactive)
• Solid: createSignal
• All solving the same problem differently

Lifecycle management:

• React: useEffect
• Vue: onMounted, onUnmounted
• Svelte: onMount, onDestroy
• Solid: onMount, onCleanup
• Same concept, better APIs

State management:

• All frameworks need it
• Some have better built-in solutions
• Patterns transfer

Your React knowledge isn’t wasted. You learned the problems frameworks solve. Now you’re learning better solutions.

The Multi-Framework Developer

Here’s a radical idea: learn multiple frameworks.

Not to master all of them. But to understand their trade-offs.

Spend a weekend with:

• Vue (learn reactivity done right)
• Svelte (learn compiler-based frameworks)
• HTMX (learn server-driven apps)
• Vanilla (learn what the browser can do)

You’ll become a better developer in your primary framework because you’ll understand what else is possible.

The Framework Portfolio

Different projects, different frameworks:

Personal blog → Astro
Client dashboard → Vue
Marketing site → HTMX + Alpine
Design system → Lit
Side project game → Svelte
Work project → React (because that's what work uses)
Learning experiment → Vanilla

You’re not locked in. You’re well-rounded.

Advice for Your Next Project

1. Question the Default

Don’t reach for React automatically.

Ask:

• How interactive is this really?
• How much JavaScript do users need to download?
• What’s the performance budget?
• Does the team know alternatives?

Then choose.

2. Optimize for Change

Pick frameworks that make change easy:

• Clear reactivity (Vue, Svelte, Solid) over confusing re-renders (React)
• Less boilerplate over more ceremony
• Standard HTML/CSS over framework-specific patterns
• Small bundles over “we’ll optimize later”

Future you will thank past you.

3. Bet on Standards Where Possible

• Web Components won’t go away
• HTML/CSS won’t go away
• JavaScript won’t go away
• Frameworks come and go

Use standards when you can. Framework abstractions when you must.

4. Measure What Matters

Track:

• Bundle size
• Time to interactive
• Developer velocity
• Team happiness

Don’t cargo cult framework choice. Measure and decide.

5. It’s Okay to Be Boring

Sometimes the right choice is:

• The framework your team knows
• The framework with the most docs
• The framework that’s “good enough”
• Not switching at all

Boring is often correct.

Final Thoughts: The Recovery Journey

You picked up this book because something about React frustrated you.

Maybe it was useEffect. Maybe it was the bundle size. Maybe it was the constant feeling that you were holding it wrong.

You’ve now seen that alternatives exist. Better alternatives, for many use cases.

But here’s the real lesson: there is no perfect framework.

• Vue has learning quirks
• Svelte’s compiler can be surprising
• Solid’s reactivity takes getting used to
• Angular is opinionated (which helps until it doesn’t)
• Alpine is too simple for complex apps
• Lit ties you to Web Components
• HTMX requires server rendering
• Vanilla requires you to build everything

Every choice is a trade-off.

The difference between a junior developer and a senior developer isn’t knowing one framework deeply.

It’s knowing:

• When to use which tool
• What trade-offs you’re making
• How to migrate when you chose wrong
• That choosing wrong is part of the job

You Are Not Your Framework

Your value as a developer isn’t:

• How well you know React
• Whether you can recite the Rules of Hooks
• Your ability to optimize re-renders

Your value is:

• Solving problems
• Shipping features
• Understanding trade-offs
• Making good decisions
• Learning and adapting

Frameworks are tools. You are a builder.

Don’t let a tool define you.

The Path Forward

You have options now:

1. Stay with React - Now you know why
2. Try something new - Now you know what
3. Mix and match - Now you know how
4. Go vanilla - Now you know the platform

All are valid.

What matters is that you’re choosing instead of defaulting.

One Last Thing

If you take one thing from this book, let it be this:

Question your tools.

Not to be contrarian. Not to chase hype. But to truly understand if they’re serving you or if you’re serving them.

React taught you to think in components. That’s valuable.

Now go build something amazing with whatever framework makes you happiest.

Or no framework at all.

“I used to introduce myself as a React developer. Now I introduce myself as a developer. React is just one tool in my toolbox.” — A Developer Who Stopped Over-Reacting

Thank You

Thank you for reading. Thank you for keeping an open mind. Thank you for caring about your craft enough to question your tools.

Now go forth and build wonderful things.

With less JavaScript. Less framework overhead. Less useEffect-induced anxiety.

And maybe, just maybe, a little more joy.

The End 🎉

Appendix: Quick Reference

Framework Comparison Table

When to Use What

Content sites → Astro, HTMX, Vanilla
Simple interactions → Alpine, Vanilla
SPAs → Svelte, Vue, Solid
Enterprise → Angular, React
Design systems → Lit, Web Components
Learning → Vue, Svelte
Performance-critical → Svelte, Solid, Vanilla
Hate build tools → Alpine, HTMX, Vanilla
Love JSX → Solid, React
Love templates → Vue, Svelte, Angular
Bet on standards → Lit, Vanilla

Resources

• Vue: vuejs.org
• Svelte: svelte.dev
• Solid: solidjs.com
• Angular: angular.io
• Alpine: alpinejs.dev
• Lit: lit.dev
• HTMX: htmx.org
• Astro: astro.build
• MDN (Vanilla): developer.mozilla.org

Over-Reacting: A Recovery Guide for React Developers

By Claude Code (Sonnet 4.5), an AI Author

For developers moving from React to better things.

May your bundles be small and your deploys be green. 🚀