Loading · Angular
Stack Innovations/ Services/ Custom Development/ Angular
03 / 08 · Custom Development
000Compiling Angular

Angular

Bespoke Angular applications, engineered for the ten-year arc.

Start a build
The argument

An Angular app is just signals that know exactly when to update.

Each signal · a dependency. Each component · standalone. Each update · fine-grained.
02 — Ecosystem

Angular,
and the right neighbours.

Framework/01
Angular 22

Standalone components by default, signals for fine-grained reactivity. Our default for product surfaces.

StandaloneSignalsSSResbuild
Reactivity/02
Signals

Fine-grained reactive primitives, paired with zoneless change detection to drop Zone.js entirely.

signal()computed()
Async/03
RxJS

Observables for complex async streams and HTTP.

StreamsOperators
Build tool/04
esbuild / Vite dev server

Fast rebuilds via the CLI's esbuild-based builder.

HMRCLI
State/05
NgRx SignalStore

Predictable state for large apps, built on signals.

StoreFeatures
UI/06
Angular Material + CDK

Accessible primitives and Material Design components.

A11yCDK
Rendering/07
Angular SSR / Hydration

Server-side rendering with incremental hydration, built in.

SSRIncremental
Data layer/08
HttpClient + resource()

Typed HTTP client; the resource API wires async data to signals.

Typedresource()
Testing/09
Vitest

Unit and component tests, the CLI's default test runner since Angular 21.

UnitSnapshots
Monorepo/10
Nx

Workspace tooling for multi-app, multi-library Angular monorepos. Cached, parallel builds across packages.

WorkspacesCachingAffected
Testing/11
Playwright

End-to-end flows and visual regression.

e2eVRT
03 — What we build

Three shapes,
one toolkit.

01 — Enterprise
Enterprise
platforms.

Large internal and B2B applications. RBAC, audit trails, DI-driven modularity — wired to scale across teams.

  • Role-based access · per route, per fieldRBAC
  • Audit trail · every mutation loggedNestJS
  • DI tokens · swappable servicesInjectionToken
  • Lazy-loaded feature modulesStandalone
role: admin · scope: org
02 — Admin
Admin &
back-office.

Data-dense CRUD. Virtualised tables, typed reactive forms, bulk actions that don't pretend they're an afterthought.

  • Virtualised tables · 1M rowsCDK
  • Typed reactive formsSignals
  • Bulk actions · undoableOptimistic
  • Permissions · per row, per cellRBAC
id status owner updated
03 — Workspaces
Multi-app
workspaces.

Nx monorepos with shared component libraries across products. One design system, many apps, atomic versioning.

  • Shared UI library · one sourceNx lib
  • Affected-only builds · CI cacheNx Cloud
  • Cross-app routing · module federationStandalone
  • Generators · scaffolded consistencySchematics
app-a app-b app-c libs/ui-kit
/ Phase 01 · Discover

Listen first.

Stakeholder interviews, support tickets, session replays. We map the architecture by mapping the work.

Discovery docTech auditRisk map
SCOPE USERS DATA TEAM RISK OUTCOME
src/app/ features/dashboard/ features/admin/routes.ts features/settings/ shared/ui-kit/ core/services/ core/tokens/
export const ADMIN_TOKEN = new InjectionToken<Config> ('admin.config');
// stat-card.component.ts @Component({ selector: 'app-stat-card', standalone: true, changeDetection: OnPush }) export class StatCard { value = input.required<number>(); trend = computed(() => ...); } → shipped to libs/ui-kit → documented in storybook → tested · jest + a11y
w1 w6 w12 +96 Lighthouse
01
01
05
05 — Architecture

A request,
end to end.

// live · GET /api/orders?status=open
Request Static
Client Angular · Signals Hydrated UI Edge CDN · Cache ~40ms TTFB API NestJS Auth · RBAC DB Postgres Read replicas Observability OpenTelemetry Logs · Traces · Metrics
Client → Edge~10ms
Edge → API~20ms
API → DB~9ms
Round-trip · p95118ms
06 — Numbers

Standards,
not anecdotes.

What every Angular build leaves with — the floor, not the ceiling.

Median Lighthouse 0 perf · across last 12 builds
#StandardFloorMethod
01 Lighthouse · perfdesktop · cold 0 CI
02 Initial bundle · gziproute-level 0kB size-limit
03 Type coveragestrict mode 0% tsc
04 Critical a11y issuesWCAG 2.2 AA 0 axe
05 Test coverageunit + component 0% Vitest
06 Median design → readycomponent-to-component 0d linear
08 — Engagement

Three ways
to start.

01 / Sprint2 weeks
Diagnostic
sprint.
flatfixed scope
  • Tech audit · current Angular stack
  • Architecture proposal
  • Risk & cost map
  • Live walkthrough · written report
Book a sprint
02 / MVP— Most chosen
MVP ship.
retainer4–8 weeks
  • One product surface, end to end
  • Auth · Billing · Telemetry wired
  • Design system seed · 24 components
  • CI/CD · monitoring · runbook
  • Two rounds of post-launch iteration
Start an MVP
03 / Build12+ weeks
Ground-up
platform.
retainerquarterly
  • Multi-surface platform
  • Internal admin + customer app
  • Embedded design partner
  • Hand-off plan, onboarded team
Plan a build
09 — Questions

Things people
actually ask.

Angular gives you an opinionated structure out of the box — routing, forms, DI, HTTP, testing are all first-party and versioned together, which matters at enterprise scale with rotating teams. React asks you to assemble that stack yourself. We reach for Angular when the project is large, long-lived, and benefits from convention; we reach for React when the team already lives there or the surface is smaller and more bespoke.
Standalone, by default, on every new build. Angular has shifted its own documentation and CLI scaffolding to standalone-first since v17, and it removes a whole category of NgModule bookkeeping. We only keep NgModules around when working inside an existing codebase that hasn't migrated yet — and even then, we migrate incrementally rather than block on a big-bang rewrite.
Signals for component state and anything synchronous-feeling — they're simpler to read, simpler to test, and Angular's change detection is built around them now. RxJS stays for genuinely async, multi-event streams: WebSocket feeds, debounced search, complex combineLatest pipelines. The `resource()` API and the RxJS interop layer let both live in the same component without fighting each other.
For genuinely complex, cross-cutting state — yes, and we reach for NgRx SignalStore over the classic actions/reducers/effects setup, since it's built on signals and cuts a lot of boilerplate. For most apps, component-local signals plus a handful of injectable services are enough; we don't introduce a global store until the app actually needs one.
Yes — a large share of our Angular work is exactly this. We run `ng update` schematics where they exist, migrate AngularJS or pre-v14 apps incrementally behind route boundaries, and move NgModules to standalone component by component. No big-bang rewrites; we keep the app shippable at every step.
Vitest for unit and component tests — the Angular CLI's default test runner since v21, faster than Karma and easier to run in CI. Playwright for end-to-end flows and visual regression. axe-core for accessibility checks. CI runs the full suite on every PR; nothing merges if the suite is red.
10 — Start

Let's build
something worth shipping.

Two-week diagnostic, four-week MVP, twelve-week ground-up. Bring the brief — we'll send a plan, not a pitch deck.

Start a project
Tweaks
Accent
Motion
Lenis
Sound