I've built and recently published my latest SaaS Application with Angular 19.1, and it has been a dream (compared to the Angular adventures (and occasional dumpster fires) of yesteryear).

First things first, here's the battlefield setup – my tech stack:

  • PrimeNG as the Component Library (still my favorite choice)
  • Supabase for the Backend (because who has time for complex backend setups?)
  • TailwindCSS for Styling (utility-first)
  • Cloudflare Pages for Deployment (mostly smooth sailing, more on that later)

A Trip Down Memory Lane (aka How I Got Here)

I'm kind of an Angular old-timer. Cut my teeth building a mobile app with Ionic, Angular (the JS version, anyone remember that?), and Cordova. Back then, the learning curve felt like scaling Everest in flip-flops, but I got there. RxJS? Didn't even know it existed – I was living that Promise.then() life, and it worked... mostly.

Over the years, I've churned out various tools and SaaS apps with Angular. I even flirted with the React/Next.js world (because, you know, trends), but it just never clicked for me. Coming from Angular's structure, it felt like trying to write with my left hand. Uncomfortable.

Fast Forward: Angular 19.1 – What's Changed?

I launched my latest SaaS with Angular 19.1 using almost all new features which are available since the last two major versions and fit into my application. And whoa, I'm really impressed with what happened to Angular! For a while, I thought it would be a slow death for Angular if you look at trends data like this chart from Stack Overflow about popularity. Since 2019/2020, Angular seemed to be in a slow decline but managed to recapture developers' interest since 2023/2024. And I can absolutely understand why.

(If you're a data nerd like me, check out this Gist for more popularity graphs: https://gist.github.com/tkrotoff/b1caa4c3a185629299ec234d2314e190)

Just to mention a few features I've grown to love:

  • Built-in Control Flow (@if, @for, @switch): Cleaner templates, less *ngIf clutter.
  • afterRender / afterNextRender: Handy hooks for when you really need to touch the DOM (use responsibly!).
  • Vite & esbuild: Build times often under 5 seconds? This is witchcraft compared to the old Webpack days.
  • Standalone Components: Simpler architecture, less NgModule boilerplate. Feels much more modern.
  • Zoneless (Experimental but Promising): The path to even better performance is clearing up.
  • View Transitions API: Smooth UI transitions out-of-the-box? Awesome.
  • Native async/await: Finally, readable async code without RxJS gymnastics (generators) for simple cases.
  • Function-Based Guards: Cleaner routing logic, less class boilerplate.
  • New @Input() / @Output() Decorators: More flexible and type-safe inputs.
  • inject() Function: Bye-bye constructor clutter and super() calls in many cases.
  • The Revamped Angular CLI (ng): Still powerful, but feels snappier.
  • effect(): Running side effects reactively based on Signal changes. Powerful stuff.
  • The New Docs angular.dev: Big improvement, much easier to navigate and learn from.
  • And oh boy, Signals! (especially combined with effect()s) - more on this below.

Okay, It Wasn't All Sunshine and Rainbows... Some downsides

Let's be real, no framework is perfect. Here are a few bumps I hit:

  • Chunk Mania: The sheer number of JS chunks generated felt... excessive. Seeing ~130 requests for a standard page, even if small, raised an eyebrow. HTTP/2 helps, but it still feels like overkill sometimes.
  • Cloudflare Pages Deployment: Took some wrangling (hah, wordplay IYKYK) with baseHref and deployUrl to get the routing and asset loading right. Tripped me up good for a bit.
  • The Community Bubble: The Angular community is great, but undeniably smaller than the React/Next.js behemoth (especially with Vercel pushing Next hard). This often means:
    • More digging for solutions to niche problems.
    • Fewer readily available, up-to-date boilerplates or complex component examples compared to the React ecosystem. You often find yourself building more from scratch or adapting older patterns.

Signals: The Real MVP?

Signals changed everything for me. One of the biggest performance boosts for rendering the application/components I encountered was with the use of ChangeDetectionStrategy.OnPush and Signals. Reactivity in components in the most performant way, native, out of the box. No more RxJS and manual handling of subscriptions and possible memory leaks when you miss an unsubscribe/cleanup. Just updating the state of a signal and Angular takes care of the rest, re-rendering the UI in the most efficient way.

With Signals, Angular feels more modern, responsive, and intuitive. IMHO it's a game-changer for both performance and developer experience.

For my application, I was impressed by the rendering speed, especially once the chunks are cached. No flickering, no big loading times or similar issues. It even feels like SSR but it's fully CSR.

Quick Dip into SSR

I also took a small dip into Server Side Rendering (SSR), but it seems too early in development to put a production-ready app fully based on a weakly documented feature and limited support (most of the features are still marked as experimental). But what I've seen so far looks promising - definitely looking forward to using it in the near future.

The Developer Experience (DX) Glow-Up

I also have the feeling that Angular is again gaining more traction with many simplified features. Compared to a few years ago when the initial Angular setup or build took hours or even days to get properly running, now everything feels more "fit together" and smooth. The developer experience is quite amazing these days - HMR (Hot Module Reloading) is an awesome new feature that I don't want to miss. Build times under 5 seconds are crazy compared to previous versions. The revamped CLI ng also comes with some awesome (new) features.

Angular was never "meant" to build smaller applications and was always put into the Large Application/Enterprise-Grade Application category. But with the new features, even the smallest application can use Angular without any problems or big overhead, IMHO.

Let's Talk Benchmarks (with a Grain of Salt)

Okay, benchmarks aren't everything, but they can be interesting indicators. When you directly compare some benchmarks between Angular 19 and React, you'll notice that Angular outperforms React in many ways (at least in the benchmarks).

Especially when working with dynamic components in the DOM (versus virtual DOM for React). Also, the memory allocation in Angular is mostly lower than in React, which often impacts the UX (causing lagging pages, slow loading times, cache state issues, etc.). The benchmark for the transferred size from server to client is quite impressive, as Angular transfers nearly half the kB compared to React for the first paint.

Take your own look over here:

This is the selection I've compared (copy the code & paste it on the benchmark website to get the same view I'm talking about):

{"frameworks":["keyed/angular-cf","keyed/angular-cf-new-nozone","keyed/angular-cf-signals","keyed/angular-cf-signals-nozone","keyed/react-classes","keyed/react-compiler-hooks","keyed/react-hooks","keyed/react-hooks-use-transition"],"benchmarks":["01_run1k","02_replace1k","03_update10th1k_x16","04_select1k","05_swap1k","06_remove-one-1k","07_create10k","08_create1k-after1k_x2","09_clear1k_x8","21_ready-memory","22_run-memory","23_update5-memory","25_run-clear-memory","26_run-10k-memory","41_size-uncompressed","42_size-compressed","43_first-paint"],"displayMode":1}

Source: https://github.com/krausest/js-framework-benchmark

Wrapping Up: Stick With What Works (For You!)

Look, I'm not here to bash React or Vue or Svelte or Solid or whatever the flavor of the week is. They're all amazing tools built by smart people. The "best" framework is usually the one you're most productive and comfortable with, instead of learning something new every day.

My point is simply this: If you've drifted away from Angular or dismissed it based on past experiences, it might be worth another look. The developer experience and performance have come a long way. The Angular team and community have done fantastic work steering the ship in a great direction.

In a world often dominated by React chatter, Angular is quietly having a very impressive renaissance.

...and at the end of the day, aren't we all just fighting the same enemy? JavaScript. 😉

What are your recent experiences with Angular? Have Signals changed things for you? Still facing old frustrations? Write it down in the comments - Let's discuss.

PS: If you're interested, the SaaS I mentioned throughout the post is Papersend, and you can find it over at https://papersend.io/. It's free to get started, no credit card or payment required.