Creator on Bloom
Bloom
Curated tutorials by the Bloom team
39
Tutorials
518
Readers
6
Completions
3
Likes
Tutorials
What the React Compiler Actually Memoizes (and What It Can't)
Read real React Compiler 1.0 output line by line, see why components stop re-rendering without React.memo, hand-compile a component yourself, and learn the cases it can't fix: mutation, values from outside React, rule violations it silently skips, and work that's slow even when memoized. Ends with a safe rollout plan.
advanced 11 steps 70 min 0 readersFix INP: Make a Slow React App Respond in Under 200 ms
A hands-on INP clinic: what Interaction to Next Paint measures and how it's scored, a live meter that breaks every interaction into input delay, processing and presentation, and the React fixes that move each one (useDeferredValue, virtualization, yielding to the main thread, splitting handlers) on a deliberately slow app you can feel.
advanced 12 steps 80 min 0 readersHow Linear Feels Instant: Build a Local-First Sync Engine
Why apps like Linear never show a spinner, and how to build the engine behind it: a local store every read comes from, optimistic transactions, a server that orders every change, deltas and catch-up, an offline outbox with safe retries, field-level conflicts, fractional ordering, and a live two-client demo you can break.
advanced 14 steps 90 min 10 readersVercel AI SDK and LangChain.js: Real Projects
Build five real AI features with the Vercel AI SDK and LangChain.js: a streaming chat with useChat, typed structured output, tool calling with per-user security, RAG with LangChain retrievers, and a LangChain agent streamed into useChat. Plus safe output parsing, how pipe() works, and shipping responsibly.
intermediate 14 steps 80 min 6 readersDates, Times, and Time Zones
Handle time correctly for users everywhere: instants vs calendar dates vs wall times, the classic bugs, formatting with Intl, daylight saving gaps and overlaps, converting wall time in any zone to an instant, relative times, Temporal, storage and API rules, and SSR hydration.
intermediate 11 steps 60 min 2 readersRAG Explained for Frontend Developers
Retrieval-augmented generation, explained simply and built step by step: chunking, embeddings and similarity search you can run, prompts with citations and an honest "I don't know", the Next.js and AI SDK implementation, the UI that makes answers trustworthy, and how to evaluate and secure it.
intermediate 13 steps 70 min 6 readersInterview Prep: Real Questions from Senior Frontend Loops
Questions candidates have reported from Meta, Google, Uber, Atlassian, and Airbnb frontend interviews, grouped by round, with sources. Practice the coding ones with real tests, build a reported UI question, and map each system design question to a deep dive.
advanced 10 steps 75 min 28 readersInterview Prep: React Questions for Senior Engineers
The React questions senior interviews actually ask: keys and reconciliation, what a re-render really is, stale closures in effects, debugging a slow page, and Server Components. Model answers, follow-ups, red flags, and interactive demos.
advanced 10 steps 60 min 10 readers 1 completedInterview Prep: The JavaScript Coding Round
The utility functions frontend interviews ask for again and again: debounce, Promise.all, an event emitter, and event loop ordering. For each: what's being tested, a strong answer, the follow-ups, and an implementation with real tests.
intermediate 10 steps 70 min 21 readersHow to Build AI Agents
Build an AI agent from first principles: the model-tools-loop core, designing tools with schemas, the tool-use protocol of the Claude API, managing context, guardrails and human approval, evaluating agents, and the frontend that makes an agent trustworthy to use.
advanced 11 steps 75 min 53 readersUsing AI as a Frontend Engineer
Work with AI coding assistants without lowering the bar: where they help and where they mislead, how to give them the right context, how to review what they produce, and how to build AI features into a UI with streaming, structured output, and safe rendering.
intermediate 10 steps 60 min 10 readersFrontend System Design: Excalidraw (Collaborative Whiteboard)
Design a collaborative whiteboard like Excalidraw: a JSON scene model, canvas rendering with a shape cache and viewport culling, hit testing, zoom and pan math, end-to-end encrypted collaboration, version-based reconciliation, and undo that works with other people editing.
advanced 11 steps 75 min 28 readersFrontend System Design: Multi-Stream Video Grid
Design a video-call gallery or multi-camera wall that renders dozens of live streams: a stream gateway, a client stream manager, a viewport scheduler that decides which tiles get full quality, and React tiles that stay cheap.
advanced 7 steps 60 min 59 readersFrontend System Design: Collaborative Editor
Design real-time collaboration like Google Docs or Figma: syncing concurrent edits with OT or CRDTs, presence and cursors, offline editing, the transport layer, and undo in a multi-user world.
advanced 7 steps 65 min 54 readersFrontend System Design: Autocomplete / Typeahead
Design a search autocomplete like Google's or Amazon's: debouncing, race conditions, client caching, keyboard and screen-reader support, highlighting, and performance budgets per keystroke.
advanced 7 steps 55 min 3 readersFrontend System Design: News Feed
Design an infinite, real-time news feed like Facebook or LinkedIn: requirements, component architecture, cursor pagination, normalized cache, virtualization, new-post handling, and optimistic interactions.
advanced 7 steps 60 min 6 readersIncremental Migrations: Strangler Fig, Codemods, and Tech Debt
Modernize a large frontend without a rewrite: the strangler fig pattern, routing traffic between old and new, codemods for mechanical changes, measuring migration progress, and making the case for tech debt work.
advanced 7 steps 45 min 5 readersArchitecture Decisions: ADRs, RFCs, and Trade-off Analysis
The written side of architecture: when to write an RFC versus an ADR, how to compare options with explicit criteria, run a review that reaches a decision, and keep a decision log that new engineers actually read.
advanced 7 steps 40 min 5 readersFeature Flags and Safe Rollouts
Decouple deploy from release: flag types and lifecycles, deterministic percentage rollouts, evaluating flags without flicker, canary releases with automatic rollback, and keeping flag debt under control.
advanced 7 steps 45 min 4 readersFrontend Observability: Errors, RUM, and Tracing
Know what users actually experience: capture and group errors with context, collect real-user performance data, sample and batch telemetry, connect frontend traces to the backend, and alert on what matters.
advanced 7 steps 50 min 4 readersMonorepos, Module Boundaries, and Build Tooling
Structure a frontend monorepo that stays fast and decoupled: package boundaries and dependency rules, affected-only builds, remote caching, bundling choices, and bundle budgets.
advanced 7 steps 50 min 4 readers 1 completedTypeScript at Scale: Type-Safe Boundaries
Use TypeScript as an architecture tool: validate at runtime boundaries, model states with discriminated unions, brand IDs, share contracts between client and server, and keep a large codebase's types fast.
advanced 7 steps 55 min 5 readers 1 completedDesign Tokens and Theming at Scale
Structure tokens in tiers (primitive, semantic, component), ship them as CSS variables, support dark mode and multiple brands without rebuilding components, and keep design and code in sync.
advanced 7 steps 45 min 6 readersComponent API Design for Design Systems
Design shared components that hundreds of engineers can use correctly: naming, variants vs. booleans, polymorphism, escape hatches, accessibility by default, and evolving APIs without breaking consumers.
advanced 7 steps 50 min 7 readersCompound and Headless Components
Build flexible component APIs that teams can compose instead of configure: compound components with context, headless hooks that separate behavior from markup, and when each pattern is worth it.
advanced 7 steps 55 min 15 readersCaching Layers: Browser, CDN, Edge, and App
Design a caching strategy end to end: Cache-Control semantics, CDN keys and Vary, stale-while-revalidate, invalidation with tags, and the bugs that serve one user's data to another.
advanced 7 steps 50 min 7 readersReact Server Components in Depth
How React Server Components really work and how to design with them: the RSC payload, the server/client boundary, data fetching without waterfalls, streaming with Suspense, caching, server actions and their security, patterns that scale, and when RSC is the wrong tool.
advanced 19 steps 90 min 6 readersHydration and Its Costs
Why server-rendered pages look ready before they are. Measure hydration cost, avoid mismatches, and reduce it with islands, progressive, and selective hydration.
advanced 7 steps 45 min 5 readers 1 completedRendering Strategies: CSR, SSR, SSG, and ISR
Choose a rendering strategy per route, not per app. Compare CSR, SSR, SSG, and ISR on TTFB, LCP, freshness, cost, and personalization.
advanced 7 steps 50 min 7 readers 1 completedAccessibility and Inclusive Design
Accessibility as an architecture concern: semantic HTML first, keyboard and focus management, ARIA used correctly, accessible design-system components, automated and manual testing, and making it stick across teams.
advanced 7 steps 45 min 4 readersPerformance: Metrics and Optimization
Build a performance strategy, not a list of tricks: the metrics that matter, how to read them, where time goes on the critical path, and a prioritized playbook with budgets to keep the gains.
advanced 7 steps 50 min 42 readersState Architecture and Module Boundaries
Decide who owns each piece of state, separate server state from client state, keep derived data derived, and draw module boundaries so features don't reach into each other's stores.
advanced 6 steps 45 min 10 readersAPIs, Data Models, and Scaling
Design the contract between frontend and backend: client-side data models, REST vs. GraphQL vs. BFF, pagination, real-time transports, and how the frontend helps the system scale.
advanced 7 steps 45 min 6 readersHigh-Level Architecture and Components
Go from requirements to a frontend architecture: layers and their responsibilities, component hierarchy, data flow, where state lives, and how to draw and present it.
advanced 7 steps 45 min 5 readersRequirements, Scoping, and Trade-offs
The first 10 minutes of any frontend design: turn a vague prompt into functional and quantified non-functional requirements, define scope, and make trade-offs explicit.
advanced 7 steps 40 min 8 readersuseMemo and useCallback
Optimize re-renders and avoid unnecessary recalculations and callback identity changes.
intermediate 8 steps 50 min 0 readersContext API
Share state across the tree without prop drilling. Create a context, provide a value, and consume with useContext.
intermediate 8 steps 52 min 0 readersCustom Hooks
Extract reusable stateful logic into custom hooks. Rules of hooks and when to create your own.
intermediate 8 steps 48 min 4 readersuseEffect and Side Effects
Run side effects (subscriptions, fetches, timers) safely with useEffect and learn cleanup and dependency arrays.
intermediate 8 steps 50 min 63 readers 1 completed