roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for RxJS interviews on how observables run, how operators compose and when a stream really ends. Covers flattening and joins, subjects and sharing, error recovery, schedulers and marble tests.
174 of 174 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 174 new. 0 cut, outside your plan.
RxJS questions arrive mostly inside Angular frontend loops, where the framework's HTTP client, router and forms all return observables, and they usually surface in the framework round rather than in a round of their own. A frequent live exercise is a search box: wire input events to a backend so that fast typing sends few requests and a slow early response never overwrites a later one. The pieces are debounceTime, distinctUntilChanged and switchMap, and the follow-up asks what mergeMap would get wrong in the same place. Backend loops on NestJS meet the library less often, through interceptors that wrap a handler's observable.
Early questions check the model: why nothing runs until something subscribes, how an observable differs from a promise that has already started, and why two subscriptions to one HTTP observable send two requests. Further up, the questions turn to lifetimes and failures. Which subscription keeps running after the component that opened it is destroyed? Why does shareReplay(1) keep a socket open when every subscriber is gone, and what does refCount: true change? Why does one failed request end a polling stream for good unless the error is caught inside the inner observable? Stronger candidates answer by naming who owns each subscription and which side effects repeat on a retry, and they settle a timing claim with a marble test instead of an argument.
Each RxJS module in the plan sits after the language-neutral idea it implements, so the operator names arrive with a decision already behind them. The opening stretch is plain JavaScript: promise behaviour, the eager, single-value contract an observable is usually compared against, and the event loop, whose timer and microtask queues the RxJS schedulers later build on.
The stream model comes next. The Observer pattern gives the shape, and the stream concepts add what the pattern leaves out: a terminal completion or error, and the cold-versus-hot question behind most duplicated requests. Only then does the library's own Observable constructor and teardown appear, with the creation functions that turn events, timers and promises into streams.
Transforming Streams pairs flattening strategies in general with switchMap and its siblings, with filtering, throttling and joins beside them. Subjects and sharing follow, because share and shareReplay are operators themselves and multicasting is the cold-to-hot conversion the stream concepts named.
The last stretch is about how streams end and when they run. Failure handling puts the neutral rules first, that an error is terminal and that a retry re-runs the source from the top, before catchError and retry themselves. The subscribe and observe sides of a pipeline then lead into schedulers and unsubscribing. Marble tests close the plan: virtual time stands in for those schedulers, and any earlier behaviour can be pinned down by one.
With a week to go and an Angular job in view, let the controls do the narrowing: level cut to the band the posting names, importance at must know only, study order left on by frequency. Flattening operators, subjects and unsubscribing usually carry the Angular questions, so they repay that week best. With more time, switch study order to by topics and take the plan from the top; the concept modules are what make an operator choice explainable rather than memorised. Developers arriving from Reactor or RxJava already hold most of those concepts and can move through them quickly. What is new to them is the single JavaScript thread, schedulers built on its queues, and a library with no demand-based backpressure to lean on. For a senior loop, the hours belong in failure handling, teardown and marble tests; interviewers at that level rarely stop at `map` and `filter`. The plan stops at the library's edge. How Angular consumes it, through the async pipe, `takeUntilDestroyed`, `toSignal` and NgRx effects, belongs to the [Angular roadmap](/roadmaps/angular), which carries RxJS inside a larger plan of its own.
With a week to go and an Angular job in view, let the controls do the narrowing: level cut to the band the posting names, importance at must know only, study order left on by frequency. Flattening operators, subjects and unsubscribing usually carry the Angular questions, so they repay that week best. With more time, switch study order to by topics and take the plan from the top; the concept modules are what make an operator choice explainable rather than memorised. Developers arriving from Reactor or RxJava already hold most of those concepts and can move through them quickly. What is new to them is the single JavaScript thread, schedulers built on its queues, and a library with no demand-based backpressure to lean on.
For a senior loop, the hours belong in failure handling, teardown and marble tests; interviewers at that level rarely stop at map and filter.
The plan stops at the library's edge. How Angular consumes it, through the async pipe, takeUntilDestroyed, toSignal and NgRx effects, belongs to the Angular roadmap, which carries RxJS inside a larger plan of its own.