Moving from intermediate to senior Angular development isn’t just about experience — it’s about discipline, architecture, and keeping up with where Angular is headed.

Here are 7 habits you need to drop today if you want your Angular codebase to be respected — and maintainable.

1. Stop Using any—You're Giving Up on TypeScript

If you’re still writing:

getData(): any {
  return this.http.get('/api/data');
}

You’re giving up TypeScript’s biggest strength.

What to Do Instead:

Define interfaces and use generics.

interface ApiResponse<T> {
  data: T;
  status: 'success' | 'error';
}

interface User {
  id: string;
  name: string;
}

getData<T>(): Observable<ApiResponse<T>> {
  return this.http.get<ApiResponse<T>>('/api/data');
}

Why it matters: Strong typing catches bugs early and makes your IDE work for you. Senior developers never give that up.

2. Stop Ignoring ChangeDetectionStrategy.OnPush

Using the default change detection everywhere?

You’re forcing Angular to check too much, too often.

What to Do Instead:

Switch to OnPush and leverage signals or computed().

@Component({
  selector: 'app-list',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `
    <div *ngFor="let item of items()">{{ item.name }}</div>
  `
})
export class ListComponent {
  private service = inject(DataService);
  items = toSignal(this.service.getItems());
}

Why it matters: Performance. Responsiveness. Clean updates. Senior Angular devs let Angular work smarter, not harder.

3. Stop Using Observables Everywhere

Angular devs overuse BehaviorSubject, async pipe, and subscribe() to death.

Yes, RxJS is powerful — but not everything needs to be an observable.

What to Do Instead:

Use Signals for local state and derived data.

items = toSignal(this.dataService.getItems(), { initialValue: [] });

total = computed(() =>
  this.items().reduce((sum, item) => sum + item.value, 0)
);

Why it matters: Signals simplify reactivity. Senior developers use RxJS where it fits — but they don’t force it.

4. Stop Building Monolithic Components

A 300-line component isn’t a badge of honor. It’s a mess waiting to happen.

What to Do Instead:

Break logic into smart and dumb components.

<app-user-management [users]="users()" (userUpdated)="handleUpdate($event)" />
<app-notifications [notifications]="notifications()" />

Use signals to wire things up in the container.

Why it matters: Senior devs separate concerns, reduce cognitive load, and build testable UI units.

5. Stop Manually Managing Subscriptions

Still doing this?

ngOnDestroy() {
  this.subscription?.unsubscribe();
}

You’re wasting time and increasing risk of memory leaks.

What to Do Instead:

Use Angular’s takeUntilDestroyed() or just signals.

updates$ = this.service.updates$.pipe(takeUntilDestroyed(this.destroyRef));

Or better yet:

data = toSignal(this.service.data$);

Why it matters: Angular has evolved. Senior devs don’t cling to old habits.

6. Stop Ignoring Lazy Loading and Code Splitting

Loading everything upfront? Including unused chart libraries and full Material modules?

What to Do Instead:

Split features into lazy-loaded routes and defer heavy components.

{
  path: 'dashboard',
  loadComponent: () => import('./dashboard.component').then(m => m.DashboardComponent)
}

Use @defer to optimize UX.

@defer (on viewport) {
  <app-heavy-chart [data]="chartData()" />
} @placeholder {
  <div>Loading...</div>
}

Why it matters: Faster loads, better user experience. Senior devs plan for scale.

7. Stop Using Outdated Angular APIs

Still using @ViewChild, @Output, and manual ChangeDetectorRef calls like it's Angular 2?

What to Do Instead:

Modern Angular offers better options.

userId = input.required<string>();
userSaved = output<User>();
nameInput = viewChild.required<ElementRef>('nameInput');

Use toSignal() and effect() for cleaner logic.

user = toSignal(this.userService.getUser(this.userId()));

effect(() => {
  if (this.user()) {
    this.nameInput().nativeElement.focus();
  }
});

Why it matters: Angular’s modern APIs reduce boilerplate and improve readability. Senior devs don’t get stuck in the past.

Final Thoughts

If you’re aiming for senior Angular roles, stop doing these things:

✅ Stop using any
✅ Stop ignoring OnPush
✅ Stop Observable overkill
✅ Stop bloating components
✅ Stop manual subscription chaos
✅ Stop loading everything at once
✅ Stop writing Angular like it’s 2017

Start coding with intention.

Senior Angular development is about clarity, maintainability, and smart decisions — not flashy complexity. These 7 habits will separate you from the crowd and help you build apps that are actually worth maintaining.