Upcoming events
Web Development insights directly from framework authors and early adopters.
Talks from our events
Articles
Top ideas
Deep Dives
Deep Dive: Growing to Tech Lead
Growing to Tech Lead
Learn directly from other Senior+ and Lead engineers on how to progress your engineering career, strengthen your foundational skills and become and irreplaceable engineer.
- Talk: Why Engineers Must Become Multipliers in the AI-Era
- Talk: Current Trends in AI for Technical Hiring
- Talk: Walking the Netflix Paved Road (Bumps Included): Web Framework, Hawkins Design System
- Talk: Why Software Engineering Is Becoming: Plan and Review
- Talk: Pocket Guide to Seniority
... and 16 more talks and workshops
Deep Dive: AI Assisted Coding
AI Assisted Coding
Remove the noise, master agentic coding patterns actually tested in production directly from Senior practitioners.
- Talk: Templates and Components for Claude Code: The Future of AI Coding Workflows
- Talk: Using Spec-Driven Development for Production Workflows
- Talk: Building Blocks of an Agentic Engineering Platform: What SRE Taught Us About Running Agents
- Workshop: Operating Agent-Based Systems - Overview, Configure, Run, Orchestrate, Monitor
- Workshop: AI-Powered Code Review
... and 22 more talks and workshops
Deep Dive: Mastering Full-stack
Mastering Full-stack
Master full-stack and fundamental engineering skills for AI-enabled future.
- Talk: Building a JavaScript Engine in Rust: Lessons From Boa
- Talk: Building a JavaScript Engine in Rust: Lessons From Boa
- Talk: Beyond Benchmarks: node.js, Deno, and Bun in Real Production
- Workshop: DevOps for Front-end Developers: From Local Code to Production by Docker Captain
- Workshop: Building Fullstack Apps With Cursor
... and 21 more talks and workshops
Trending today
88 min
DevOps for JavaScript Developers: From Code to Production
Workshop
This workshop closes the old and very real gap between Node.js developers and production.Many Node.js developers can build APIs, services, and backends that work locally—but things fall apart when it’s time to containerize, deploy, scale, and operate them in real environments. This worksho...
Using UDP in the Browser for faster Client/Server Connections
JS GameDev Summit 2023
21 min
Using UDP in the Browser for faster Client/Server Connections
Top Content

This talk introduces geckos.io, a real-time client-server communication library using UDP and WebRTC. The speaker discusses the benefits of UDP for real-time multiplayer games and explains how geckos.io enables UDP connections between browsers and Node.js servers. The deployment process for geckos.io involves opening UDP ports and handling signaling through an HTTP request. The speaker demonstrates how geckos.io works with Docker and showcases the ability to host multiple servers on the same machine. Overall, this talk provides an overview of geckos.io and its applications in real-time communication.
Deploy Everywhere with Expo Router
React Summit 2025
26 min
Deploy Everywhere with Expo Router

Innovating ExpoGo (formerly Exponent) for rapid mobile prototyping with custom native code support and instant deployment. Revolutionizing native app development with Continuous Native Generation (CNG) for enhanced speed and access to new features. Empowering React framework with Expo for web, enabling universal apps with SEO benefits and advanced CSS tools. Innovating navigation with Expo Router for seamless file-based routing and native API integration. Streamlining app deployment with Expo for efficient full stack development and user onboarding.
114 min
Flaky Test Management with Cypress
Workshop
This workshop is for Cypress users who want to step up their game against flake in their test suites. Leveraging the Cypress Real World App, we’ll cover the most common causes of flake, code through some examples of how to make tests more flake resistant, and review best practices for detecting a...
No REST for Cap'n Web
Node Congress 2026
23 min
No REST for Cap'n Web

Kenton Varda advocates for using CapnWeb, an RPC protocol, over REST for web APIs, emphasizing benefits for humans and AI agents. CapnWeb simplifies client-server communications by treating them as function calls. TypeScript type checking ensures method accuracy in CapnWeb across JavaScript runtimes. Stubs in CapnWeb allow method calls to execute on remote objects and simulate all possible method names for remote calls. Converting REST APIs to CapnWeb streamlines code and improves API calls. CapnWeb enhances API functionality with object-specific RPC sessions and promises pipelining for multilevel API optimization. AI agent security challenges are addressed with sandboxing and token protection in CapnWeb. CapnWeb capabilities for AI agents include passing restricted CapnWeb stubs and exploring capability-based security with CapnProto.
Pushing the Limits of Video Encoding in Browsers With WebCodecs
JSNation 2023Watch video: Pushing the Limits of Video Encoding in Browsers With WebCodecs
25 min
Pushing the Limits of Video Encoding in Browsers With WebCodecs
Top Content

This Talk explores the challenges and solutions in video encoding with web codecs. It discusses drawing and recording video on the web, capturing and encoding video frames, and introduces the WebCodecs API. The Talk also covers configuring the video encoder, understanding codecs and containers, and the video encoding process with muxing using ffmpeg. The speaker shares their experience in building a video editing tool on the browser and showcases Slantit, a tool for making product videos.
Pear Runtime: Zero-Infrastructure, P2P High-Scale Applications
JSNation 2024
8 min
Pear Runtime: Zero-Infrastructure, P2P High-Scale Applications

Pair Runtime is a fully peer-to-peer runtime that operates on user devices, with no data stored in the cloud. Pair is a development and deployment tool that enables creating and running Pair applications on user devices. Pair is a platform for building terminal, desktop, and mobile applications, providing all the necessary tools and resources. It offers inherent data security and uses a hole-punching algorithm to connect peers. Pair is designed for simplicity and true security.
Running JavaScript Actually Everywhere
Node Congress 2026
21 min
Running JavaScript Actually Everywhere

JavaScript ecosystem enables versatile development for mobile using frameworks like React Native, Expo, and Bear. Challenges arise in porting server logic to mobile due to limitations in reusing core logic between backend and mobile. Bear stands out as a versatile runtime for iOS, Android, React Native, and Expo, allowing selective module integration. The integration of Bear with React Native simplifies mobile app development and background task execution. Bear emphasizes a 'less is more' philosophy, offering flexibility in engine compilation and compatibility with various platforms. It also supports streamlined native add-on development, NAPI support, and controlled upgrades for pushing runtime limits.
Beyond Signals: The Next Big Shift in Web Reactivity
JSNation US 2025
29 min
Beyond Signals: The Next Big Shift in Web Reactivity

Ryan Carniato, author of SolidJS, discusses signals in the front-end world and their impact on reactivity. Signals in Solid JS have revolutionized frontend UI development by bringing signals to the forefront, impacting frameworks beyond React. Optimizing React performance with fine-grain rendering allows for updating only the necessary components, eliminating unnecessary reruns and enhancing performance composition. Mutability in programming offers benefits like stable references and reduced cloning needs. Stores in frameworks like Solid.js maintain references for unchanged data, reducing overnotifications and unnecessary recalculations. Signals enable fine-grained control with push and pull mechanisms, showcasing examples in counters, async operations, and error handling within UI components.
You Can’t Use Hooks Conditionally… or Can You?
React Summit 2023Watch video: You Can’t Use Hooks Conditionally… or Can You?
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.
Featured
The AI-Native Software Engineer
JSNation US 2025
35 min
The AI-Native Software Engineer

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.
122 min
Pragmatic 101 on Custom JS Tooling for Your Project
Featured Workshop
Let’s demystify the secrets of modern JavaScript tooling. In this workshop, you will learn how linters, compilers, and code transforms work. You will take your first steps building your own developer tools, writing an ESLint rule, a compiler plugin, and a code transformation. Learn these skills t...
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.
Vite and the Future of JavaScript Tooling
JSNation 2025
23 min
Vite and the Future of JavaScript Tooling
Top Content

Evan Yeo discusses Vite's growth, challenges with dependencies like ES Build and Rollup, and the creation of the bundler Rolldown. The JavaScript ecosystem faces fragmentation, but the company aims for a unified JavaScript stack. Rust is chosen for lower-level development, while JavaScript and TypeScript for high-level APIs. Roldown offers advanced bundling features, outperforming existing tools. Integration with Vite leads to tailored optimizations and significant speed improvements. Vite+ development focuses on creating a comprehensive toolkit. VitePlus integrates TS-down for library bundling, ViteTest for testing, and OX-Lint for linting. Future plans include monorepo awareness, build orchestration, and framework-like features.
102 min
Production-Ready Apps with AI Agents
Featured Workshop
Coding assistants are already changing the way we develop code, and in several years they are expected to completely change how developers interact with code and write it. In this workshop, I'll share tips and best practices on using such tools as we develop the production-ready app with Zencoder...
64 min
Vibe coding with Cline
Featured Workshop
The way we write code is fundamentally changing. Instead of getting stuck in nested loops and implementation details, imagine focusing purely on architecture and creative problem-solving while your AI pair programmer handles the execution. In this hands-on workshop, I'll show you how to leverage...
I Measured React Server Components’ Performance So You Don’t Have To
React Advanced 2025
22 min
I Measured React Server Components’ Performance So You Don’t Have To

Nadia introduces React server components and performance, highlighting the benefits of server components in improving performance and the need for a clear understanding of their impact on rendering and data fetching in React applications. Exploring Server-Side Rendering Impact on Performance: Analysis of transitioning from client-side to server-side rendering, including implications on performance and data fetching. Transforming Empty Screen to Performance Improvement: Detailed process of browser work, React rendering, and data fetching impact. Making the Shift to Server-Side Rendering: Impact on interactivity and data fetching optimization. Understanding the Benefits of AppRouter Version in SSR with Reduced JavaScript Payload and Introduction of Server Components. Investigating Smarter Server-Side Rendering with Server Components and Streaming in Next.js. Refactoring for Server Components: Async Data Fetching, Server Component Identification, and Utilizing Suspense for React Streaming Chunks. Enhancing Performance with Server Components: Balancing Rendering Approaches, Importance of Server-Side Data Fetching, and Leveraging Suspense for Improved Streaming.
96 min
The React Developer's Guide to AI Engineering
Featured WorkshopFree
A comprehensive workshop designed specifically for React developers ready to become AI engineers. Learn how your existing React skills—component thinking, state management, effect handling, and performance optimization—directly translate to building sophisticated AI applications. We'll cover the...
179 min
Exploring Server Side Rendering
Featured Workshop
Server-side rendering (SSR) is back in the spotlight – and React is evolving fast. In this workshop, we’ll go deep into the mechanics, performance trade-offs, and modern techniques of SSR with React.js. You'll start by building an SSR app from scratch – no frameworks, just raw renderToString and...
98 min
Building a RAG System in Node.js: Vector Databases, Embeddings & Chunking
Featured Workshop
Large Language Models (LLMs) are powerful, but they often lack real-time knowledge. Retrieval-Augmented Generation (RAG) bridges this gap by fetching relevant information from external sources before generating responses. In this workshop, we’ll explore how to build an efficient RAG pipeline in N...
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.
Garbage Collection Between V8, cppgc (Oilpan), and Native Runtimes
Node Congress 2026
9 min
Garbage Collection Between V8, cppgc (Oilpan), and Native Runtimes

Today's presentation delves into garbage collection challenges in JavaScript and native code, highlighting the impact on memory leaks and bugs. V8's implementation of minor and major garbage collection is discussed. The evolution of memory management in runtimes, including Node.js and Deno, is explored, emphasizing the shift towards automatic cleanup and improved performance. The complexity of runtime memory management, especially in handling CPP objects and bridging with workers, is outlined. Key points include the efficiency gains from generational garbage collection and the importance of migrating away from certain memory management practices for enhanced runtime performance.
Server Components Wars: PHP Strikes Back
React Summit 2025
6 min
Server Components Wars: PHP Strikes Back

Edoardo, a senior dev rel at Storyblok, delves into server components' intricacies, urging a better understanding. The evolution from PHP to React marked a shift in web development paradigms, emphasizing server-side rendering and dynamic client interactions. Facebook transitioned from PHP to React, introducing XHP subset. Isomorphic JavaScript and server-side rendering emerged with data requests and content rendering. React server components enable server-side rendering with data fetched from DBMS or CMS, emphasizing patterns for seamless transitions to new frameworks.
Reimagine Frontend in the Serverless Era
React Summit 2025
8 min
Reimagine Frontend in the Serverless Era

Evangelia, tech founder of Fioromat Academy, discusses the impact of serverless technologies on frontends, emphasizing a shift towards lightweight, stateless backends split into smaller units and the increased importance of API gateways and serverless functions. The discussion also highlights the significance of optimistic state updates, caching strategies to reduce API calls, resilient connection handling with retries for failed HTTP calls, granular error handling at the component level, and custom fallback UI per component. Overall, the Talk emphasizes the evolving frontend architectures and the necessity of adapting to changes in data structures and technologies.
Delivering High-Quality Videos on Your ReactJS Website
React Summit 2025
7 min
Delivering High-Quality Videos on Your ReactJS Website

Raul from ImageKit discusses optimizing and streaming videos, highlighting challenges like resolutions and codecs. Developers can use ImageKit Video API for seamless integration and quick optimization. ImageKit offers streamlined video hosting with real-time optimization and adaptive streaming. It enables easy access to cloud storage and transformation of videos for better 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.
Using Spec-Driven Development for Production Workflows
JSNation US 2025
7 min
Using Spec-Driven Development for Production Workflows

We're discussing spec-driven development and the innovative AI IDE, QIRO, that supports this approach. QIRO focuses on structured specifications before coding, aiding developers in creating designs. The QIRO mascot, a playful ghost, symbolizes the essence of spec-driven development. Eric Hanchett discusses QIRO, emphasizing its spec-driven development feature integrated into the IDE. QIRO aids in in-depth feature planning, resembling a structured requirements approach. Coding assistants benefit from detailed examples for efficient development. Exploring Manual Coding Assistance: Creating user requirements, building design documents, and task lists manually. Example of using spec mode in a coding assistant to break down requirements, create designs, and implement features.
Auth: Build vs Open Source vs Buy
JSNation 2025
7 min
Auth: Build vs Open Source vs Buy

Authentication is crucial for system security, with options including building, buying, or using open source. Modern security complexities are addressed by purchasing systems with enterprise-level security features. Cost considerations in authentication highlight maintenance and scaling costs, with buying solutions providing peace of mind and predictable costs.
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.
It’s Not Magic: Elevate Auth Security with PKCE Best Practices
Node Congress 2025
5 min
It’s Not Magic: Elevate Auth Security with PKCE Best Practices

The talk discusses the need to enhance auth security with Pixie Best Practices and the limitations of current standards like OAuth 2 and OpenID Connect. It introduces Pixie as an added layer of security over the authorization code flow and explains how it prevents code injection. Pixie enhances security by connecting client requests with responses from the authorization server, preventing cross-site request forgery attacks. It is recommended for public clients and will be required for all clients in the upcoming OAuth 2.1 spec. The talk also highlights the benefits of Pixie for enhancing security in web apps. Learn more about Pixie and best practices at FusionAuth, where Kim Meida, Senior Director of Developer Relations, provides developer-first auth and auth APIs.
Latest
Typescript Is SO SLOW...Or Is It?
Node Congress 2026
27 min
Typescript Is SO SLOW...Or Is It?

Mike's enthusiasm for TypeScript, its widespread adoption, benefits in development, and its downside in terms of speed. Exploring TypeScript's slow performance in build speeds and its implications on project deployment in CI environments. Running TypeScript build commands and optimizing build speeds by managing project size. Reducing build times by breaking down large projects into smaller, isolated modules using monorepos. Exploring the limitations of path aliases and the importance of utilizing workspaces for efficient code isolation and faster TypeScript performance. Discussing project references efficiency in TypeScript builds and the impact on compiler and build speed. Discussing the impact of live evaluation on editor speed and how pre-build scripts can significantly improve completion time and overall typing experience. Avoid live evaluation for large projects, consider pre-builds. Discussion on TypeScript port to Go and its impact on future versions. Importance of optimizing project setup for speed and efficiency.
Beyond Benchmarks: node.js, Deno, and Bun in Real Production
Node Congress 2026
12 min
Beyond Benchmarks: node.js, Deno, and Bun in Real Production

Vinicius Neves emphasizes practical considerations over speed comparisons when choosing a JavaScript runtime. The discussion delves into debugging and observability differences among Node, Dino, and Bun at 3 a.m. Metrics, error tracking, deployment, and serverless capabilities are explored across these runtimes. Serverless deployment challenges and considerations, including CICD integration and deployment target relevance, are highlighted. Serverless cold start performance is compared, with Bun leading, followed by Dino and Node. The talk also emphasizes hiring considerations, NPM compatibility issues, permission models, and testing workloads before committing to a runtime.
No REST for Cap'n Web
Node Congress 2026
23 min
No REST for Cap'n Web

Kenton Varda advocates for using CapnWeb, an RPC protocol, over REST for web APIs, emphasizing benefits for humans and AI agents. CapnWeb simplifies client-server communications by treating them as function calls. TypeScript type checking ensures method accuracy in CapnWeb across JavaScript runtimes. Stubs in CapnWeb allow method calls to execute on remote objects and simulate all possible method names for remote calls. Converting REST APIs to CapnWeb streamlines code and improves API calls. CapnWeb enhances API functionality with object-specific RPC sessions and promises pipelining for multilevel API optimization. AI agent security challenges are addressed with sandboxing and token protection in CapnWeb. CapnWeb capabilities for AI agents include passing restricted CapnWeb stubs and exploring capability-based security with CapnProto.
34 min
Building with Gemini: AI Studio, Antigravity, and Google DeepMind's Latest Models
WorkshopFree
In this hands-on session, we'll dive straight into the practical mechanics of working with Google DeepMind’s latest research and models. We'll explore Google AI Studio, Antigravity, and the Gemini APIs, focusing on how to seamlessly integrate these capabilities into your own projects. If you're l...
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.
73 min
Building Model Context Protocol (MCP) Tools for AI Agents with Cloudflare Workers
WorkshopFree
In this hands on workshop participants will learn how to create a production‑ready Model Context Protocol (MCP) server on Cloudflare Workers. The session covers defining tool endpoints, integrating external APIs, persisting state with KV storage, and globally deploying the server so AI assistants...
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.
100 min
The Cake Is a Lie... And So Is Your Login’s Accessibility
Workshop
Much like the promise of cake in Portal, login forms are everywhere in web development. While they may seem functional at first glance, many users with disabilities encounter a maze of invisible walls, from keyboard traps to inaccessible CAPTCHAs. It's as if GLaDOS designed these forms herself to...
Node Just Run
Node Congress 2026
16 min
Node Just Run

Using Node to simplify common tasks in local environments and CI. Customization hooks and extending Node for additional file types are discussed by Jacob Smith. Node's need to understand different file types for main.tsx. Avoid using bundlers for local environments. Extending Node with customization hooks for asynchronous work is discussed. Spinning up infrastructure for async work is crucial. Utilize single responsibility principle for handling specific functionalities like CSS modules and media URLs. Collection of loaders/customization hooks simplifies integration with Node for various tasks. You don't need extensive knowledge of the inner workings. A demonstration highlights the usefulness of this approach in web development. Using customization hooks can significantly improve testing efficiency and speed. Node can spin up quickly without needing additional time. Minimal configuration is required, focusing on CSS modules and media URLs. Small, encapsulated functionalities do one thing, not heavily interacting with each other. Alternatives like Vite and Vitest are popular but may not offer the same performance as Node alone. Customization hooks allow precise usage, unlike solutions with a broader scope. The size impact difference is significant, with tiny customization hooks compared to larger alternatives, showing similar performance in tests.
Security Pitfalls in AI-Generated Code: What Happens When Developers Skip Review
AI Coding Summit 2026
25 min
Security Pitfalls in AI-Generated Code: What Happens When Developers Skip Review

Introduction to AI security pitfalls, emphasizing the importance of understanding AI promises and risks, responsibility in verifying AI-generated code, the necessity of code verification and thorough review for secure deployment, ensuring code validation and sanitization for secure applications, risks of unsecure authentication logic and broken authorization due to AI usage, the importance of avoiding exposing secrets in code by trusting AI blindly, learning resources on cloud security and platforms like Flare Learning and TryHackMe, and the significance of creating AI rules, testing, and following best practices for code security.
Popular
Vue: Feature Updates
Vue.js London 2023Watch video: Vue: Feature Updates
44 min
Vue: Feature Updates
Top Content

The Talk discusses the recent feature updates in Vue 3.3, focusing on script setup and TypeScript support. It covers improvements in defining props using imported types and complex types support. The introduction of generic components and reworked signatures for defined components provides more flexibility and better type support. Other features include automatic inference of runtime props, improved define emits and defined slots, and experimental features like reactive props destructure and define model. The Talk also mentions future plans for Vue, including stabilizing suspense and enhancing computer invalidations.
117 min
Detox 101: How to write stable end-to-end tests for your React Native application
Top Content
Workshop
Compared to unit testing, end-to-end testing aims to interact with your application just like a real user. And as we all know it can be pretty challenging. Especially when we talk about Mobile applications.
Tests rely on many conditions and are considered to be slow and flaky....
Tests rely on many conditions and are considered to be slow and flaky....
Future Features of JS?!
JSNation 2022
28 min
Future Features of JS?!
Top Content

Welcome to the future features of JavaScript, including proposals for array operations, throw expressions, records and TPUs, pipeline operators, and more. The talk covers the introduction of type assertions for imported files, non-mutating array operations, and the simplification of error handling. It also explores the concept of immutability with records and TPUs, and the use of the pipeline operator to simplify code. Other proposals include Map.implace, IteratorHelper, slice notation, type annotations, Array UNIQBY, number ranges, and the Function 1 proposal.
Managing React State: 10 Years of Lessons Learned
React Day Berlin 2023Watch video: Managing React State: 10 Years of Lessons Learned
16 min
Managing React State: 10 Years of Lessons Learned
Top Content

This Talk focuses on effective React state management and lessons learned over the past 10 years. Key points include separating related state, utilizing UseReducer for protecting state and updating multiple pieces of state simultaneously, avoiding unnecessary state syncing with useEffect, using abstractions like React Query or SWR for fetching data, simplifying state management with custom hooks, and leveraging refs and third-party libraries for managing state. Additional resources and services are also provided for further learning and support.
Modern Web Debugging
JSNation 2023
29 min
Modern Web Debugging
Top Content

This Talk discusses modern web debugging and the latest updates in Chrome DevTools. It highlights new features that help pinpoint issues quicker, improved file visibility and source mapping, and ignoring and configuring files. The Breakpoints panel in DevTools has been redesigned for easier access and management. The Talk also covers the challenges of debugging with source maps and the efforts to standardize the source map format. Lastly, it provides tips for improving productivity with DevTools and emphasizes the importance of reporting bugs and using source maps for debugging production code.
177 min
React Hooks Tips Only the Pros Know
Top Content
Featured Workshop
The addition of the hooks API to React was quite a major change. Before hooks most components had to be class based. Now, with hooks, these are often much simpler functional components. Hooks can be really simple to use. Almost deceptively simple. Because there are still plenty of ways you can me...
Building a JS Engine -- For Fun!
JSNation 2024
9 min
Building a JS Engine -- For Fun!
Top Content

The Talk discusses the basics of building a JS engine, highlighting the complexity and feature completeness of existing engines. It emphasizes the possibility of creating a simpler engine tailored to specific use cases and target audiences. The speaker suggests starting anywhere in the process and provides tips on using parser libraries, implementing runtime features, and ensuring correctness through testing. Additionally, the Talk encourages exploring JavaScript standards and engaging with the open-source community.
Record & Tuple: Immutable Data Structures in JS
JSNation 2022
24 min
Record & Tuple: Immutable Data Structures in JS
Top Content

Today's Talk introduces the concept of record and tuple in JavaScript, which provide a new way to handle data. The Talk explores the references and mutability of objects, strings, and numbers in JavaScript. It discusses the limitations of freezing objects and proposes record and tuple as a solution. The Talk also covers methods and syntax for tuples, the status of the proposal, and acknowledges the contributions of various individuals. Overall, the Talk aims to redefine how data is handled in JavaScript and encourages waiting for broader browser support before implementing these features.
Deno 2.0
Node Congress 2023
36 min
Deno 2.0
Top Content

The Talk discusses forced optimization with Node and Deno, with Deno aiming to pursue the same goals in a more expansive and modern way. Deno has built-in support for NPM and enforces security constraints. It also has a key-value database called Deno KV, which will be a core part of the Deno 2 API. Deno Deploy is a serverless Edge Functions platform powered by FoundationDB, optimized for fast reading and ideal for building eCommerce sites or application servers at the edge. Deno 2.0 is coming soon with more features under development.
Options API vs Composition API: Choosing the Right Approach for Your Team
Vue.js London Live 2021
23 min
Options API vs Composition API: Choosing the Right Approach for Your Team
Top Content

Today's Talk discusses the Options API and Composition API in Vue 3, highlighting the differences and considerations when choosing an approach. The Composition API offers more flexibility and integrates well with TypeScript, but may require more familiarity with JavaScript. Combining both APIs allows for structure and flexibility, with the ability to progressively enhance code. Team preferences and the level of TypeScript usage should be considered when choosing the right approach for a project.
JavaScript
10 Years of Best of JS
JSNation 2025
28 min
10 Years of Best of JS

Michael discusses the evolution of JavaScript from its early days to modern server-side capabilities, the impact of jQuery, Node.js, and single-page applications with popular libraries like Backbone and AngularJS. The emergence of UI libraries like React, Vue.js, and Angular, alongside meta frameworks like Next.js, Remix, Veltkit, and Solid with server components. The Best of JS project tracks JavaScript project trends, filters out deprecated projects, and monitors GitHub stars for maintenance. The importance of maintaining project relevance, adding new projects continuously, and classifying projects under meaningful tags. The evolution of TypeScript, tool releases like Deno and Burn, styling evolution from CSS to headless components, and the impact of Tailwind CSS. Analysis of CSS optimization, CLI ecosystem, tooling trends, emerging tools, and JavaScript development trends over the past decade.
Temporal: The Curious Incident of the Wrong Nighttime
JSNation 2025
25 min
Temporal: The Curious Incident of the Wrong Nighttime

Speaker's involvement in Temporal proposal and TC39 meetings for JavaScript standardization. Date conversion challenges faced in development. Addressing time zone discrepancies with Temporal to prevent bugs. Exploration of Temporal types and design philosophy. Usage of Java's time zone serialization in JavaScript Temporal. Challenges in implementing Temporal proposal and its transformative potential in ECMAScript.
React
Our Own React Global State Manager in Less Than 50 Lines of Code
React Summit 2025
26 min
Our Own React Global State Manager in Less Than 50 Lines of Code
Top Content

Speaker delves into global state management in React, mentioning Redux and alternatives like React context. Creating a global state manager in under 50 lines of code with React context, highlighting challenges with performance and React specificity. Building a custom hook named user store for state management, implementing state and API for store, handling partial state updates efficiently. Managing listeners for state changes, setting up custom hooks and selectors, and subscribing to external stores. Demonstrating optimization in state management and preventing unnecessary button re-renders. Discussion on Redux, Signals, debugging, and various global state management choices like Zestand and Redux toolkit.
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.
Panel Discussion: The State of React
React Summit 2025







35 min
Panel Discussion: The State of React








7 authors
Panelists introduced themselves and discussed React Server Components (RSCs), exploring usage in production and alternative frameworks. Challenges of adopting RSCs and benefits of universal data fetching were highlighted. The complexities of implementing RSCs were discussed, emphasizing the need for better integration. The potential of server components for composability and evolving architecture was explored. The React compiler's impact on performance optimization and component re-rendering was examined. Discussions included enhancing React with compiler features, evolving feature sets, and reimagining state management. Improvements in communication, community engagement, and dependency management within the React ecosystem were emphasized. Recommendations for managing dependencies, component performance, and audience appreciation were shared.
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.
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.
121 min
TDD in Frontend
Workshop
Tests first, code last!How to develop your frontend that the code isn't falling apart? How to make it scary free to deliver your work results? How to battle bugs that are chasing you at every step you make?I am going to answer these questions during the workshop and show how to foll...
The State of React and the Community in 2025
React Summit 2025
29 min
The State of React and the Community in 2025

Mark Erickson discusses the state of React in 2025, React community debates on React's direction and misconceptions, React's shift towards client-side frameworks and SSR emphasis, React's feature development process at Meta and Vercel, controversy around Vercel's server components involvement, tight relationship between React and Next, React team's emphasis on frameworks for app performance, critique of React's heavy-handed framework recommendation, React team's delay in adding VEET as a recommended tool, challenges with server components' origins and communication, no official signals support planned for React 19, social media impact on React development decisions, React community diversity and server components usage insights, React's evolving black box concept and tradeoffs discussed.
125 min
Hands-on React Server Components, Server Functions, and Forms in the Next.js App Router
Workshop
In this workshop, we will explore React's latest features: Server Components, Server Functions, and forms. Discover how to optimize server-side rendering, build smooth user experiences with React Suspense and Transitions, and enhance application interactivity with Server Functions and new React 1...
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.
How to React Compiler
React Summit 2025
20 min
How to React Compiler

Introduction to React compiler, differences from React 19, installation of Babel plug-in React compiler, specifying target React versions, and how React compiler detects and processes component dependencies. Configuring React compiler settings, exploring default options and configurations, utilizing React compiler playground website for configurations, dealing with JSX markup re-computation. React compiler feature for extracting JSX from array map callbacks, limitations of enable function outlining, enabling JSX outlining for separate functions. Function memoization in React compiler, React compiler beta stage, potential errors with React compiler. React compiler error: memorization preservation, hidden messages, validation settings. React compiler: validation tools, hooks treatment, memorization challenges. Changing hooks to functions for React compiler optimization. React Compiler usage considerations and potential optimizations.
Free workshops
53 min
"Hello World" on OpenShift AI: Training Your First Neural Network
WorkshopFree
Join us for an interactive workshop where you'll train your first neural network using the classic MNIST handwritten digit dataset. In this hands-on session, participants will use OpenShift AI 3.x Workbenches to build and train a PyTorch model that recognizes handwritten digits from images.
52 min
Hands-On Guide to Secure AI-Driven Coding
WorkshopFree
Modern AI coding agents don’t just autocomplete. They execute, connect, and automate. With the wrong settings, they can access more of your system than you intended. In this session, I’ll demonstrate how agent autonomy, MCP integrations, and Skills can lead to unexpected security risks. Through e...
49 min
Ship a Production Voice Agent: A Hands-on Workshop
WorkshopFree
Ready to bring conversational AI to life? In this hands-on workshop, we'll walk through deploying a real-time voice agent using Render's cloud platform. You'll work directly with LiveKit's voice agent template to create an interactive AI assistant that can listen, think, and respond naturally thr...
87 min
Build Your Dream Extensions with AI
WorkshopFree
In this interactive workshop, you’ll build a working internal browser extension you and your team can use to share context across apps you use daily. We’ll start with a practical, real-world example: a web clipper that you’ll customize to send content from GitHub to your team’s communication tool...
76 min
Using Sandboxes to Safely Execute Untrusted or Dynamic Code
WorkshopFree
This workshop introduces Sandboxes as a general computing primitive and uses Cloudflare Sandboxes as the concrete implementation. Participants explore common, real-world use cases for sandboxed execution and learn how to reason about when and why sandboxes are the right tool.
The works...
The works...
141 min
Building AI workflow editor UI in React with Workflow Builder SDK
WorkshopFree
Join us to learn how to build your own Zapier-like interface in days, not months. Discover how to save 1,000+ hours of design and coding upfront, building a complex workflow editor UI from scratch. Customize it for AI orchestration, automations, business processes visualization and other real-wor...
145 min
Build LLM agents in TypeScript with Mastra and Vercel AI SDK
Featured WorkshopFree
LLMs are not just fancy search engines: they lay the ground for building autonomous and intelligent pieces of software, aka agents.
Companies are investing massively in generative AI infrastructures. To get their money's worth, they need developers that can make the best out of an LLM, and t...
Companies are investing massively in generative AI infrastructures. To get their money's worth, they need developers that can make the best out of an LLM, and t...
109 min
How To Enhance an Existing React App With AI, Without Rewriting It From Scratch
WorkshopFree
In this workshop, we will incrementally augment an existing React application with AI. I'm sure most of you probably already maintain a React app, so rather than starting from the ground-up, let's take something that already works, and develop some patterns for adding practical, real-world AI fea...
58 min
On-Premise Open-Source LLMs with Ollama & FastAPI
WorkshopFree
This workshop introduces how to use open-source LLMs on-premise for enhanced data control, privacy, and cost efficiency. It highlights Ollama for simplified LLM management (downloading, running models offline) and FastAPI for efficient local hosting, enabling fast API development and seamless int...
83 min
Data is Beautiful: Creating Compelling Data Visualisations with AG Charts
WorkshopFree
AG Charts is a JavaScript Charting Library, built by AG Grid, that you can use to create beautiful and compelling data visualisations in React, with a simple, intuitive, flexible API.What You'll Learn: In this workshop, you'll learn how to get started with AG Charts to create simple visual...
Upcoming events
Subscribe to the top JS conferences
and grow in-depth as engineer with insights from library authors and core teams
Learn more










































































