Angular

Overview

Angular's value is opinionatedness. It ships routing, forms, HTTP, dependency injection, testing and a CLI as one versioned, coherent framework. On a small marketing site that is overhead. On an application that a rotating team will maintain for five years, it is the reason the codebase still makes sense in year three — because the framework, not team convention, decided how things are organised.

We use Angular for admin consoles, internal business systems, dashboards, and applications with complex forms and role-based access. Those are the problems it is genuinely best at.

Modern Angular

Angular today is substantially different from the NgModule-heavy framework people remember, and a lot of published advice is out of date.

• Standalone components. NgModules are no longer required. Components declare their own dependencies, which removes a large amount of ceremony and makes the dependency graph readable.
• Signals. Fine-grained reactivity that makes change detection predictable and removes a whole category of performance problems. New work is signal-based, with computed for derived state and effect used sparingly and deliberately.
• Zoneless change detection. Where the application is fully signal-based, dropping Zone.js removes measurable overhead and a common source of confusing behaviour.
• New control flow — @if, @for, @switch — which is faster than the structural directives it replaces and considerably easier to read.
• Typed reactive forms, so form state is checked at compile time instead of failing at runtime on a typo.

Architecture

• Feature-based structure, with a shared layer for genuinely reusable pieces and no circular dependencies between features.
• Smart and presentational components separated, so business logic is testable without rendering.
• Services for data access, with HTTP concerns in interceptors rather than repeated in every call site.
• State handled with signals or a store, chosen by actual complexity. NgRx is powerful and it is also a significant amount of boilerplate; we introduce it when shared state genuinely warrants it, not by default.
• Strict TypeScript. strict mode on from day one, because turning it on later is a project of its own.

RxJS, used carefully

RxJS is the part of Angular that most often becomes unmaintainable. Deeply chained operators, nested subscriptions and manual subscription management produce code that only its author understands, and memory leaks nobody notices until a long session degrades.

Our rules: prefer the async pipe or signals over manual subscription; use takeUntilDestroyed where a subscription is unavoidable; keep operator chains short and named; and use flattening operators deliberately — switchMap for cancellable requests like typeahead, concatMap where order matters, exhaustMap to swallow double submissions.

Performance

• Lazy-loaded routes so the initial bundle contains only what the first screen needs.
• OnPush change detection everywhere, or signals, so Angular is not re-checking the whole tree on every event.
• @defer blocks for below-the-fold and heavyweight components.
• Virtual scrolling for long lists rather than rendering thousands of DOM nodes.
• Bundle budgets enforced in the build, so a careless import does not quietly add hundreds of kilobytes.
• Angular Universal for server-side rendering with hydration where first paint or SEO matters.

Testing and quality

Angular's testing story is one of its strengths and we use it. Unit tests on services and business logic, component tests for meaningful UI behaviour rather than for coverage percentages, and end-to-end tests with Playwright or Cypress on the flows that would cost real money if they broke. All of it in CI, with linting and strict compilation as gates.

Upgrades

Angular releases twice a year with a predictable support window, which is an advantage if you plan for it and a problem if you do not. ng update handles most of the work through automated migrations, and staying current is dramatically cheaper than jumping four versions under pressure. We take on legacy upgrades too, including AngularJS and older Angular applications — incrementally, keeping the application deployable throughout, rather than through a big-bang rewrite.

Security

Angular escapes interpolated values by default, which prevents most XSS — provided nobody reaches for bypassSecurityTrust to silence a warning. We keep authentication tokens out of localStorage where the threat model calls for it, enforce authorisation on the server as well as in route guards, and audit dependencies continuously. Route guards improve the user experience; they are not a security control.

How we work

1. Model the domain and the permissions before writing components.
2. Set up strict TypeScript, linting, bundle budgets and CI on day one.
3. Build feature by feature, each one demonstrable.
4. Test the flows that matter and keep them green in CI.
5. Document the architecture so a new developer is productive in days rather than weeks.

What you get

• A modern standalone, signal-based Angular application, not a legacy pattern rebuilt in a current version.
• Strict typing end to end, with typed forms and typed API contracts.
• Enforced bundle budgets and lazy loading.
• Meaningful automated tests running in CI.
• A documented upgrade path so the next version is routine work.

Angular is overhead on a small site and an advantage on a large one. The break-even point is roughly where the team becomes bigger than the people who wrote it.