Your next project does not need a JS framework

Summary

JavaScript frameworks like React, Vue, and Angular add complexity with build pipelines, state sync, and split codebases. Phoenix LiveView simplifies development by keeping interactivity on the server with Elixir, reducing overhead and improving maintainability. For most projects—dashboards, CMSs, and internal tools—LiveView delivers dynamic features with cleaner code and less friction.

---

If you're gearing up for your next web project, there's a good chance your first instinct is to reach for a JavaScript framework. Maybe you're thinking: “React for interactivity, Vue for rapid UI, Angular for scale.” But what if I told you there's another way - one that keeps things simpler, more maintainable, and just as dynamic?

That approach? Phoenix LiveView.

Why JS frameworks feel like the default

The JS frameworks aren't inherently bad. We've shipped projects with React, Vue, and Angular when the requirements called for it. They excel at building rich, interactive interfaces with component models, client-side routing, and robust ecosystems.

But here's our experience: JS SPAs introduce A LOT of complexity to a system. Build pipelines that need maintenance. State synchronization between frontend and backend. API contracts that need coordination. Bundle sizes that affect performance. And last but not least, separate teams for backend and frontend. It's not that these tools don't work—they absolutely do, but it feels like a lot of excessive friction that does not directly affect the bottom line.

LiveView: Staying in out comfort zone

Since we're already deep in the Elixir ecosystem, LiveView felt like a natural evolution rather than a departure. It leverages the Phoenix foundation we know well while solving the interactivity problem in a fundamentally different way.

Instead of splitting our application logic between server and client, LiveView keeps everything on the server side where we're most comfortable. Here's what this looks like in practice:

Live interactivity without the client-side complexity. User interactions happen over WebSocket connections, giving us real-time updates without managing React state or Vue reactivity systems.

One language, one mental model. We're not context-switching between JavaScript and Elixir. Everything lives in the same codebase, following Phoenix conventions we already understand.

Simplified deployment and debugging. No separate build processes, no client-server state mismatches to track down. When something breaks, we know exactly where to look.

A real example

Consider an admin dashboard that needs live filtering and search. The JS way, this would mean:

1. A React component for the search interface
2. API endpoints for data fetching
3. State management for filters and results
4. Error handling in both JavaScript and Elixir
5. Loading states and debounce logic on the frontend

With LiveView, this can be handled in a single module:

def handle_event("filter", %{"query" => query}, socket) do
  results = MyApp.search(query)
  {:noreply, assign(socket, :results, results)}
end

The template updates automatically, users get instant feedback, and you write maybe 20% of the code you would have needed with a separate frontend.

Why it matters for maintainability

Working exclusively in Elixir has taught us that consistency pays dividends. When new team members join, they don't need to learn JavaScript patterns, build tools, and API conventions. They can focus on Phoenix and Elixir—skills that transfer across all projects.

Debugging is also much more straightforward. No more "Is this a frontend issue or backend issue?" investigations. The entire application flow lives in one place, using tools and patterns we already know well.

When we still reach for JS

We're not framework fundamentalists. Some projects genuinely benefit from client-side frameworks:

• Complex single-page applications with heavy offline requirements
• Rich interactive experiences like image editors or games
  
• Progressive web apps with sophisticated caching strategies

But these represent maybe 5% of the use cases one would normally face. The other 95% - admin panels, dashboards, content management systems, internal tools—work beautifully with LiveView.

Our recommendation

If you're starting a new project soon, consider starting it with LiveView. You might be surprised how far it takes you before you need to reach for anything else.

We've found that choosing the simplest tool that solves the problem leads to cleaner code and happier developers. LiveView is a really solid choice that plays to Elixir's strengths while keeping things maintainable.

The best technology decision is the one that lets you stay focused on solving your users' problems rather than wrestling with your tools.