Articles

Tags and invalidation

Next 16 split invalidation in two: updateTag buys correctness with latency, revalidateTag buys latency with staleness

Next.js · 17 min read

The Cache Components model

Next 16 caches nothing unless you opt in, and that inversion is why most existing Next.js advice is now actively wrong

Next.js · 35 min read

Build time, request time, and the client

Your code runs at one of three moments, and whether guessing wrong suspends or throws depends on whether the value can wait

Next.js · 24 min read

File conventions and the route tree

The file conventions are a fixed wrapper stack, and each wrapper has a different relationship to the two rendering passes

Next.js · 19 min read

Rules of the server boundary

Four scopes forbid different things, and the rules are enforced unevenly — one violation fails silently into a plausible value

Next.js · 24 min read

Server and Client Components

The use client directive marks an entry point into the client module graph, spreading through import and never through JSX

Next.js · 25 min read

Thinking in the App Router

A route is not static or dynamic but a static shell with holes, and every piece of data answers one of four questions

Next.js · 24 min read

A signed-in user sees someone else's data

A cached scope keys on its arguments and not the request, so two of the three ways to leak another user's data go uncaught

Next.js · 15 min read

Client-side rendering

Client-side rendering is a legitimate fourth answer, and the mistake is choosing it for a page rather than for a boundary

Next.js · 18 min read

The static shell and streaming

A Suspense boundary is the seam between two rendering passes, so its placement decides what exists before the request arrives

Next.js · 19 min read

Micro-frontends: the decision

Micro-frontends buy independent deployment for independent teams, and most teams that reach for them do so too early

React · 18 min read

Module Federation in practice

Module Federation is runtime code sharing, and sharing exactly one React across host and remote is what decides whether it works

React · 17 min read

Accessibility in React

React ships inaccessible DOM as happily as accessible DOM, so almost every win comes from not fighting the platform

React · 16 min read

Performance profiling

Profiling is measurement, not optimization, and conflating the React layer with the browser layer is how it usually goes wrong

React · 23 min read

TanStack Router — the type-safe alternative

The capability React Router has no clean answer for is validated, typed search params, and it costs a generated route tree

React · 15 min read

Custom Hooks

A custom hook buys a name and a boundary, never shared state, and the craft is what you extract rather than how you extract it

React · 19 min read

Effects and Synchronization

Reading useEffect as a lifecycle hook rather than a synchronization contract is the root of nearly every way it gets misused

React · 24 min read

Escape Hatches Audit

Three escape hatches exist because the ordinary tools cannot wait, and useLayoutEffect, useSyncExternalStore and flushSync each charge for it

React · 20 min read

useRef and the DOM

State is for values that drive renders and refs are for values that survive them, and React 19 removed most of the DOM ceremony

React · 19 min read

Forms: Controlled and Uncontrolled

Controlled versus uncontrolled is a per-field decision, settled by whether anything needs the value before the form is submitted

React · 19 min read

Component Composition

Composition rests on the owner versus parent distinction, and the ladder from children to render props is climbed only as far as forced

React · 20 min read

Components and Props

A component's props type is its public API, and designing it well is what makes invalid usage fail to compile instead of at runtime

React · 18 min read

Conditional Rendering and Events

Branching and event handling look trivial and hide real machinery, from unmount-versus-hide decisions to blur firing before click

React · 20 min read

JSX and Rendering

JSX is sugar for function calls that return plain objects, and reading it that way dissolves a whole class of React confusion

React · 18 min read

The Rules of React

React's rules are the load-bearing assumptions of the hook list, StrictMode, concurrent rendering and the Compiler, not etiquette

React · 18 min read

Thinking in React

React bets that your UI is a function of state, and most React bugs come from fighting that bet rather than from the API

React · 21 min read

A refresh storm on 401 logs the user out

Parallel 401s each triggering their own token refresh is what logs the user out, and a single-flight refresh is the fix

React · 9 min read

Logout clears the token but not the cache

Clearing the token does not end the session, so logout needs one shared teardown that cancels, wipes and broadcasts across tabs

React · 9 min read

The protected page flashes before the redirect

Auth has three states, not two, and deciding in a route loader before the protected component mounts is what removes the flash

React · 8 min read

After "cancel" the list never refreshes — or after invalidate a ghost write returns

Cancel stops in-flight work and invalidate marks stale and refetches, and an optimistic mutation needs both in the right order

React · 4 min read

Cart rows each call useQuery in a .map — hooks explode or the API melts

A runtime-length list of queries needs useQueries or a batched endpoint, because calling useQuery inside a map breaks the hook rules

React · 4 min read

Checkout refetches on every visit — even 3 seconds later

Force a refetch on mount only where correctness demands it, and keep the cached data so the screen still paints while it runs

React · 5 min read

Infinite scroll loads page 80 and the tab runs out of memory

An infinite feed has to page forever without keeping forever, which means capping retained pages as well as virtualizing the DOM

React · 4 min read

mutateAsync crashes the page — or nested onSuccess hell blocks a multi-step signup

Default to mutate and reach for mutateAsync only when you genuinely need a promise, because its rejections are yours to catch

React · 4 min read

Persisted Query cache writes PII into localStorage — and survives logout

Persisting the query cache is safe only as an allowlist of public data with a user-scoped buster that logout actually clears

React · 4 min read

Pull-to-refresh on a Suspense infinite feed flashes the whole skeleton

A suspending refetch hides the list unless it runs in a transition, and Retry only works if the cached error is reset with it

React · 4 min read

Search Race Condition: Stale Results Overwrite Fresh Ones

Search-as-you-type needs a race policy, not just a debounce, because the network will happily deliver an old query last

React · 16 min read

Skimming the product grid fires dozens of prefetch GETs

Prefetch on intent rather than on hover, and give it a real staleTime, or the warm cache gets refetched the moment it is used

React · 3 min read

The Cancel button on a large upload does nothing

Mutations do not get the automatic abort signal queries do, so a working Cancel means threading your own controller through

React · 4 min read

The ops board sits stale while the operator stares at it

Stale does not mean refetch, so a watched dashboard needs an interval on that surface alone rather than a global polling default

React · 4 min read

The spinner never resolves after you navigate away and back

A spinner that never resolves is a loading flag that outlived its request, so derive loading from the request rather than storing it

React · 10 min read

Double Submit and the Optimistic Like

Client pending state stops the second click, but only a server idempotency key actually prevents the duplicate order

React · 14 min read

A remote's independent deploy silently breaks the host

A remote's exposed props are a versioned public API, so compatibility has to be checked at runtime and evolved additively

React · 9 min read

A shared store couples your remotes back into a monolith

A shared mutable store re-couples independently deployed remotes, so share server truth and versioned events instead of state

React · 9 min read

One remote 404s and the whole shell goes white

A remote that fails to load should degrade inside its own slot, or a three-minute CDN blip becomes a full product outage

React · 9 min read

One remote's CSS restyles another — depending on load order

Global selectors in one remote restyle another once load order decides the cascade, so scoping has to be structural not careful

React · 8 min read

The remote crashes with "Invalid hook call" — but only inside the shell

An invalid hook call only inside the shell means two copies of React, so federation has to treat React as a strict singleton

React · 9 min read

A 900KB bundle loads before anyone sees the login screen

The initial download should carry only the first screen, with routes and heavy libraries pulled in on navigation or interaction

React · 7 min read

Switching to the "All transactions" tab freezes the page for six seconds

Ten thousand rows in one synchronous commit is the freeze, and virtualizing down to the visible window is what removes it

React · 7 min read

The hero paints five seconds late because the page is client-rendered

A client-rendered hero cannot paint until the JavaScript does, so the LCP element has to be in the initial server response

React · 8 min read

Typing Lag: The Re-render Storm

The fix for a typing-lag re-render storm is structural, and the diff contains no hand-written memo, useMemo or useCallback at all

React · 14 min read

Clicking a lazy route blanks the screen before the page appears

Keep the current page on screen while the next chunk loads, because unmounting it first is what turns code splitting into a flash

React · 8 min read

Hitting Back dumps the user at the top of the list instead of where they were

Scroll restoration needs the list data loaded before render, otherwise the router restores a position the page does not have yet

React · 8 min read

URL params drift out of sync with component state

Mirroring the URL into state is what makes filters vanish on Back, so derive from the address bar during render instead

React · 8 min read

"use client" crept up the tree and shipped your whole page to the browser

The use client directive marks a boundary rather than a file, so everything below it ships and the boundary belongs at the leaves

React · 9 min read

The page flashes and the console floods with hydration errors

Hydration errors come from environment-divergent values in the first render, so read time, locale and storage only after mount

React · 8 min read

The Server Action succeeded, but the page still shows the old value

A successful write still shows stale UI until you invalidate the exact cache it came from, and the client cache is a second one

React · 8 min read

Context Re-Renders the Whole Tree

Splitting context by change cadence and pushing reads down to leaves fixes most context re-render storms, until it stops being enough

React · 10 min read

Server data in a Zustand store goes stale

Server state in a client store goes stale with nothing to refresh it, which is why a query cache owns it and Zustand keeps the rest

React · 10 min read

Error Boundaries

Without a boundary a single throw during render unmounts the entire tree, and the real skill is telling error state from error throws

React · 17 min read

How React Renders

Render is pure and disposable while commit is synchronous and atomic, and that split explains most of what React seems to do arbitrarily

React · 26 min read

Memoization and the Compiler

React Compiler inverts the memoization deal, so the job is now verifying it worked rather than hand-placing memo and useMemo

React · 21 min read

Portals and the Event System

A portal splits the React tree from the DOM tree, and every portal question reduces to asking which of the two governs the behavior

React · 19 min read

Rendering Lists and Keys

A key is an item's identity across renders, and identity decides what persists, which is why index keys corrupt state in real lists

React · 21 min read

Next.js and RSC in practice

Next 16 made caching opt-in, so everything is dynamic by default and the build errors on uncached request-time data outside Suspense

React · 18 min read

Context

Context is a transport, not a store, so every reader re-renders on every change and nothing you wrap around a reader prevents it

React · 19 min read

State and useState

State is a snapshot plus a queue, and every classic useState confusion comes from reading it as an ordinary JavaScript variable

React · 22 min read

useReducer and State Structure

The choice is not useState versus useReducer but where the rules live, and most reducer pain turns out to be state shape pain

React · 21 min read

Angular DevTools

The official browser extension inspects your component tree, profiles change detection, and maps the injector hierarchy

Angular · 9 min read

Animations

Angular's animation DSL is a state machine — you declare states and transitions, and the runtime handles interpolation and cleanup

Angular · 10 min read

Change Detection

Change detection in v22 is re-engineered around signals — OnPush by default, zoneless new apps, and updates only where data changed

Angular · 20 min read

Component Interactions: Input, Output, and Two-Way Binding

Parent and child talk through inputs, outputs, and two-way bindings, and an Observable can serve directly as an output

Angular · 7 min read

Component Lifecycle

Angular calls lifecycle hooks in a fixed order, and knowing exactly when each one fires is what separates subtle bugs from solid components

Angular · 14 min read

Dynamic Components in Angular

Runtime component creation survived intact but its API did not, and setInput is now required for signal inputs to react

Angular · 17 min read

Angular Material

Google's official component library ships accessible Material Design 3 components with build-time theming through CSS custom properties

Angular · 11 min read

Choosing an Angular UI Library

Angular Material is the safest long-term bet, while PrimeNG, NG-ZORRO, and the commercial suites win on breadth or data-heavy grids

Angular · 6 min read

View Encapsulation

Three encapsulation modes decide whether a component's styles stay private or leak, which explains most CSS that will not apply

Angular · 10 min read

Angular Data Binding

Every Angular binding syntax is sorted by the direction data travels between the component class and its template

Angular · 5 min read

Built-in Control Flow

Built-in blocks replaced the structural directives with no imports to remember, a required track, and real TypeScript narrowing

Angular · 10 min read

Content Projection

Content projection passes markup written between a component's tags into its template, the Angular equivalent of a web component slot

Angular · 3 min read

Template Variables, ViewChild, and ContentChild

Template reference variables reach elements from the template, while ViewChild and ContentChild queries reach them from the class

Angular · 6 min read

Dependency Injection

The DI mental model is unchanged since Angular 9, but inject() now reaches places a constructor cannot, like guards and interceptors

Angular · 26 min read

Attribute Directives

Attribute directives change how an existing element looks or behaves, which is what separates them from structural directives

Angular · 2 min read

Composing Form Data Sources with Directives

Pairing a directive with an injection token lets one shared select control pick its data source declaratively at each call site

Angular · 3 min read

ng-template, ngTemplateOutlet, and ng-container

ng-template stores markup that never renders where it is defined, and ngTemplateOutlet decides when and where it lands

Angular · 4 min read

Structural Directives

Structural directives add, remove, and reshape the DOM, and the asterisk is shorthand for the ng-template they work through

Angular · 5 min read

Angular Form Async Validators

Async validators cover the checks that need a server answer, such as whether the username someone typed is already taken

Angular · 4 min read

Angular Reactive Forms

The FormGroup runtime model is unchanged, but typed forms and nonNullable controls changed how you declare a form and how it infers

Angular · 20 min read

Angular Template-driven Forms

Template-driven forms build the model from directives in the template, with two-way binding keeping component state in sync

Angular · 8 min read

DisabledControlDirective for Reactive Forms

Reactive forms warn against the disabled attribute in templates, and a small directive is the supported way to keep disabling declarative

Angular · 2 min read

Signal Forms

Signal Forms drops FormGroup for a plain signal of data plus a field tree exposing value, errors, and touched as signals

Angular · 11 min read

Getting Started with Angular

Scaffolding a v22 app produces standalone components and an app config file rather than the AppModule the CLI used to generate

Angular · 14 min read

TypeScript Prerequisites for Angular

The TypeScript you need before Angular makes sense, from interfaces and generics to the utility types v22 code leans on

Angular · 10 min read

HTTP

HttpClient is a typed layer over the browser's Fetch API with an interceptor pipeline every request and response passes through

Angular · 11 min read

HTTP Error Handling

Angular wraps every HTTP failure into one HttpErrorResponse, and a status of zero is what tells network errors apart from server errors

Angular · 12 min read

HTTP Interceptors

Interceptors are middleware for HttpClient, one ordered place to attach auth headers, retry requests, or normalize errors app-wide

Angular · 12 min read

Micro Frontends with Module Federation

Micro frontends still work the same way, but the esbuild builder means Native Federation and import maps replaced webpack federation

Angular · 25 min read

Transform Data with Angular Pipes

Pipes turn raw values into display-ready output inside the template, and reuse better than a formatting method per component

Angular · 6 min read

Signal Inputs

Signal inputs arrive as read-only signals, so parent values feed computed and effect directly with no ngOnChanges plumbing

Angular · 13 min read

Signals

A signal tracks every place its value is read, which lets Angular update only the consumers that depend on what changed

Angular · 15 min read

toSignal & toObservable

These two helpers bridge Angular's two reactivity models, letting Observable sources and signal consumers meet in one component

Angular · 12 min read

Introduction to RxJS and Observables

Angular leans on RxJS everywhere, and the shift it demands is thinking in streams of values over time rather than single results

Angular · 6 min read

RxJS Combination Operators

Combination operators merge several Observables into one, and choosing between forkJoin, combineLatest, and zip is a timing decision

Angular · 11 min read

RxJS Creation Operators

Creation operators build Observables for you, so you stop hand-writing subscribe and teardown functions for every source

Angular · 6 min read

RxJS Error Handling and Conditional Operators

An error terminates an Observable, so catchError and retry exist to replace or restart the stream rather than resume it

Angular · 6 min read

RxJS Filtering Operators

Filtering operators drop values on their way through a stream, the Observable counterpart to filtering an array

Angular · 10 min read

RxJS Higher-Order Observables and Utility Operators

Higher-order operators map each value to an inner Observable, and the flattening strategy decides what happens when they overlap

Angular · 8 min read

RxJS Subjects, Multicasting, and Unsubscribe in Angular

A Subject multicasts one execution to many subscribers, which is also where unsubscribing in Angular stops being optional

Angular · 11 min read

RxJS Transformation Operators

Pipeable operators return a new Observable instead of mutating the source, and transformation operators reshape each value in flight

Angular · 5 min read

App Initialization: Silent Token Restoration on Reload

A silent refresh call before the app renders is what keeps in-memory tokens from logging users out on every page reload

Angular · 14 min read

JWT Interceptor: Breaking the Circular Dependency

The cycle between an auth service and its JWT interceptor is an architecture problem, and extracting a token service is the fix

Angular · 13 min read

Step-up Authentication: Re-auth for Sensitive Actions

An interceptor can catch a step-up challenge, collect fresh credentials, and retry the original request without the caller knowing

Angular · 18 min read

Token Storage: Where Tokens Should Actually Live

Access tokens belong in memory and refresh tokens in an HttpOnly cookie, because anything in localStorage is readable by any script

Angular · 16 min read

Component Communication: When NgRx Is Overkill (And When It Isn't)

Where shared state belongs is usually answered by a scoped service and signals, with NgRx as the exception rather than the default

Angular · 19 min read

Virtual Scrolling: Rendering 10,000 Items Without Killing the Browser

Rendering only the visible window keeps a ten-thousand row list responsive, provided tracking and viewport height are set correctly

Angular · 16 min read

A Search Engine in Five Stages

Search as you type grows in five stages, from debounce and switchMap to URL-synced filters with stale-while-revalidate caching

Angular · 19 min read

Async Validation: Username Availability Without the Flicker

A server-backed availability check needs debouncing, deduplication, and explicit pending states or the field flickers and hangs

Angular · 15 min read

Dynamic Forms: Shape That Changes With User Input

Forms that change shape at runtime lose user input unless you cache removed control values and revalidate the controls yourself

Angular · 17 min read

Multi-Step Wizards: State That Survives the Back Button

A wizard's state has to outlive its step components, which is why the form model belongs in a subtree-scoped service

Angular · 17 min read

Optimistic Updates: UI That Feels Instant Without Lying

Applying the user's intent locally and rolling back on failure is what makes an interface feel instant without misreporting results

Angular · 17 min read

Request Deduplication: One Call When Five Would Fire

When several callers ask for the same resource at once, an in-flight cache collapses them into a single HTTP round trip

Angular · 15 min read

Retry with Backoff: Surviving Transient API Failures

Retrying with exponential backoff hides transient failures, but only if the policy separates retryable errors from terminal ones

Angular · 17 min read

Upload and Download Progress with HttpClient

One custom operator turns HttpClient's raw event stream into the status and percentage a progress bar can bind to directly

Angular · 13 min read

WebSocket Integration: Real-Time Data Without the Reconnection Hell

One shared connection with backoff reconnection and a heartbeat is what separates a working real-time layer from a demo

Angular · 18 min read

Bundle Splitting: Beyond Lazy Routes

Lazy routes alone rarely shrink the initial bundle, because the weight usually sits in libraries the entry point still imports

Angular · 19 min read

Image Optimization: LCP Wins Without Rewriting Everything

NgOptimizedImage handles the sizing, format, and priority hints that most LCP problems come down to, without rewriting the page

Angular · 15 min read

Performance Auditing: "The App Is Slow, Where Do I Look?"

Pick one symptom and profile it before optimizing, because blind OnPush and trackBy changes usually spend the budget on nothing

Angular · 21 min read

Web Workers: Heavy Computation Without Freezing the UI

Moving CPU-heavy work to a worker keeps the UI responsive, and Comlink makes the message protocol read like ordinary method calls

Angular · 18 min read

Service Worker: Offline-First Without Losing User Data

Offline support is more than caching assets, because the work users actually lose is the pending mutation that never reached the server

Angular · 20 min read

Custom RxJS Operators with takeUntilDestroyed

A custom operator can bake teardown into a polling stream, so consumers get cleanup on destroy without writing ngOnDestroy

Angular · 11 min read

Race Conditions: Picking the Right Higher-Order Operator

Most Angular race conditions are one wrong higher-order operator, and switchMap, exhaustMap, concatMap, and mergeMap each fix a different one

Angular · 17 min read

Hover- and Viewport-Triggered Route Preloading

Preloading lazy chunks on hover or viewport entry removes the click-then-wait pause, as long as slow connections are excluded

Angular · 15 min read

SSR + Hydration: Debugging the Mismatches

Most hydration bugs trace back to server and client rendering different markup, and the console warning usually names the mismatch

Angular · 20 min read

NgRx → Signal Store: Migrating Without a Big-Bang Rewrite

Both stores can run side by side, so moving from NgRx to Signal Store happens one feature slice at a time rather than in one rewrite

Angular · 21 min read

Testing Signal-Based Components: Patterns for the v22 Era

Signal-based components need different test patterns, starting with effects that do not run until the test tells them to

Angular · 17 min read

@defer Blocks

Deferred blocks code-split part of a template, so its dependencies download only when a trigger such as viewport entry fires

Angular · 11 min read

SSR & Hydration

Server rendering ships HTML the browser paints immediately, and hydration reuses that DOM instead of discarding and rebuilding it

Angular · 15 min read

ViewRef & Renderer2

The view container and renderer APIs cover the small share of DOM work that Angular templates cannot express declaratively

Angular · 10 min read

Angular Router

The router still maps a config tree onto outlets, but provideRouter replaced RouterModule.forRoot and the routing module around it

Angular · 19 min read

Angular Router — Feature Modules, Child Routes, and Services

Child routes and per-feature route files keep a growing app's routing config from collapsing into one flat list at the root

Angular · 5 min read

Angular Router — Guards and Resolvers

Guards and resolvers hook into the router's navigation cycle, so access checks and data loading finish before a route renders

Angular · 12 min read

Angular Router — Lazy Loading Modules

Lazy loading defers a feature's code until someone navigates to it, so the initial bundle carries only what the first screen needs

Angular · 6 min read

Router Outlets

An outlet marks where the matched component is inserted, and named outlets let independent sections update from a single URL

Angular · 12 min read

routerLink & Directives

routerLink navigates inside the app instead of asking the browser for a new document, and routerLinkActive marks the current route

Angular · 11 min read

NgRx Signal Store

Signal Store keeps the NgRx family but drops the Redux ceremony, replacing actions and reducers with state signals and methods

Angular · 11 min read

NgRx Store

NgRx brings Redux to Angular with real boilerplate cost, paid back in predictable state transitions and time-travel debugging

Angular · 12 min read

NGXS

NGXS keeps unidirectional data flow but expresses actions as classes and state changes as decorated methods on a state class

Angular · 9 min read

Component Harnesses

A harness puts a stable API in front of a component's DOM, so restructuring the template stops breaking every test that touched it

Angular · 10 min read

E2E Testing

End-to-end tests drive a real browser through whole user journeys, catching production-build and cross-component failures units miss

Angular · 10 min read

Integration Tests

Integration tests widen the boundary to a real component tree or route, faking only what genuinely sits outside the app

Angular · 10 min read

Unit Tests

TestBed builds a minimal Angular environment per spec, so one component runs with real DI and templates but fake dependencies

Angular · 14 min read

Angular Elements

Angular Elements wraps a component as a native custom element, so a React, Vue, or plain HTML page can embed it without Angular

Angular · 10 min read

Builders

Every CLI command delegates to a builder, a schema-validated task function you can configure precisely or replace with your own

Angular · 10 min read

Built-in i18n

Built-in i18n inlines translations at build time into one bundle per locale, costing nothing at runtime but tying language to the URL

Angular · 11 min read

Input Coercion: built-in transforms and CDK utilities

Built-in input transforms replaced the CDK setter dance for boolean and number inputs, leaving CDK coercion for the rest

Angular · 9 min read

Ionic

Ionic adds a platform-adaptive mobile UI layer to Angular, and Capacitor packages the same codebase into real iOS and Android apps

Angular · 11 min read

ngx-translate

Loading translation JSON at runtime buys instant language switching, at the cost of parsing and lookup work in the browser

Angular · 10 min read

Nx

Nx makes a monorepo practical by mapping project dependencies, then rebuilding and retesting only the projects a change affects

Angular · 14 min read

Progressive Web Apps (PWA)

Registering a service worker gives an Angular app offline support, cached repeat loads, background updates, and installability

Angular · 9 min read

Sass & SCSS

Angular compiles SCSS out of the box, so the real work is pairing Sass authoring features with component style encapsulation

Angular · 11 min read

Schematics

A schematic writes files through a virtual tree rather than the disk, which is what makes generation previewable and safe to abort

Angular · 10 min read

Persistence boundaries

Your ORM already gives you a repository, so a second one buys only changeability, and the real boundary is the transaction

NestJS · 17 min read

Bootstrap and lifecycle hooks

The port is bound only after every bootstrap hook resolves, and shutdown hooks do not run until you opt in

NestJS · 18 min read

Configuration and environment

Config is the only untyped, unvalidated, externally supplied input, so convert and validate all of it once, at boot

NestJS · 18 min read

Controllers and routing

There is no routing table — precedence emerges from declaration order, which is why a shadowed route raises no error

NestJS · 19 min read

Custom providers and injection tokens

Four provider forms collapse into one runtime decision, construct the class or call the factory and await it

NestJS · 18 min read

Decorators and metadata reflection

Decorators annotate and the framework behaves, so a decorator that does nothing wrote the wrong key or the wrong target

NestJS · 18 min read

Modules and the module graph

A module is a visibility boundary with an identity, and those two properties are enforced by different mechanisms

NestJS · 19 min read

Providers and dependency injection

Nest injects tokens, not types, so every resolution error is a wrong token or a module that cannot see it

NestJS · 20 min read

Scopes and lifetimes

Scope belongs to a dependency tree, declared in one place and taking effect upward through everything that injects it

NestJS · 20 min read

TypeScript for Nest

Type erasure is a runtime property in Nest, because the framework reads your types back through reflection

NestJS · 21 min read

Exception filters

Filters are the only layer where exactly one participant runs, so adding a filter can mean removing another

NestJS · 20 min read

Execution context and Reflector

The execution context is a typed view over one arguments array, so switching it to the wrong transport fails silently

NestJS · 16 min read

Execution order

The pipeline is a nesting rather than a list, so guards sit outside the interceptor chain and pipes run inside it

NestJS · 18 min read

Guards

A guard runs before validation, so the body it reads is raw input and returning false always renders as 403

NestJS · 17 min read

Interceptors

The handler arrives as a deferred observable, so an interceptor holds the decision to invoke it at all

NestJS · 17 min read

Middleware

Middleware is the adapter's layer, wrapped just enough to reach filters and inject providers, and every limit follows

NestJS · 18 min read

Pipes

A pipe sees one argument and learns its type from emitted metadata, so an interface DTO disables validation silently

NestJS · 16 min read

DTOs and class-validator

A DTO is not a type but a runtime object carrying metadata, so a nested property without @Type passes ValidationPipe silently

NestJS · 18 min read

Serialization and response shaping

Serialization is the direction where a mistake leaks rather than rejects, and Exclude gives false confidence three ways

NestJS · 18 min read

ValidationPipe in depth

Three of ValidationPipe's defaults are the opposite of its reputation, starting with transform being off

NestJS · 18 min read