Confessions of a developer who swore he'd never go back
If you had asked me three or four years ago what I thought about Angular, I probably would have given you a skeptical look. To be completely honest, there was a time when I considered Angular to be the 'monster' under the bed of web development. I saw it as an overly bureaucratic, heavy tool full of complex concepts that only made sense in large corporate environments where structure matters more than agility.
For a long time, I felt liberated in the React and Vue ecosystems. I loved that sense of 'freedom' (which sometimes ended up being chaos, but that's another story). However, a few months ago, out of a mix of professional curiosity and a specific project need, I decided to take another peek at what Google was doing with its framework. And what I found, honestly, threw me off. It wasn't the Angular I remembered. There was something different, something much lighter and, for the first time in years, fun to use.
My traumatic past experience
To understand my reconciliation, first I have to tell you why I left. My relationship with Angular (especially versions 2 through 8) was a roller coaster of frustrations. I remember spending hours trying to figure out why a component wasn't rendering because I had forgotten to declare it in a specific NgModule. Modules were, for me, the biggest hurdle: an abstraction layer that seemed to add extra work without a clear benefit for the individual developer.
Then there was RxJS. Don't get me wrong, reactive programming is powerful, but Angular forced you to dive in head-first from minute one. Trying to make a simple form or an HTTP request turned into an odyssey of observables, pipes, and subscriptions that, if you didn't manage them well, ended up in memory leaks. I felt like Angular was forcing me to learn an entire encyclopedia before I could properly paint a 'Hello World.' So, like many others, I decided to 'run' toward environments that allowed me to be productive faster.
What changed to make me decide to come back?
What changed my mind wasn't a single feature, but a renewed philosophy that seems to have permeated the Angular development team. The arrival of Standalone Components was the first big 'click' in my head. Finally, we could say goodbye to the tyranny of NgModules. Now, a component is an independent unit, easy to understand and to move around. This simplifies the architecture in a massive way and brings the development experience closer to what we love about other frameworks.
But the real game changer, the thing that truly blew my mind, was Signals. If you come from other worlds, Signals are Angular's answer to reactive state management but in a much more human and predictable way. We no longer rely exclusively on Zone.js for the framework to know something has changed (with the performance cost that implied). With Signals, the code is cleaner, more explicit, and, above all, much easier to debug. I no longer feel like I'm fighting the framework to update the view; now it flows naturally.
Stability vs. the chaos of choice
Another reflection that brought me back is the exhaustion that the React ecosystem sometimes produces. Don't get me wrong, I love React, but sometimes you get tired of having to decide which routing library to use, which state manager to choose, or how to structure your folders this week.
Angular, in its current maturity, offers a "batteries included" approach that I value much more now than before. Having a powerful CLI, a standardized routing system, and an official way to handle forms (which, by the way, are still the best in the industry) allows me to focus on what really matters: the business logic of my application. It's like moving back into a house that's been renovated: the structure is solid and familiar, but now everything is more modern, efficient, and aesthetic.
What I've learned on this return
My biggest takeaway from this round trip is that we shouldn't marry our technological prejudices. Software evolves, and tools that once seemed clunky to us can become our best allies if they know how to adapt. Angular has managed to listen to the community, trimmed the fat, and kept a powerful but much more accessible engine.
I've learned that complexity isn't in the tool, but in how we use it. The "new" Angular allows me to write less code, better understand what's happening under the hood, and, curiously, enjoy strict typing with TypeScript that in other environments sometimes feels like a patch. Plus, the improvement in hydration performance and the new control flow APIs in templates (those @if and @for blocks that are now so clean) prove that the framework is more alive than ever.
Final thoughts
If you're one of those who, like me, fled Angular years ago complaining about its complexity, I sincerely encourage you to give it a second chance. Don't try to apply it like we did in 2018; forget about modules, embrace Signals, and enjoy the power of the new control flow system.
At the end of the day, our job as developers is to choose the best tool for each problem, and right now, Angular has earned its spot back in my toolkit. It's not the monster I remembered; it is, quite possibly, one of the most solid, modern, and balanced frameworks we have at our disposal today. Sometimes, stepping away for a while is the best way to appreciate what a technology can offer you when it truly matures.