Why Angular feels heavy, why people quit early, and why teams that stay rarely leave.
Ash leaned back in his chair and stared at the pull request.
Another comment.
Another suggestion to “rewrite this in React.”
“I don’t get it,” Ash said aloud. “The app is fast. It’s stable. We haven’t had a production bug in months. Why does everyone hate Angular?”
Taylor Bell, a senior frontend architect who had joined the startup after years in large-scale enterprise systems, swiveled her chair toward him.
“They don’t hate Angular,” she said calmly. “They hate what they think Angular is.”
The First Impression (Why Angular Feels Heavy)
“Angular is too complex,” Ash said. “So many files. Modules. Decorators. Dependency injection. React is just… JavaScript.”
Taylor Bell smiled. “That’s exactly the trap.”
She grabbed a marker and drew two boxes on the whiteboard.
Box 1: A Tool
Box 2: A System
“React is a tool,” she explained. “A brilliant one. It solves rendering. Everything else—routing, state, forms, architecture—you assemble yourself.”
She tapped the second box.
“Angular is a system. It assumes you’re building something that will live for years, not a weekend demo.”
The Architecture (Why Angular Is Opinionated)
Taylor Bell opened a fresh Angular project.
“Look at this,” she said.
“Components. Services. Modules. Clear boundaries.”
Ash frowned. “But that’s the problem. It tells you how to structure everything.”
“Yes,” Taylor Bell said. “And that’s why it scales.”
She continued:
Dependency Injection isn’t ceremony—it’s controlled lifecycles and testability.
Services prevent logic from leaking into components.
Modules and Standalone APIs enforce boundaries in large teams.
TypeScript-first catches bugs before users do.
“Angular assumes your team will grow,” she said.
“And that not everyone will be a genius.”
The Misunderstanding (Why Developers Bounce Off)
Ash crossed his arms. “Then why do people quit Angular so fast?”
“Because Angular front-loads discipline,” Taylor Bell replied.
She pointed at the onboarding doc.
“In React, you start fast and discover problems later:
Where should this logic live?
Why is state duplicated?
Why did this refactor break half the app?
In Angular, you pay the cost upfront:
You learn DI.
You learn RxJS.
You learn structure.
People confuse learning curve with bad design.”
The RxJS Problem (Power Mistaken for Pain)
Ash groaned. “RxJS though… that’s where I got lost.”
Taylor Bell nodded. “Fair.”
“RxJS is misunderstood because people use it everywhere,” she said.
“It’s not for everything. It’s for asynchrony that evolves over time.”
She wrote:
User input streams
WebSocket updates
Complex async flows
Cancellation and retries
“Angular doesn’t force RxJS,” she said.
“But when you need it, nothing else comes close.”
The Performance Myth (Angular Is Slow?)
Ash pulled up a benchmark.
“People say Angular is slow.”
Taylor Bell laughed. “Angular from 2016, maybe.”
She listed quietly:
Ivy compiler
Fine-grained change detection
Signals (modern Angular)
Tree-shakable builds
Zoneless configurations
“Angular apps fail for the same reason any app fails,” she said.
“Bad architecture. Not the framework.”
The Popularity Illusion (Why You Don’t Hear the Success Stories)
“So why isn’t Angular ‘cool’ anymore?” Ash asked.
Taylor Bell leaned back.
“Because Angular users don’t tweet about rewrites,” she said.
She explained:
Angular dominates enterprise, not Twitter.
Banks, airlines, healthcare, governments use Angular.
These teams value stability over trends.
You don’t rewrite Angular apps every year—so there’s less noise.
“React apps brag about velocity,” she said.
“Angular apps brag about not breaking.”
The Real Tradeoff
Taylor Bell summarized it with a simple truth:
If you want… Choose…
Maximum flexibility React
A complete framework Angular
Fast experiments React
Long-term maintainability Angular
Loose conventions React
Enforced best practices Angular
“Angular isn’t unpopular,” she said.
“It’s just not loud.”
The Conclusion
Ash merged the pull request.
No rewrite.
No framework switch.
No fire drill.
The app kept shipping. New developers onboarded faster than before. Refactors felt safe. Bugs dropped.
A month later, Ash caught himself saying something unexpected in a meeting:
“Angular already gives us that.”
Taylor Bell smiled.
“Frameworks don’t fail,” she said, grabbing her coffee.
“Teams fail when they confuse discipline with difficulty.”
“And Angular,” she added,
“is just disciplined enough to make bad decisions uncomfortable.”
Top comments (0)