Episodes
How The Web Platform Is Killing Framework Fatigue
In this episode, we examine how modern web standards like the HTML Dialog element and native form validation are rendering heavy JavaScript frameworks obsolete for simple interfaces. Lucas walks through the specific performance overhead of bundling React for a single modal window, while Luna explores the developer experience shift from learning obscure library APIs to mastering reliable browser primitives. We look at concrete benchmarks showing how native components reduce bundle size by up to…
How Edge Caching Transforms Web Performance
We examine how the shift from centralized servers to distributed edge caching is reshaping web performance standards. With CDN providers now processing complex logic at the network edge, developers are rethinking latency, security headers, and user experience for global audiences. We look at specific benchmarks from major infrastructure players and discuss why moving static assets closer to the user is no longer optional but foundational to modern web architecture. #WebPerformance…
Why The Web Is Dying Without Privacy
The death of third-party cookies is forcing a fundamental rewrite of how the modern web measures success. Lucas and Luna break down the shift from identity-based tracking to context-based modeling, using the rollout of Google's Privacy Sandbox APIs as the central case study. We look at why attribution is breaking, how companies are pivoting to first-party data strategies, and what this means for small businesses that relied on cheap audience targeting. This episode covers the technical…
How The CSS Cascade Layers Fix Specificity Wars
CSS specificity has long been a source of frustration for developers, leading to brittle stylesheets and endless !important battles. In this episode, Lucas and Luna explore the new CSS Cascade Layers feature, which introduces a predictable hierarchy for style declarations. They break down how @layer rules work, why they solve the specificity problem better than previous hacks, and provide concrete examples of structuring large-scale applications with layers like reset, base, component, and…
How The Web Platform Evolved Without Libraries
We examine how native browser APIs like View Transitions, CSS Container Queries, and the Web Locks API have reduced the need for heavy frontend frameworks. Lucas and Luna discuss why building with vanilla JavaScript and modern CSS is becoming a viable, performant strategy for enterprise applications, using specific examples of performance gains and developer experience improvements in September 2026. #WebDevelopment #VanillaJS #FrontendArchitecture #CSSContainerQueries #ViewTransitionsAPI…
How The Open UI Initiative Changes Browser Components
We explore the Open UI community effort to bring native-like controls like menus, dialogs, and tabs directly into HTML. Lucas and Luna discuss why custom JavaScript widgets often fail at accessibility and performance, and how standardized web components could finally give developers a reliable foundation for complex interfaces without reinventing the wheel every time. #OpenUI #WebComponents #HTMLStandard #Accessibility #FrontendDevelopment #BrowserEngines #UserInterfaceDesign #W3C #WCAG…
How Server-Sent Events Simplify Real-Time Data
WebSockets are powerful but often overkill for dashboards and live feeds. In this episode, Lucas and Luna break down why Server-Sent Events offer a simpler, HTTP-based alternative for one-way streaming. They examine the specific use cases where SSE shines, compare it against traditional polling and WebSockets, and look at how modern frameworks like Next.js handle these connections with minimal overhead. If you are building admin panels or notification systems, understanding this distinction can…
How Web Components Simplify Enterprise Design Systems
We dive into why major enterprises are abandoning custom JavaScript frameworks for standardized web components in their design systems. With Apple, Microsoft, and Google all contributing to the ecosystem, we look at how encapsulation solves the CSS leakage problem that plagued earlier attempts at component libraries. We examine a specific case study of a financial services firm that reduced their bundle size by forty percent after switching to native shadow DOM implementations. This is not just…
How WebGPU Is Reshaping Browser-Based Rendering
WebGPU is the new low-level graphics API for the web, promising performance parity with native applications. In this episode, we look at how Mozilla and Google are driving adoption through specific use cases like real-time ray tracing in browsers and complex data visualization. We examine the technical hurdles of shader compilation, the shift from WebGL's immediate mode to WebGPU's command buffer architecture, and what this means for developers building high-fidelity 3D experiences without…
How Subresource Integrity Prevents Supply Chain Attacks
We examine how Subresource Integrity transforms browser security by verifying external scripts before they execute. Using the 2021 Cloudflare incident as a cautionary tale, we break down how hash-based validation stops attackers from hijacking third-party libraries like jQuery or analytics trackers. Lucas and Luna discuss the practical implementation of SRI attributes in modern web stacks, weighing the minor performance overhead against the massive risk reduction for user data and brand…
How Edge Functions Changed Serverless
We explore the shift from centralized cloud compute to edge computing, focusing on how global latency affects user experience and revenue. Using a specific case study of an e-commerce platform that reduced load times by half by moving logic closer to users, we examine the trade-offs between consistency and speed. The conversation covers when to use edge functions versus traditional serverless, the implications for data privacy regulations like GDPR, and why this architecture matters for modern…
How WebSockets Enable Real-Time Apps
We explore how the WebSocket protocol transformed web development by enabling persistent, bidirectional connections between browsers and servers. Lucas breaks down the handshake process, frame structure, and latency benefits compared to traditional HTTP polling. Luna examines real-world use cases like collaborative editing tools, live trading dashboards, and multiplayer games that rely on sub-millisecond updates. We discuss security considerations including origin validation and message…
How Web Components Finally Reached Prime Time
In episode 172 of The Web Development Podcast, Lucas and Luna explore the quiet revolution of Web Components — the standards-based way to build reusable UI without heavy frameworks. They dig into the Custom Elements API, Shadow DOM, and the rising tide of platform support that's making Web Components a serious choice for design systems, micro-frontends, and performance-conscious teams. Along the way, they discuss real-world adoptions at major companies and the trade-offs developers face between…
CSS Container Queries Adaptive Component Styling
In this episode of The Web Development Podcast, Lucas and Luna explore the CSS Container Queries API, a feature that lets components adapt their styles based on their container's size rather than the viewport. They trace its journey from early community demand to baseline status across major browsers in early 2023, and explain why it's a game-changer for component-driven development. The hosts break down key concepts like container-type and container-name, compare it to media queries, and…
How the CSS Typed Object Model Boosts Performance
In this episode, Lucas and Luna explore the CSS Typed Object Model, or Typed OM, a browser API that transforms how developers read and write CSS values from JavaScript. Instead of wrestling with strings like 'transform: translateX(10px)', Typed OM gives you typed JavaScript objects with unit-aware numbers, making code cleaner and faster. They break down how it works, why it beats the old CSSOM string approach, and how it enables smoother animations and layout thrashing prevention. They also…
How the CSS View Transitions API Makes Page Changes Feel Native
In episode 169 of The Web Development Podcast, Lucas and Luna dive into the CSS View Transitions API, a browser feature that lets developers create smooth, native-feeling page transitions without heavy JavaScript libraries. They break down how it works under the hood, from the pseudo-element tree to the snapshot process, and walk through a concrete example: migrating a client's React app from a janky loading spinner to buttery cross-fades. They also discuss browser support as of August 2026…
How CSS View Transitions Make Page Changes Feel Native
In this episode of The Web Development Podcast with Fexingo, Lucas and Luna dive into the CSS View Transitions API, a browser feature that lets developers create smooth, native-feeling animations when navigating between pages or updating the DOM. They break down how it works under the hood, explore real-world examples like a photo gallery and a dashboard, and discuss performance and progressive enhancement. The episode also covers the new same-document variant and what it means for single-page…
How the CSS Scroll Timeline API Powers Storytelling
In this episode of The Web Development Podcast, Lucas and Luna dive into the CSS Scroll Timeline API, a game-changer for scroll-driven storytelling on the web. They explore how it lets developers tie animations directly to scroll progress without a line of JavaScript, using the new animation-timeline property. The conversation looks at a real-world example: a product page that animates a character running across the screen as you scroll, with a progress bar that fills and text that fades in and…
How CSS Light-Dark() Simplifies Theme Switching
In Episode 166 of the Web Development Podcast, Lucas and Luna explore the CSS light-dark() function, a native way to implement light and dark mode without JavaScript or complex theming systems. They walk through how it works, its browser support as of August 2026, and real-world performance benefits. The episode also covers tips for handling fallbacks, custom properties, and accessibility, plus a subtle nod to listener support that keeps the show ad-free. Perfect for frontend developers looking…
How the CSS Color Function Simplifies Design Tokens
In this episode of The Web Development Podcast, Lucas and Luna explore the CSS Color Module Level 4 and its impact on modern design systems. They discuss how new color functions like color-mix(), relative color syntax, and wider gamut support simplify creating, maintaining, and scaling design tokens. The conversation touches on practical examples, browser support, and how tools like style dictionaries are evolving. They also consider potential pitfalls and how teams can adopt these features…
How CSS State Queries Adapt Layouts to Component State
Lucas and Luna dive into CSS state queries, the emerging spec that lets components adapt their styling based on internal state like visibility, disabled, or checked — without a single line of JavaScript. They explore how this differs from container queries, walk through a real example with a custom dropdown, and discuss browser support as of August 2026. If you're tired of toggling classes or writing imperative state logic for UI, this episode explains how state queries could simplify your…
How the CSS Transition Behavior Property Unlocks Discrete Animations
In this episode, Lucas and Luna dive into the CSS transition-behavior property, a game-changer for animating properties that were once impossible to transition, like display and visibility. They explain how this single line of code enables smooth, discrete animations that were previously only achievable with JavaScript workarounds. Using real-world examples like accordion menus, image carousels, and dropdowns, they show how transition-behavior simplifies state changes and improves user…
How the CSS Color Function Simplifies Design Tokens
In this episode of The Web Development Podcast, Lucas and Luna dive deep into the CSS Color 4 specification and how modern color functions like color(), oklch(), and color-mix() are revolutionizing design token management. They explore a real-world case study of a design system migration at a mid-sized tech company, where the team cut their color token count from 200 to 50 while improving consistency across light and dark modes. Lucas explains the math behind perceptually uniform color spaces…
How the CSS Toggle Group Simplifies State Management
In this episode, Lucas and Luna explore the CSS Toggle Group and Toggle State — the new primitives that let you manage complex UI states, like accordions and tabs, directly in CSS without writing a line of JavaScript. They break down how it works, compare it with older approaches like the checkbox hack, and discuss browser support as of August 2026. You'll learn a concrete technique for building accessible, performant components with far less code, and hear why this could be a turning point for…
How the Web Locks API Prevents Double-Spend in Browser Apps
In episode 160 of The Web Development Podcast, Lucas and Luna explore the Web Locks API, a browser feature that lets web apps coordinate access to shared resources. They explain how it works, why it matters for everything from offline-first apps to real-time collaboration, and walk through a practical example: preventing double-spend in a client-side budget tracker. They also touch on the API's surprising history, its pitfalls, and how it fits into the broader evolution of the web platform. If…
How The Web Share API Expands Browser Sharing
In episode 159 of The Web Development Podcast, Lucas and Luna dive into the Web Share API, exploring how it lets web apps trigger native share sheets across devices. They walk through a concrete example of integrating the API with the File System Access API to share files, discuss browser support nuances including Safari and Chrome on Android, and explain how to handle fallbacks for desktop browsers. The episode also covers the relationship between the Web Share API and the Web Share Target…
How CSS Anchor Positioning Replaces JavaScript Popovers
In Episode 158 of The Web Development Podcast, Lucas and Luna dive into the CSS Anchor Positioning API, a game-changer for UI development. They explore how this native CSS feature lets you position elements relative to other elements without JavaScript, using a simple anchor-name and position-area approach. The episode demos a tooltip and a popover, discussing browser support (as of August 2026, it's in Chrome and Edge, with Firefox and Safari on the horizon), the shift from JavaScript-based…
How the Web Animations API Replaces JavaScript Animations
In this episode of The Web Development Podcast, Lucas and Luna explore the Web Animations API (WAAPI) and how it's changing the way developers approach animations on the web. They break down a real-world example: animating a shopping cart icon with a bounce effect using just a few lines of JavaScript. The discussion covers key features like the animate() method, playback controls, and compositing with CSS, plus practical tips on when to use WAAPI versus CSS transitions. They also touch on…
How Native CSS Masonry Layout Finally Reached Browsers
In this episode, we explore the long-awaited arrival of native CSS masonry layout, a feature that promises to simplify the way developers build Pinterest-style grids. We break down how the new CSS Grid-based approach works, compare it to JavaScript libraries like Masonry.js, and discuss real-world performance implications. We also cover browser support as of August 2026, including Safari's early adoption, and what it means for your next project. Tune in to learn how to start experimenting with…
How CSS Scroll Snap Improves User Experience
In episode 155 of The Web Development Podcast, Lucas and Luna explore the CSS Scroll Snap API, a feature that transforms scroll-based interactions into smooth, guided experiences. They break down how scroll-snap-type and scroll-snap-align work, discuss alignment and stopping strategies, and compare it to JavaScript-based alternatives like GSAP's ScrollTrigger. The episode digs into real-world use cases—from image carousels to full-screen section navigation—and offers practical tips for…
How CSS Scroll-Driven Animations Replace JavaScript Scroll Effects
In this episode of The Web Development Podcast, Lucas and Luna dive into CSS scroll-driven animations, a native CSS feature that lets developers create scroll-linked effects without JavaScript. They explore the core concepts—scroll progress timelines, view timelines, and animation ranges—and walk through practical examples like parallax scrolling, progress bars, and reveal-on-scroll. The conversation covers browser support as of August 2026, performance considerations, and how this shifts the…
How CSS Nesting Streamlines Modern Stylesheets
In this episode, Lucas and Luna explore how CSS nesting, now supported across all major browsers since late 2023, is changing the way developers write and maintain stylesheets. They trace its evolution from preprocessors like Sass to native browser support, explain the key syntax rules (including the & nesting selector and @nest for complex selectors), and share practical examples of how nesting reduces repetition and improves readability without sacrificing performance. They also discuss…
How the Popover API Simplifies Web Overlays
Lucas and Luna dive into the Popover API, a native browser feature replacing JavaScript-heavy modal, tooltip, and dropdown implementations. They explore how it works, its accessibility benefits, and real-world use cases, from basic popovers to advanced styling with the ::backdrop pseudo-element. The episode also covers browser support, polyfill options, and how the Popover API integrates with other modern CSS features like anchor positioning. By the end, you'll know when to reach for the…
How CSS Font Loading API Redesigns Typography
In this episode, Lucas and Luna explore how the CSS Font Loading API is changing the way web developers handle typography. They discuss the shift from flash-of-invisible-text to more controlled fallback and swap strategies, and how new features like font-size-adjust are improving layout stability. They also introduce a practical example: a simple React hook that uses the Font Loading API to load a custom font and trigger a re-render only when it's ready. The conversation touches on performance…
Why Native CSS Masonry Layout Is Finally Here
CSS masonry layout has been a long-awaited feature for web developers, and in this episode, Lucas and Luna explain why it's now a reality. They break down how the new masonry layout module in CSS Grid simplifies complex, Pinterest-style layouts without JavaScript libraries. The hosts walk through a concrete example: building a responsive gallery with just a few lines of CSS, and discuss the trade-offs compared to JavaScript-based solutions like Masonry.js. They also touch on browser support as…
How CSS Color Functions Simplify Design Tokens
In this episode, Lucas and Luna dive into the CSS Color 4 specification, focusing on the new color functions like oklch(), oklab(), and color-mix(). They explain how these modern functions replace the guesswork of hex and rgb with intuitive perceptually uniform color spaces, making it easier to create accessible, consistent design systems. The discussion covers real-world examples, such as using oklch() to define a brand palette that scales harmoniously and leveraging color-mix() to generate…
How CSS Typed Object Model Replaces Inline Style Parsing
In this episode of The Web Development Podcast, Lucas and Luna dive into the CSS Typed Object Model—the modern API that finally lets developers manipulate styles as typed values instead of string-hacking el.style.left. They walk through a concrete example: animating an element's transform from 'translateX(50px)' in JavaScript, showing how CSSTransformValue and CSS.px(50) remove the gymnastics of parseFloat and regex. They compare it to the old string approach, explain how it unlocks performant…
How CSS Subgrid Solves Nested Grid Alignment
Lucas and Luna explore CSS subgrid, the feature that finally lets nested grid items align with their parent grid. They walk through a real-world pricing-card layout where a subgrid card footer aligns with the tallest column, explain how subgrid differs from a regular grid inside a grid item, and cover browser support as of August 2026. They also touch on when to reach for subgrid versus simpler tools like flexbox, and share practical tips for avoiding common pitfalls. This episode is perfect…
How CSS View Transitions Simplify Page Animations
In this episode of The Web Development Podcast, Lucas and Luna dive into the View Transitions API, a powerful tool that lets developers create smooth, cinematic page transitions without JavaScript. They explore how it works under the hood, why it's built for performance, and how you can start using it today. With practical examples and a look at browser support as of August 2026, they show how this API can replace the hacky animations that were once the norm. Plus, they share a simple way to…
CSS Scoping Simplifies Style Encapsulation
In this episode of The Web Development Podcast, Lucas and Luna dive into the CSS Scoping specification — a native way to encapsulate styles without the baggage of Shadow DOM. They explore how @scope at-rules are changing the game for component styling, solving the age-old problem of style leakage. With real-world examples like styling a blog post's prose or a widget inside a legacy app, they show how scoped styles are more predictable and maintainable. They also discuss the trade-offs versus…
How CSS @property Unlocks Custom Properties
In episode 144 of The Web Development Podcast, Lucas and Luna dive into the CSS @property rule, a feature that transforms custom properties from simple placeholders into typed, animatable, and inheritable building blocks. They explain how @property gives CSS variables superpowers by defining syntax, initial values, and inheritance, and why this matters for smooth animations and design systems. Through concrete examples—like animating a custom property from 0 to 360 degrees for a spinner or…
How the File System Access API Gives Web Apps Native File Power
In this episode, Lucas and Luna explore the File System Access API, a browser feature that lets web apps read and write files directly from the user's file system, bridging the gap between web and native desktop apps. They break down how it works with a concrete example — building a markdown editor that opens local files, edits them, and saves changes with Ctrl+S — and walk through the security model, including permission prompts and the difference between read and write access. They also cover…
How CSS Linear Transitions Enter and Exit the DOM Smoothly
In this episode, Lucas and Luna dive into the new CSS View Transitions API and, more specifically, the linear() easing function that's transforming how developers animate elements entering and leaving the page. They explore a concrete example with a to-do list app, showing how linear() can create snappy, natural motion without the complexity of JavaScript libraries. The conversation touches on the performance benefits, the math behind the easing curve, and how this fits into the broader trend…
How CSS Starting-Style Transitions Entry Animations on First Render
Lucas and Luna explore the new CSS starting-style rule, which finally makes it possible to animate elements from their initial state when they first appear in the DOM. Prior workarounds involved JavaScript hacks or forced reflows. Starting-style lets you define a separate beginning style for the very first transition, enabling clean entry animations for modals, toggles, and dynamic content. The hosts walk through a real example: animating a cart icon in an SPA without flicker. They discuss…
How CSS Cascade Layers End Specificity Wars
Lucas and Luna dive into CSS cascade layers (@layer), a feature that lets developers control style order without specificity hacks. They contrast the old approach of !important and convoluted selectors against a cleaner layered system. Using a real-world example of styling a third-party date picker, they show how @layer can isolate component styles, reset rules, and framework overrides. They discuss browser support (stable since 2022), the four implicit layers (user-agent, user, author layers…
How the View Transitions API Simplifies Page Animations
The View Transitions API lets web developers create smooth, animated transitions between pages or views with just a few lines of CSS. In this episode, Lucas explains how the API works under the hood — from the document-ready promise to the pseudo-element tree — and walks through a real example: transitioning from a product listing to a detail page without the standard white flash. Luna asks about browser support, performance costs, and how to handle users who prefer reduced motion. They also…
How CSS content-visibility Boosts Page Render Performance
Web pages with lots of content can feel sluggish to load because the browser renders everything at once, even parts not visible on screen. Enter CSS content-visibility – a property that tells the browser to skip rendering off-screen elements until they're needed. In this episode, Lucas and Luna break down how content-visibility works, how to pair it with contain-intrinsic-size to prevent layout shifts, and share a real-world example (a busy product listing page) where it cut initial render time…
CSS Container Queries Fix Component Responsiveness
Episode 137 of The Web Development Podcast dives into CSS Container Queries, a feature that lets components respond to their parent container's size rather than the viewport. Lucas and Luna walk through a real dashboard example with reusable chart and table widgets, explaining the `container-type` and `container-name` properties, the `@container` rule, and how this shifts responsive design from page-level to component-level thinking. They also touch on browser support, caveats like scroll…
CSS Anchor Positioning Eliminates JavaScript Tooltip Dependencies
In this episode of The Web Development Podcast with Fexingo, Lucas and Luna dive deep into the CSS Anchor Positioning API—a game-changing feature that lets you position elements relative to other elements entirely in CSS, without a single line of JavaScript. They walk through a concrete tooltip example using the anchor() function and @position-try rule, explain how it compares to libraries like Popper.js, and discuss browser support as of July 2026 (Chromium stable, Firefox flagged, Safari…
How CSS Separate Transform Properties Simplify Animations
Episode 135 explores the CSS individual transform properties: translate, rotate, and scale. These allow you to animate each transform independently, eliminating the need to manage the entire transform string and enabling smoother, more flexible animations. Lucas and Luna discuss concrete use cases like hover effects and load animations, compare browser support (now above 94%), and share performance tips. They also explain why this approach is easier to read and maintain than the traditional…
Showing the latest 50 episodes. The full archive of 184 is on Apple Podcasts, Spotify and every major podcast app — or via the RSS feed above.