Talks from our events
Latest
All talksControl, Evidence, Trust: Leading Teams When AI Writes the Code
TechLead Conf London 2026: Adopting AI in Orgs Edition
7 min
Control, Evidence, Trust: Leading Teams When AI Writes the Code

AI assistants now write a growing share of the code your team ships, but most review processes and quality gates were designed for human authors. Reviewing more code faster isn't a strategy. In this lightning talk, Albert Franquesa introduces Control, Evidence, Trust, a simple model for leading t...
AI Reviews AI – Closing the Loop in Agentic Development
AI Coding Summit London
28 min
AI Reviews AI – Closing the Loop in Agentic Development

Daniel, a consultant from Germany, discusses AI-generated code and challenges in rapid code shipping. The Pharoes AI case study highlights code reviews and challenges in agile development. Incidence per pull request and code churn issues are discussed in software development. AI-assisted coding and quality gates are introduced. Developing with Angular and TypeScript emphasizes the importance of basics, AI sub-agents, and pull request review services. Utilizing hooks for deterministic code handling and enhancing code handling with various hooks are crucial. Transitioning to behavior-driven development, utilizing tools like PlayWrite and Jira integration, and evaluating code review strategies are key points. Optimizing code review practices, smart integration of AI and hooks, advanced code review models, ownership in code reviews, software metrics, and quality gates challenges are also covered.
From Prompting to Orchestrating: Coding Is Now a System
AI Coding Summit London
26 min
From Prompting to Orchestrating: Coding Is Now a System

Vladimir Novik discusses the evolution of AI systems in coding, highlighting the shift in job requirements and challenges faced in scaling systems. Challenges in swarm orchestration include reducing reliability due to compounding errors and structural challenges in transitioning to a swarm system. Orchestrator Coding focuses on system properties over tools for code evolution. Enforcing architectural decisions and mechanical enforcement are crucial for system reliability. Orchestration disciplines prioritize dispatch, isolation, and durable handoffs, emphasizing autonomous systems and event-triggered actions. Mastery of orchestrated workflows involves resilience, autonomy, and disciplined manual and automated workflows. Advanced workflow techniques stress exact commands, linear workflow skills, caution in commits, and iterative improvement strategies. Automation enhancement strategies aim to overcome cost and parallelism challenges. Coding transformation journey involves validating and evolving code with orchestration. Model orchestration layers and architecture comparisons highlight the importance of model evaluation and verification gates. Tool comparisons and orchestrator communication strategies improve system orchestration. Architecture enforcement mechanisms utilize multiple layers and tools for code analysis and infrastructure testing.
How Not to Use TanStack Query
React Advanced 2026
19 min
How Not to Use TanStack Query

We built a product fully on TanStack Query and skipped adding a state management layer. It worked for a while, then it broke in ways we didn’t expect.This talk dives into how TanStack Query works, what we got wrong, and how to use it properly. From missing optimistic updates to confusing s...
The AI Call Is the Render: Server Components as the Intelligence Boundary
React Advanced 2026
17 min
The AI Call Is the Render: Server Components as the Intelligence Boundary

Most React applications treat AI as a separate service: a backend calls an LLM, returns JSON, and a client component renders it. This works, but it misses something fundamental about how React Server Components actually model computation.RSCs do not just move rendering to the server. They...
Built for Turbulence: Architecting Full-Stack Web Experiences That Hold Up in Any Environment
React Advanced 2026
28 min
Built for Turbulence: Architecting Full-Stack Web Experiences That Hold Up in Any Environment

We build platforms in perfect environments, but the real world is anything but that.Real teams need to move fast, stay pragmatic, and make difficult architectural choices, each with their own trade-offs. So how do we keep UX, resilience, and performance at the forefront while the architect...
Many Ways to Put an Icon on Screen. Which Should You Use?
React Advanced 2026
18 min
Many Ways to Put an Icon on Screen. Which Should You Use?

Every web app needs icons, and there are surprisingly many ways to load them: img tags, icon fonts, inline SVGs, SVG sprites, and Icon components. Most teams pick one by habit or choose what's easy. The choice affects bundle size, accessibility, caching, rendering quality, and developer experienc...
Software Craftless: Writing Code That Would Make a Goat Vomit
Web Engineering Summit 2026
15 min
Software Craftless: Writing Code That Would Make a Goat Vomit

The talk delves into the concept of writing complex code to boost creativity and appear smarter, using JavaScript challenges to highlight the importance of front-end development. It suggests adding confusion to code, utilizing complex functions, and mixing library versions. The future of front-end development involves emoji CSS, diverse HTML tags, and functional CSS. Architectural design principles include over-engineering systems, using diagrams with circles and hexagons, and organizing code by type. Effective testing strategies focus on code coverage, unit testing, and test order. Optimizing UI design, AI usage, and ethical AI utilization are essential, alongside audience engagement for feedback and social media interaction.
When React Meets Rock: Building Safe and Performant UI for Live Entertainment
React Advanced 2026
28 min
When React Meets Rock: Building Safe and Performant UI for Live Entertainment

At TAIT, we build the full automation stack behind the world's biggest live experiences, from the systems that move stages and fly performers to the React interface that operators use to control them. Our frontends can't lag, freeze, or crash while hardware is moving, or someone can get hurt. Thi...
The Web Is Fun Again! Exploring the New HTML-in-Canvas API
React Advanced 2026
22 min
The Web Is Fun Again! Exploring the New HTML-in-Canvas API

What happens when HTML steps inside the canvas? In this hands-on live coding session, we’ll explore the new HTML-in-Canvas API and the creative possibilities it unlocks. We’ll build from scratch, covering core concepts like pixel manipulation, simple effects, and basic shaders. The focus is on pr...
Featured
npm install && pray
Node Congress 2026
29 min
npm install && pray

JavaScript developers face security risks in npm packages with self-replicating worms compromising packages. Supply chain attacks target prolific maintainers leading to unauthorized code injections. Vulnerabilities in package maintainers and implicit trust contribute to successful attacks. Secure package installation practices vary between npm and Deno. AI-generated code introduces new security risks with embedded secrets. Secure AI code execution involves sandboxing for isolation and secure handling of API keys.
Vinext: Deploy Next.js Without Next.js
React Advanced 2026
23 min
Vinext: Deploy Next.js Without Next.js

Next.js is a great framework - until you want to deploy it somewhere that isn't Vercel. vinext is a Vite plugin from Cloudflare that reimplements the Next.js API surface from scratch, so your existing app runs everywhere with a single command. In this talk, we'll look at why this exists, how Cl...
We Deserve a Better Streams API for the Web
Node Congress 2026
30 min
We Deserve a Better Streams API for the Web

James Snell discusses challenges in current stream APIs, proposes a new, faster, and simpler streams API while questioning the existing Web Streams model. Discussion includes the necessity for a new API due to excessive ceremony, confusing locking mechanisms, and complex specifications, especially in controller APIs. Challenges with controller API optimization, hidden buffering, and excessive memory usage are highlighted. The talk delves into the cost and complexity of promises in JavaScript, optimizing readable streams, and managing complexity in stream implementations. Optimizing stream processing in JavaScript, data chunk processing, back pressure policies, multi-consumer patterns, and efficient branch cursor management are explored. The new API aims at simplifying stream processing by eliminating unnecessary operations, reducing promise overhead, and focusing on iterators, transforms, and back pressure for efficiency and simplified design.
Why Software Fundamentals Still Matter
React Advanced 2026
31 min
Why Software Fundamentals Still Matter
Agentic Interfaces: Tools, Skills, Generative UI and Web MCP
JSNation 2026
31 min
Agentic Interfaces: Tools, Skills, Generative UI and Web MCP

Wes discusses the evolving ways of interacting with software, from UI to voice commands and tailored interfaces. He explores generative UI, explaining its three levels: basic, declarative, and fully generative. Discussions on finding a middle ground between known components and fully generative approaches. Discussing challenges with current MCP interfaces and the need for adaptive and reactive interfaces, using smart home examples to illustrate preferences for UI interactions and personalized automation. Exploring the versatility of WebMCP in switching between manual and agent-controlled interactions for enhanced user experiences. Discussing staying hopeful in front-end development, embracing new technologies, and the concept of dynamic UI for user-driven component selection. Discussing the importance of preserving the openness of the web, advocating against centralized control by a few companies, and the risks associated with MCPs in user consent and security.
The AI-Native Software Engineer
JSNation US 2025
35 min
The AI-Native Software Engineer
Top Content

Software engineering is evolving with AI and VIBE coding reshaping work, emphasizing collaboration and embracing AI. The future roadmap includes transitioning from augmented to AI-first and eventually AI-native developer experiences. AI integration in coding practices shapes a collaborative future, with tools evolving for startups and enterprises. AI tools aid in design, coding, and testing, offering varied assistance. Context relevance, spec-driven development, human review, and AI implementation challenges are key focus areas. AI boosts productivity but faces verification challenges, necessitating human oversight. The impact of AI on code reviews, talent development, and problem-solving evolution in coding practices is significant.
The Dark Side of Micro-Frontends
React Advanced 2025
29 min
The Dark Side of Micro-Frontends
Top Content

In the Talk, various key points were discussed regarding micro-front-end architecture. These included challenges with micro-intents, common mistakes in system design, the differences between micro-intents and components, granularity in software architecture, optimizing micro-front-end architecture, efficient routing and deployment strategies, edge computing strategies, global state and data sharing optimization, managing data context, governance and fitness functions, architectural testing, adaptive growth, value of micro-frontends, repository selection, repo structures, and web component usage.
The New AI Workflows
React Advanced 2025
14 min
The New AI Workflows

The Talk delves into the impact of LLMs on engineering workflows, emphasizing the shift towards AI for code writing efficiency. It highlights the importance of problem-solving abilities and product development in hiring practices. LLMs enhance productivity for developers, designers, and product managers, enabling faster iterations and collaboration. Efficient product workflows are achieved through simultaneous UI and code work using Builder.io. Task delegation is streamlined with async agents and Builder bots, optimizing project editing and code management. Integration with tools like VS Code and Figma streamlines design and code editing, enhancing collaboration and workflow automation.
Keeping Up with The Fast and Furious Web
JSNation US 2025
29 min
Keeping Up with The Fast and Furious Web

Scott Talinsky's journey in web development highlights his transition from YouTube tutorials to creating educational content and courses, reflecting his passion for teaching. The evolution of web development tools showcases advancements from limited colors to modern frameworks like React and CSS features like squircles. Adapting to new technologies emphasizes core skills and freedom in tool selection. User-centric development prioritizes accessibility and understanding the purpose of tools. Learning strategies focus on fundamentals, hands-on learning, and avoiding influencer bias. Standing out in tech roles requires quality projects, broad knowledge, and effective communication.
Why Node.js Needs an Application Server
Node Congress 2026
18 min
Why Node.js Needs an Application Server

Matteo Collina discusses Node.js, its single-threaded design, and the introduction of threads in 2018 for parallelism and CPU utilization. Node.js production monitoring focuses on application health, fault tolerance, and event loop efficiency. VAT architecture improves Node.js applications with thread migration and monitoring. Node.js manages threads and failures independently with Prometheus monitoring. Scalability in Node.js involves Kubernetes clusters and in-process scaling. Next.js with React SSR for Node.js applications enables dynamic scaling and performance. Node.js handles CPU blocking and SSR performance by utilizing multiple threads.
Trending today
Type-safe bindings for Node.js with Rust and WebAssembly
Node Congress 2023
22 min
Type-safe bindings for Node.js with Rust and WebAssembly

This Talk explores TypeScript bindings for NodeJS with Rust and WebAssembly, providing an alternative approach for creating native NodeJS modules and automatically generating types. It delves into the use of WebAssembly and Rust for TypeScript modules, showcasing how Rust functions can be defined and imported using the wasm.bindgen library. The Talk also highlights the challenges of string conversion between Rust and JavaScript, the limitations of supporting Rust data types in JavaScript, and the seamless integration of Rust functions into TypeScript apps using tspy. It concludes with the recommendation of TSFI for type-safe bindings and showcases its usage in a TypeScript-based full-text search engine with WebAssembly support.
Boost the Performance of Your WebGL Unity Games!
JS GameDev Summit 2023
7 min
Boost the Performance of Your WebGL Unity Games!
Top Content

The Talk discusses ways to boost the performance of WebGL Unity games, including issues with bundle size, memory usage, and runtime performance. It suggests using Brotli for compression and non-exception support for better performance. Choosing the appropriate texture compression format and experimenting with separate builds can also help. The Talk also covers optimizing textures, models, audio, and assets by reducing build size, using compression, disabling unnecessary models, and optimizing audio quality. Unity's optimization tools and profilers are recommended for analyzing performance and memory issues.
Unreal Engine in WebAssembly/WebGPU
JS GameDev Summit 2022
33 min
Unreal Engine in WebAssembly/WebGPU
Top Content

Alex Saint-Louis, co-founder of Wunder Interactive, shares the mission of bringing Unreal Engine to the browser, enabling cross-platform 3D applications and games. They are working on a WebGPU back end for Unreal Engine to push the limits of 3D on the web. Wunder Interactive has improved compression, built their own asset file system, and offers powerful tools for game developers. They are utilizing modern web technologies like WebAssembly, WebGL, and WebGPU, and plan to support other engines like Unity and Godot. The team aims to transform the industry by bringing console-quality games to the browser and providing an alternative distribution path. They are excited to bring Unreal Engine 5 to the web with WebGPU support and are working on WebXR support for cross-platform 3D experiences, including VR.
Makepad - Leveraging Rust + Wasm + WebGL to Build Amazing Cross-platform Applications
JSNation 2022
22 min
Makepad - Leveraging Rust + Wasm + WebGL to Build Amazing Cross-platform Applications
Top Content

Welcome to MakePad, a new way to build UI for web and native using WebAssembly and Rust. JavaScript is not suitable for complex applications like IDEs and design tools. Rust, a new programming language, was used to reimagine MakePad, resulting in a fast and efficient platform. MakePad offers live editing, high CPU performance, and the ability to load native instrument components. The future of MakePad includes an open-source release, a design tool, and support for importing 3D models.
Optimizing HTML5 Games: 10 Years of Learnings
JS GameDev Summit 2022
33 min
Optimizing HTML5 Games: 10 Years of Learnings
Top Content

PlayCanvas is an open-source game engine used by game developers worldwide. Optimization is crucial for HTML5 games, focusing on load times and frame rate. Texture and mesh optimization can significantly reduce download sizes. GLTF and GLB formats offer smaller file sizes and faster parsing times. Compressing game resources and using efficient file formats can improve load times. Framerate optimization and resolution scaling are important for better performance. Managing draw calls and using batching techniques can optimize performance. Browser DevTools, such as Chrome and Firefox, are useful for debugging and profiling. Detecting device performance and optimizing based on specific devices can improve game performance. Apple is making progress with WebGPU implementation. HTML5 games can be shipped to the App Store using Cordova.
Proven Pinia Patterns
Vue.js London 2023
20 min
Proven Pinia Patterns
Top Content

Pinnia is a lighter, more modular state management solution for Vue apps, offering consistent patterns, TypeScript support, and an intuitive developer experience. PINIA encourages splitting state into manageable domains, improving code splitting, type inferences, team collaboration, and debugging clarity. Pinia provides flexibility in accessing and mutating state, with different approaches for option and setup stores. It also offers features like patch, reset, and onAction methods. Vue Mastery offers comprehensive Pinnia courses and resources for fast learning.
From Figma to Production Code: Building a Reliable AI-Driven UI Workflow
React Advanced 2026
28 min
From Figma to Production Code: Building a Reliable AI-Driven UI Workflow
Agentic by Default: Rethinking Developer Workflows with Claude Code
AI Coding Summit 2026
29 min
Agentic by Default: Rethinking Developer Workflows with Claude Code

The Talk delves into agent decoding in Cloud Code, emphasizing the importance of planning, acting, and verifying changes systematically. It explores maximizing efficiency through Cloud Code acting as an agent, reasoning, reading, writing code, and using tools for successful outcomes. The discussion covers enhancing task planning, utilizing subagents for specialized assistance, and optimizing tool use with MCP integration. It introduces Cloud Skills, plugins for team collaboration, and efficient tool utilization with parallel workflows. The concept of non-interactive agents, guided autonomy, and steps for experiencing agent decoding are also highlighted.
Web Apps of the Future With Web AI
JSNation 2024
32 min
Web Apps of the Future With Web AI

Web AI in JavaScript allows for running machine learning models client-side in a web browser, offering advantages such as privacy, offline capabilities, low latency, and cost savings. Various AI models can be used for tasks like background blur, text toxicity detection, 3D data extraction, face mesh recognition, hand tracking, pose detection, and body segmentation. JavaScript libraries like MediaPipe LLM inference API and Visual Blocks facilitate the use of AI models. Web AI is in its early stages but has the potential to revolutionize web experiences and improve accessibility.
Node.js startup snapshots
Node Congress 2023
28 min
Node.js startup snapshots
Top Content

The Talk discusses the Startup Snapshot initiative in Node, which aims to improve startup performance by adding new features and optimizing initialization costs. Startup snapshots, serialized binary blobs, are used to speed up startup and can be generated for both the core and user applications. Custom snapshots allow deserializing a heap from a specified snapshot, skipping parsing and compilation. The Talk also addresses misconceptions and limitations of startup snapshots, and highlights the different use cases for heap snapshots and startup snapshots.
Short takes
Video Optimization for the Web: The Missing Piece in Lighthouse
React Summit US 2025
7 min
Video Optimization for the Web: The Missing Piece in Lighthouse

Rahul introduces video optimization principles, emphasizing modern formats, compression, bitrate reduction, and lazy loading. ImageKit simplifies video loading by compressing videos significantly and adapting to network conditions. Pausing videos when not in view saves data costs and enhances user experience.
Optimizing the Path From Design to Production in Engineering Workflows
React Summit US 2025
7 min
Optimizing the Path From Design to Production in Engineering Workflows

Akbar, developer advocate at Figma, highlights the importance of exploration, representation, and production in product development. Figma leverages design systems and AI tools for efficient transition from representation to production, optimizing expertise and automating non-critical tasks. Seamless integration between design elements and the app is achieved through tools like Code Connect and Copilot, fostering collaboration between design and code.
Backend-for-Frontend Auth: The Secure JS App Architecture
JSNation US 2025
6 min
Backend-for-Frontend Auth: The Secure JS App Architecture

Challenges in OAuth, importance of back end security for front end, and implementation details of OAuth flow between front end, back end, and authorization server. Detailed process of token handling, session management, and user data retrieval in OAuth implementation between front end, back end, and authorization server.
From Experiment to Enterprise: Scaling AI Coding Assistants Across Engineering Teams
TechLead Conf London 2025: Adopting AI in Orgs Edition
9 min
From Experiment to Enterprise: Scaling AI Coding Assistants Across Engineering Teams

Sharing insights on scaling AI coding assistance & adopting AI native dev tools. Discussing the need for a shift from viewing adoption as a tech problem to a change management challenge. Exploring a tactical framework with three key phases: onboard, adopt, succeed. Emphasizing the importance of onboarding developers, ensuring access to licenses, and setting clear policies to avoid 'shadow AI'. Highlighting the necessity of human infrastructure for successful AI dev tool implementation, including AI advocates, communities of practice, and executive sponsorship. Adoption strategies require a focus on interconnected metrics and all pillars simultaneously. Leadership checklist for post-conference actions involves measuring metrics, distinguishing between strategic and tactical points, and staying connected through platforms like WhatsApp and LinkedIn.
A JS Dev's Guide to Not Dismissing Blockchain
JSNation US 2025
8 min
A JS Dev's Guide to Not Dismissing Blockchain

Brian Wipo, Developer Relations lead at the Algorand Foundation, discusses the relevance of blockchain in 2025 and its impact on developers. Algorand's high-performance blockchain addresses key issues faced by other platforms, enabling new markets and real-world applications like tokenized assets and supply chain traceability. In 2025, blockchain excels in disintermediating markets, tracking data integrity, and creating new markets such as fractional ownership of assets. Real businesses on Algorand include tokenized solar panels, real estate ownership, supply chain traceability, and more. Using a para wallet with a mastercard debit card, you can buy items at the store with stable coins. Algorand TypeScript 1.0 simplifies writing smart contracts on the chain in TypeScript. TypeScript developers can now integrate blockchain using a compiler that transforms code into Teal assembly language for blockchain execution.
Everyone Is Now a Manager - Interfaces in the World of Agents
TechLead Conf London 2025: Adopting AI in Orgs Edition
6 min
Everyone Is Now a Manager - Interfaces in the World of Agents

Sam Kmezverk's talk covers the evolving tech landscape, emphasizing key principles for agents' implementation in tasks and decision-making processes. Addressing challenges in agent orchestration, debugging system issues, and cultivating user trust are crucial for successful interface development.
Shipping AI Under Constraints: Build, Buy, or Kill
TechLead Conf London 2025: Adopting AI in Orgs Edition
8 min
Shipping AI Under Constraints: Build, Buy, or Kill

Dave, Engineering Manager at Capital Untap, shares a story of AI failure and lessons learned from moving too fast in AI development within the company. The AI team focused on developing a chatbot for customer service, which became a flagship initiative under engineering governance. Issues with accuracy and complexity led to pausing the chatbot project and exploring third-party vendors. Capital OnTap reset AI processes by integrating AI engineers into product teams, emphasizing standard engineering over specialized AI teams.
Trust Engineering: Replacing Hope with Reliability
TechLead Conf London 2026: Adopting AI in Orgs Edition
7 min
Trust Engineering: Replacing Hope with Reliability

How do you deliver with AI and still sleep at night? By engineering trust into your delivery system.
In this talk, I'll share an end-to-end AI engineering workflow we built and ran on a production codebase, redefining roles, responsibilities, quality ga...
In this talk, I'll share an end-to-end AI engineering workflow we built and ran on a production codebase, redefining roles, responsibilities, quality ga...
Deploy Your AI Code in Minutes
AI Coding Summit 2026
7 min
Deploy Your AI Code in Minutes

Shifra guides the migration of a Repl.it app to Render with emphasis on simplicity and mock data. Ensure Render deployment requirements are met, including specifying root directory, build and start commands, and correct port. Configure GitHub repository setup, connect to Git, and create a repository. Confirm code in the repository and deploy on Render, showcasing a sample landing page.
MCPs: How to Avoid Security Pitfalls
AI Coding Summit 2026
7 min
MCPs: How to Avoid Security Pitfalls

Gil Friedman from Backslash Security discussed MCP security, focusing on the Model Context Protocol and AI assistant security risks like GitHub token exposure in auto run mode. Security measures for MCP usage include setting autorun to ask every time, postmarking MCP incidents, handling malicious servers, safeguarding sensitive information, reviewing and disabling unused tools, requiring permission before triggering actions, removing MCP from environments, and revoking API keys when necessary.
Popular
You Can’t Use Hooks Conditionally… or Can You?
React Summit 2023
28 min
You Can’t Use Hooks Conditionally… or Can You?
Top Content

The Talk discusses the use of the Use hook in React and its ability to be used conditionally. It explains the concept of the fiber tree and how hooks values are stored in memory. The Talk also delves into the conditional use of useContext and how it differs from useState. It explores the process of updating context values and optimizing context rendering. The role of the provider in managing context values and rendering is emphasized.
Let’s Talk about Re-renders
React Summit 2022
23 min
Let’s Talk about Re-renders
Top Content

This Talk discusses React performance and how re-renders can affect it. It highlights common mistakes and misconceptions, such as the overuse of useMemo and useCallback hooks. The importance of React.memo in preventing unnecessary child component re-renders is emphasized. Creating components in render functions is identified as a major performance killer, and the benefits of moving state down and wrapping state around children are explained. The Talk also covers optimizing component rendering through memoization and provides a recap of the key points.
From Blender to the Web - the Journey of a 3D Model
React Advanced 2021
27 min
From Blender to the Web - the Journey of a 3D Model
Top Content

This Talk is about Blender, a free and open-source 3D software, and integrating 3D models into websites. The speaker discusses exporting 3D models to the web using the gltf format and compressing them using gltf transform and draco compression. They also cover integrating the 3D model into a website using React and React 3 fiber, troubleshooting installation and error issues, and working with refs and frames. The Talk explores rendering, lighting, mathematics, and experimentation in 3D, as well as interaction and rendering effects. The speaker also mentions their favorite creation in Blender.
Build a 3D Solar System with Hand Recognition and Three.js
JSNation 2022
36 min
Build a 3D Solar System with Hand Recognition and Three.js
Top Content

This Talk explores the use of TypeScript, 3JS, hand recognition, and TensorFlow.js to create 3D experiences on the web. It covers topics such as rendering 3D objects, adding lights and objects, hand tracking, and creating interactive gestures. The speaker demonstrates how to build a cube and a bouncy box, move objects with flick gestures, and create a solar system with stars and planets. The Talk also discusses the possibilities of using hand gestures for web navigation and controlling websites, as well as the performance limits of these technologies.
Draft.js, Editor.js, Slate.js: Choosing the Best Text Editor for Your React Project
React Summit Remote Edition 2021
8 min
Draft.js, Editor.js, Slate.js: Choosing the Best Text Editor for Your React Project
Top Content

Welcome to my session on DraftJS, EditJS, and SlideJS. We will discuss their strengths and data model, focusing on React's component and prop model. We will evaluate the editors based on their sustainability, funding, support, maturity, license, editor features, release cycle, data structure, ecosystem, browser support, usage, and GitHub stars. The first editor we'll discuss is Draft.js, which is used by Facebook Messenger, comments, status posts, and the Facebook Notes app. It's funded and supported by Facebook, has a version of 0.11.7, and requires custom code for additional features. The license is MIT. It's a bare metal, in terms of features. The release cycle is semantic version. The data structure is JSON. It's used by 83,000 packages and has 20,000 stars. The data model is made up of blocks with text and entities. It supports various editor features including block styles, inline styles, undo/redo, paste, lists, nested lists, media, and links. Editor.js is a block-based editor written in vanilla JavaScript. It has a 2.19 release, Apache 2.0 license, and a semver release cycle. The data structure is JSON, and there are numerous plugins available. It has 1,500 packages using it and 15,000 stars. The editor features include block styles, inline styles, undo/redo, paste, lists, nested blocks, media, and links.
Micro-Frontends With React & Vite Module Federation
React Advanced 2023
20 min
Micro-Frontends With React & Vite Module Federation
Top Content

Microfrontends is an architecture used by big companies to split monolithic frontend applications into manageable parts. Maintaining a consistent look and feel across different microfrontends is a challenge. Sharing styles can be done through Vanilla CSS, CSS modules, or CSS in JS. JavaScript variables can be used in styles, but readability and runtime overhead are considerations. Sharing state in microfrontends can be achieved through custom events, broadcast channels, shared state managers, or custom PubSub implementations. Module federation with Vite allows for client composition and sharing dependencies. Configuration is similar to Webpack, and future work includes working on the QUIC framework.
Building Better Websites with Remix
React Summit Remote Edition 2021
33 min
Building Better Websites with Remix
Top Content

Remix is a web framework built on React Router that focuses on web fundamentals, accessibility, performance, and flexibility. It delivers real HTML and SEO benefits, and allows for automatic updating of meta tags and styles. It provides features like login functionality, session management, and error handling. Remix is a server-rendered framework that can enhance sites with JavaScript but doesn't require it for basic functionality. It aims to create quality HTML-driven documents and is flexible for use with different web technologies and stacks.
If You Were a React Compiler
React Summit US 2024
26 min
If You Were a React Compiler
Top Content

In this talk, the speaker aims to build an accurate understanding of how the new React compiler works, focusing on minimizing re-renders and improving performance. They discuss the concept of memoization and how it can be used to optimize React applications by storing the results of function calls. The React compiler automates this process by analyzing code, checking dependencies, and transpiling JSX. The speaker emphasizes the importance of being aware of memory concerns when using memoization and explains how the React compiler detects changes in function closure values. They also mention the Fibre Tree, which drives the reconciliation process and helps optimize performance in React. Additionally, the speaker touches on JSX transpilation, compiler caching, and the generation of code. They encourage developers to understand the code generated by the compiler to optimize specific sections as needed.
Simplifying Server Components
React Advanced 2023
27 min
Simplifying Server Components
Top Content

React server components simplify server-side rendering and provide a mental model of components as pure functions. Using React as a library for server components allows for building a basic RSC server and connecting it to an SSR server. RSC responses are serialized virtual DOM that offload code from the client and handle interactivity. The client manifest maps serialized placeholders to real components on the client, enabling dynamic rendering. Server components combine the best of classic web development and progressive enhancement, offering the advantage of moving logic from the client to the server.
Exploring React Server Component Fundamentals
React Day Berlin 2023
21 min
Exploring React Server Component Fundamentals
Top Content

This Talk introduces React Server Components (RSC) and explores their serialization process. It compares RSC to traditional server-side rendering (SSR) and explains how RSC handles promises and integrates client components. The Talk also discusses the RSC manifest and deserialization process. The speaker then introduces the Waku framework, which supports bundling, server, routing, and SSR. The future plans for Waku include integration with client state management libraries.
React
Plug and Play Design: Building Extendable React Applications
React Summit US 2025
29 min
Plug and Play Design: Building Extendable React Applications

Mateusz Jagodziński, principal developer at Synergy Codes, shares insights on Plug and Play Design Building Extendable React Applications, discussing feature flags, modularity, and real-world use cases. Challenges of feature flags, the concept of alternative modular design for feature management, and the importance of modularity in code organization and development. Configurability and limitations in feature management, showcasing a plugin-based design for flexible tool versions and code manipulation. Explanation of plug and play design for code manipulation and version control with full type safety in TypeScript projects. Exposing functions to register new plugins, organizing plugins' logic within individual folders, and implementing a build setup with a replacement mechanism for plugin files. Replacing missing plugins with a fallback code, enforcing restriction on direct plugin imports, and visualizing the relationship between plugins, adapters, and application components. Exploring pros and cons of self-contained plugins, addressing implementation overhead, and discussing the value of enforced modularity for AI coding tools. Discussing plugin management decisions based on client needs and the scalability of the approach with changing requirements and minor tweaks. Handling plugin version tracking, automated testing challenges, and feature control based on environments. Adapters and maintaining plugin compatibility through iterations and cosmetic changes, leveraging existing solutions for simplicity. Discussing the implications of not shipping separate builds for multiple customers and considering the benefits of smaller bundle size. Exploring the ease of trying out new features with separate plugins to assess overhead and developer experience.
From Segments to Suspense: The Future of Next.js Caching
React Advanced 2025
27 min
From Segments to Suspense: The Future of Next.js Caching

Introduction to Cache Components in Next.js 16, transforming the app router with new features like partial pre-rendering, Dynamic I.O., and caching directives. Deep dive into static params generation in Next.js focusing on changes in generating static params for improved performance. Exploring challenges of generating static params and balancing static vs. dynamic rendering for better performance. Addressing challenges with cache components, optimizing static and dynamic rendering for improved performance. Understanding impact of parameters on rendering with cache components, managing dynamic components, and introducing suspense boundaries for faster page loads. Enhancing cache life APIs, introducing a new caching model for static outputs in Next.js. Revolutionizing cache management with granular control over cache lifetimes and dynamic segment configuration. Navigating data and caching in Next.js, exploring cache components guidance and caching differences between server and client components.
React Strict Dom: Cross-Platform React Based on the Web
React Summit US 2025
29 min
React Strict Dom: Cross-Platform React Based on the Web

Talk on cross-platform React using ReactStrict DOM to unify web and native React, standardizing for consistent UI development. Fragmentation challenges in React due to lack of standardized styling systems, impacting development efficiency and product consistency. Exploring unsuccessful cross-platform React approaches and the importance of minimizing migration costs. Enabling web developers to build native apps with React Native while enhancing it with web APIs for seamless code migration. Benefits of code sharing for cross-platform apps, AI integration for React Strict DOM, and the future vision for React Native as a web renderer. Unified styling in React Native, Tailwind integration, and UI best practices. Flexibility and readiness in React DOM, potential inclusion in React Foundations, and considerations for reversibility of decisions in React DOM.
From Fiber to Async React
React Advanced 2026
29 min
From Fiber to Async React

Almost a decade ago, React’s rendering algorithm was rebuilt, and with that it brought about new tools, ideas, and ways of building UI. But those tools arrived incrementally and were adopted in isolation, often framed as “optimizations” rather than part of a unified model. So are they truly indep...
Suspenseful Component Composition
React Summit US 2025
12 min
Suspenseful Component Composition

Simeon Griggs discusses Suspenseful Component Composition, the use of fallback props, and the basics of suspense in React applications with a demo showcasing data fetching and layout shifting. Exploring issues with data fetching and suspense boundaries. Addressing the challenges of using suspense boundaries and data fetching for individual rows in React applications. Creating consistent fallback elements for smooth loading experiences in tables by aligning sizes and optimizing data fetching placement. Optimizing data fetching placement for smoother loading experiences. Consider exporting suspense boundary to enhance code cleanliness and be defensive against data fetching errors. Use error boundaries to handle errors in suspenseful data fetching components for a smoother user experience.
Lessons From Adopting React Compiler
React Summit US 2025
23 min
Lessons From Adopting React Compiler

Akash Hamilwasia presenting at React Summit 2025, shares React Compiler learnings and works on an AI audio platform. Memoization in React helps optimize UI performance by preventing unnecessary re-renders. React Compiler offers automatic memoization through static code analysis. React rules emphasize purity and immutability. The compiler analyzes and memoizes code changes for optimization. React Compiler package usage improves performance through code analysis. Understanding reactivity issues is crucial for handling React state. Compiler optimization requires correct dependency arrays and usage of external libraries. Measure React Compiler impact using React Profiler for optimization and real user impact analysis.
React Beyond the DOM
React Summit US 2025
27 min
React Beyond the DOM

Eric Rasmussen discusses React beyond the DOM, React PDF, Ink tools, and rendering to Markdown. The overview includes React Reconciler, host configuration, state management with real-world entities like light bulbs, and building a traffic light state machine visually. The talk also covers securing third-party JavaScript, expanding React rendering possibilities, advanced tooling for state machines, controlling light bulbs via renderer callbacks, server functions for fetch in the cloud, and potential robot programming with React.
Node.js
Breaking the Context Ceiling: Implementing Recursive Language Models with LangGraph and TypeScript
Node Congress 2026
21 min
Breaking the Context Ceiling: Implementing Recursive Language Models with LangGraph and TypeScript

Jamal Legaro discusses challenges with context windows in language models and recursive language models as a solution. Enhancing language model performance through metadata and summaries, orchestrator copies, and comparing scaffold and RLM approaches. Efficient management of language model operations with slicing, recursion, code execution, and context window handling. Graph-based workflow design in Langchain for agent connections and state management. Workflow management, document analysis, and using RLM for processing large documents. Detailed workflow setup, code structure with Langsmith, and node definitions with RLM benefits for cost considerations and production readiness.
The State of Node.js Security
Node Congress 2026
27 min
The State of Node.js Security

Introducing Node.js security overview, defining vulnerabilities, non-vulnerabilities, and preventive measures. Discussing Node.js API input validation, real vulnerabilities like HTTP server crashes, and the importance of Node.js security in widely used platforms. Discussing the importance of Node.js maintenance, the introduction of experimental permissions in Node.js 20, and the seatbelt philosophy to protect against malicious code. Discussing the importance of maintaining up-to-date Node.js versions and using tools like npx isMyNodeVulnerable for security checks. Discussing the importance of Node.js security releases, funding, and dependency vulnerability assessment for a safer Node.js environment. Using Node.js Dependency Vulnerability Assessment to evaluate and address potential vulnerabilities, ensuring automated security checks and updates for a safer Node.js environment. Automating Node.js security release process, including configuration files for dependencies, extensive testing across various environments, and creating security release issues and blog posts automatically. Support for various environments, extensive testing with over 55 suites and 5,000 unit tests, automation efforts to streamline processes, and the establishment of a maintenance threat model for enhanced security measures. For a single pull request, it takes six hours to run tests, automation efforts in progress, maintenance threat model to address security risks, permission model roadmap, ongoing discussions on security reports, and plans for the Node.js Collaborator Summit. Active community involvement in Node.js security development, four security releases from 2024 to 2026 addressing various vulnerabilities, end-of-life version strategy with Node.js 16 and 18 having high weekly downloads, and the approach to issuing CVEs for end-of-life versions. Node.js project's strategy adjustment for CVEs to include end-of-life versions, importance of Node.js threat model, trust boundaries, and developer responsibilities. Node.js protection against network data, upgrade recommendations for different Node.js versions, and upcoming changes in Node.js release schedule.
The State of Node.js 2025
JSNation US 2025
19 min
The State of Node.js 2025

Matteo Collina presents an updated talk on Node.js, discussing roles, open-source projects, and dispelling myths. He highlights Node.js vitality, contrasts with legacy technologies like COBOL and jQuery. The talk covers Node.js popularity, software reuse, module growth, and download stats. It addresses risks of not updating Node.js, LTS support phases, version updates, adoption rates, security measures, Node 24 features like ESM support and stable permissions. Collaboration processes, TSC role, governance, and benefits of Platformatic VAT for app development are also discussed.
Node.js: More Threads Than You Think
React Advanced 2025
32 min
Node.js: More Threads Than You Think

The talk covers a range of topics including Node.js evolution to a multi-threaded system, scaling with the cluster module, managing PM2 for efficient orchestration, challenges in SSR frameworks, TCP SO reuse port for resource utilization, VAT architecture for smart service routing, zero downtime deployment with shared cache, performance benchmark results, PM2 performance challenges, legality and functionality of TCP SO reuse port, kernel balancing considerations, tool comparison between PM2 and Deno, cache consistency challenges, VAT architecture with worker thread recovery, T-scaling for vertical scaling, and updating Node V6 applications.
Stop Paying for AI APIs: npm Install Your Way to In-Process Inference
Node Congress 2026
26 min
Stop Paying for AI APIs: npm Install Your Way to In-Process Inference

Introduction by Ed Silva, a Node.js core collaborator, discussing the significance of AI in 2026. Companies facing challenges in AI implementation, focusing on AI integration and the need for developer skills. Demonstrations of Node.js egg cooking using Hug and Face community and model inference with Hug and Face Transformers. Transformers JS extending NLP to computer vision and audio tasks, utilizing O-N-N-X format for model execution. Tasks and examples available in Transformers.js for NLP and computer vision, emphasizing model differentiation and execution processes. Optimization techniques for model download trade-offs, GPU utilization, and experimentation possibilities with models like Hugging Face.
Unlocking the Power of the Dependency Graph
Node Congress 2026
19 min
Unlocking the Power of the Dependency Graph

Rui Adorno emphasizes the power of dependency graphs in JavaScript projects, highlighting the underutilized graph structure and the importance of understanding metadata. The discussion delves into advanced dependency selector syntax, integrating query language with VLT client for updates and additions, running tests, and updating versions. The exploration of VLT client features includes secure package installs, phased installation processes, and DSS capabilities. Multi-project package filtering is expanded through DSS query language with a host local selector for benefits like script inspection and AI agents.
JavaScript File Handling Like a Pro: From ZIP Streams to Memory-Efficient Parsing
JSNation US 2025
24 min
JavaScript File Handling Like a Pro: From ZIP Streams to Memory-Efficient Parsing

Node.js offers significant capabilities for efficient file handling, emphasizing the importance of processing files effectively to avoid crashes and memory issues. Understanding streams, backpressure, and stream concepts like readable, writable, duplex, and transform streams is crucial for efficient file handling. Streams enable working with data in chunks, ensuring stable memory usage and efficient applications. Backpressure in streams optimizes memory usage by processing data incrementally, unlike loading entire files into memory. Utilizing readable streams in processing improves concurrency and avoids blocking the event loop.
Node.js + TypeScript: A Native Integration Years in the Making
JSNation US 2025
19 min
Node.js + TypeScript: A Native Integration Years in the Making

Welcome to JS Nation. Marco Ippolito discusses NodeJS and TypeScript integration, challenges, and growth. TypeStripping in Node.js removes TypeScript syntax for execution. Efficient TypeStripping in Node 22 skips SourceMaps, aligns with TypeScript versions. Enhanced features in Node 22 support experimental TypeScript features with limitations. Node.js supports TypeScript features with erasable syntax and namespace in Node 23.8. Importing types correctly crucial to avoid errors. Node.js TypeScript integration update includes switching to TypeScript, browser support, and community involvement.
Life of an ESM in Node.js – and How It's Changing for the Better
JSNation 2026
29 min
Life of an ESM in Node.js – and How It's Changing for the Better

Talk about the fundamentals of ESM in Node, Node's resolution process for imports, challenges with TypeScript and Node's resolution, customizing module resolution in Node, handling source code loading, loading and parsing modules in Node, module compilation and dependencies, bytecode reuse and instantiation in Node and V8, revamping API design and ESN namespace mutability, deferred evaluation and idempotency in ESM, ESM misconceptions and circular dependencies, and the future of TypeScript loading and performance improvements.
From Legacy to Delight: The Future of Node.js DX
JSNation 2026
21 min
From Legacy to Delight: The Future of Node.js DX

Claudio Bunder emphasizes the importance of Node.js documentation, highlighting its impact on the ecosystem and the challenges in maintaining it. Node.js API documentation tooling faces significant design and implementation hurdles, with a lack of documentation hindering user interaction. The transformation of Node.js API documentation was driven by the need to improve user experience. Dockit, an AST engine, streamlines API documentation generation with support for Markdown, JS Doc, and TS Doc, offering modular flexibility and community-driven documentation creation. Dockit's efficient processing of document structures and metadata, combined with a generator system, ensures high performance and scalability in API documentation generation.
Testing
Automated Accessibility Testing in React: Beyond the Basics
React Advanced 2025
9 min
Automated Accessibility Testing in React: Beyond the Basics

Introduction to Accessibility Testing in React applications, emphasizing early automation and challenges in scaling. Importance of instant feedback, Unity test, and entry testing for code accessibility. Utilizing end-to-end testing tools like Jest-Axi and Cypress to ensure accessibility compliance. Emphasis on manual testing alongside automated tools. Encouragement for discussions on LinkedIn to enhance accessibility knowledge.
AI Can Generate Tests for You, Now What?
Web Engineering Summit 2026
22 min
AI Can Generate Tests for You, Now What?

Living in an exciting and productive period with AI's assistance in test generation and scalability, led by Maya, a Staff Software Engineer passionate about AI accessibility. Streamlined test generation through AI can compromise code quality if not placed correctly, emphasizing the importance of test validity over quantity. Challenges of test generation include cost impacts on code quality, highlighting the need for validity over quantity and the importance of placing tests correctly. Understanding risks and validation criteria in code testing, with an example focusing on search functionality. Importance of mapping tests to specific quarens for effective validation in Agile Testing. Exploring AI integration into Agile Testing, balancing AI and human input for effective workflows. Transitioning to a new scalable workflow with AI test plan generation for enhanced efficiency. Establishing collaboration standards with AI, prioritizing strategic testing tactics over quantity and ensuring code safety beyond complete coverage.
A Leak in the Shell – How Refactoring Autocomplete Broke Us and How We Fixed It
JSNation 2026
26 min
A Leak in the Shell – How Refactoring Autocomplete Broke Us and How We Fixed It

The speaker presents a project to enhance autocomplete in a database CLI using TypeScript, discusses challenges with memory errors in testing, delves into Node.js memory management, explores system contexts and heap snapshots, examines JavaScript memory retention, evaluates the impact of context and eval on memory, uncovers Node.js core bugs and memory leak testing complexities, highlights the use of HeapSnapshots for memory leak detection, emphasizes the importance of application understanding in debugging, and stresses the significance of testing procedures and managing separate heaps.
The 2025 State of JavaScript Testing
JSNation US 2025
27 min
The 2025 State of JavaScript Testing

Speaker reflects on the importance of testing, shares insights from the state of JS survey, and discusses future plans for JavaScript testing in 2025. Companies are exploring testing tools and methodologies based on surveys and personal data. Evolution of testing practices from browser to node-based environment with VTest adoption. Advancements in testing technology include VTest's role, Playwright for end-to-end testing, and comprehensive testing solutions. Progress in self-healing tests, AI integration, and tool resurgence like Storybook and MSW for API mocking. Diverse opinions on testing in 2025, with a focus on static analysis, VTest, and end-to-end testing resurgence to browser.
Fast-Tracking Quality for Hundreds of React Applications With Automated Testing Layers
React Advanced 2025
29 min
Fast-Tracking Quality for Hundreds of React Applications With Automated Testing Layers

Discussion on improving release cycles and testing efficiency, transitioning to React Native, quality assurance challenges addressed through redefined responsibilities and test automation, shift-left approach for early testing and diversification of automated tests, efficient test execution with caching strategies, impact of caching on CI performance, efficiency with change recognition and caching, project-specific approaches for testing, test optimization with AI and Pyramid test structure, QA team transitioning to engineering, handling unautomated tests and test association, maintaining test stability with Git revert strategy.
Stop Testing the DOM: AI + Accessibility for Resilient React Test Automation
React Advanced 2026
18 min
Stop Testing the DOM: AI + Accessibility for Resilient React Test Automation

Frontend apps morph at lightspeed, obliterating traditional test automation in their wake – CSS flips, components explode on re-render, and your test suite? Total carnage, half of it flaming red!Buckle up: I'm unleashing a game-changer – harnessing the browser's Accessibility Tree (the sec...
Component Testing in 2026, the Return of the Browser
React Advanced 2026
21 min
Component Testing in 2026, the Return of the Browser

Component tests started in real browsers with Karma: high fidelity, but slow feedback and painful config. Jest + JSDOM made tests fast and easy, but emulation can miss rendering, layout, and browser APIs.Playwright and Vitest Browser Mode bring back browser-first testing with headless spee...
Think Like a Tester: What to Look For in AI-Generated Code
JSNation 2026
16 min
Think Like a Tester: What to Look For in AI-Generated Code

Developers and QA engineer Wendy discuss the challenges in development and testing, using John's experience as an example. John encounters challenges with expired coupons affecting the checkout process and sprint deadlines. Developers and testers have complementary perspectives in software development; introducing the concept of QAI for enhanced quality assurance and collaboration. The QAI introduces a new perspective to code development, focusing on thorough alignment and error scanning for enhanced quality assurance. The importance of code alignment in development, the consequences of silent failures, and the necessity of handling potential hidden failures with a security-focused approach. AI builds fast and trusts everything, teaches suspicion, identifies trust gaps, and addresses accessibility failures for a secure code environment. Every team has patterns to anticipate, leveraging skills for immediate help, and focusing on effectiveness and protection in AI development. John and I collaborate using QAI to enhance code effectiveness, prioritize code alignment, fix contradictions, and address hidden failures effectively. Ship clean code timely, find bugs early to save time and trust. AI and QAI enhance speed and safety in development. Wendy emphasizes the importance of detecting bugs early and the impact on user trust and deadlines.
Upcoming events
Subscribe to the top Dev conferences
and grow in-depth as engineer and tech leader with insights from library authors, core teams and experts from top tech companies
Learn more
















































































