PODCAST · business
The Web Development Podcast with Fexingo: Frontend, Backend, and Modern Web Stack
by Fexingo
The Web Development Podcast with Fexingo is Lucas and Luna's weekly exploration of the modern web stack, from frontend frameworks to backend infrastructure. Each episode dissects a specific technology or workflow — think React Server Components vs. traditional SSR, the economics of cloud-native databases, or the practical trade-offs of a micro-frontend architecture — with real benchmarks and open-source case studies. Lucas, a former full-stack engineer turned journalist, asks the hard questions about developer productivity and deployment costs, while Luna, a senior architect in a high-traffic fintech org, brings battle-tested insight into scaling and maintainability. Their conversations avoid hype: no breathless takes on the latest framework until they've stress-tested it against production data. The listener is a working developer (mid-level to senior) who needs to make informed decisions about tooling, architecture, and team practices. Expect arguments backed by numbers — like Redis
Episodes
-
How The Web Became Too Heavy To Load
On October 13, 2026, the average website payload has ballooned to nearly two megabytes, driven by a silent crisis in JavaScript bundle sizes. We dissect how major e-commerce platforms and SaaS providers are accidentally turning performance into a luxury good, leaving mobile users behind. Lucas…
more -
The Hidden Cost of Web Fonts on Bandwidth and Performance
Web fonts are a staple of modern design, but they carry a silent tax on performance that most developers overlook. In this episode, we examine the specific mechanics of font loading, from the initial HTTP request to the render-blocking nature of critical CSS. We break down how self-hosting versus...
-
How Micro Frontends Solve Monolith Complexity
Enterprise web apps are collapsing under their own weight, and monolithic codebases are the primary culprit. In this episode, we examine how micro frontends break large applications into independent, deployable units. We look at specific implementation patterns like module federation and shell...
-
The Real Cost of JavaScript Frameworks
We dissect the hidden performance tax of modern frontend frameworks by analyzing a real-world case study of a major e-commerce platform that switched from a monolithic React bundle to a modular, server-driven approach. Lucas and Luna break down the exact metrics: how reducing initial JavaScript...
-
How Browser Privacy Sandboxes Are Reshaping Web Tracking
We dig into the mechanics of browser privacy sandboxes and how they are quietly dismantling the ad-tech stack. Lucas walks through the specific technical shift from third-party cookie tracking to group-based fingerprinting, while Luna challenges whether these changes actually protect user data or...
-
How The Web Platform Is Killing Framework Fatigue
Lucas and Luna explore how the native web platform is rapidly absorbing the features that once required heavy JavaScript frameworks. With CSS nesting, container queries, and view transitions now standard in major browsers, developers are finding they can build complex interfaces with less code…
more -
How WebAssembly Is Changing The Browser
We look at why browsers are no longer just JavaScript engines. Lucas and Luna discuss how WebAssembly lets developers run near-native code in the browser, changing everything from video editing to CAD tools. We explore the real-world shift away from heavy client-side frameworks toward compiled...
-
How Web Vitals Redesign UX Strategy
We examine how Core Web Vitals shifted from a ranking signal to the primary metric for user experience design. Lucas and Luna discuss the specific impact of Largest Contentful Paint on conversion rates, the subjective nature of Cumulative Layout Shift, and why Interaction to Next Paint is…
more -
Why Your Website Slows Down With Every Third Party Script
Most web developers treat third-party scripts as harmless add-ons, but the cumulative cost of analytics, chat widgets, and ad trackers is quietly degrading performance. In this episode, Lucas and Luna break down the real data behind script bloat, using a case study of a mid-sized e-commerce site...
-
The Silent Tax of Third Party Scripts on Web Speed
Third party scripts quietly dominate modern web pages, often consuming half the total JavaScript downloaded by a browser. This episode dissects how ad tech, analytics tools, and chat widgets create render-blocking bottlenecks that hurt user experience and search rankings. We look at specific data...
-
How AI Agents Are Rewriting Web Workflows
We break down the shift from static web pages to dynamic, agent-driven interfaces using Stripe's recent API changes and Vercel's new AI SDK. Lucas and Luna explore how backend logic is moving closer to the user, what that means for developer productivity in October 2026, and why the traditional...
-
How CSS View Transitions Modernize Web Navigation
We explore how modern browsers are replacing jarring page jumps with smooth, cinematic view transitions. Using the new View Transitions API, developers can create native-feeling animations between routes without heavy JavaScript libraries. We break down the specific implementation details…
more -
The Hidden Cost of Third Party Scripts
In this episode, we break down the structural fragility of modern web applications caused by third-party JavaScript dependencies. We look at how a single vendor failure can cascade into application downtime, using the 2021 Cloudflare outage as a primary case study to illustrate supply chain risk…
more -
How The Web Platform Killed Framework Fatigue
We dig into the surprising rise of islands architecture and how modern browsers are handling state management natively, making heavy client-side bundles obsolete. Lucas breaks down why Shopify’s Polaris design system is shifting toward lightweight hydration, while Luna explores the real-world...
-
How Server Sent Events Revolutionize Real-Time Web Apps
We dive into the quiet dominance of Server-Sent Events as the preferred protocol for real-time data streaming in modern web applications. Lucas and Luna explore why SSE has outpaced WebSockets for many use cases, examining its one-way reliability, automatic reconnection logic, and seamless...
-
How The Web Made You Pay For Your Own Data
We dig into the hidden architecture of modern web tracking and how third-party cookies are being phased out by major browsers. Lucas breaks down the technical shift from centralized tracking to privacy sandbox solutions, while Luna explores the economic incentives driving this change. This…
more -
The Hidden Cost of Web Fonts on Bandwidth and Performance
Web fonts have become the silent bandwidth hogs of modern websites, often consuming more data than the HTML or images that frame them. In this episode, we break down the specific mechanics of font loading, the hidden costs of variable weight files, and why your favorite site might be slowing you...
-
How Subresource Integrity Protects Web Scripts
We look at how Subresource Integrity, or SRI, acts as a cryptographic passport for external scripts on the web. Most developers load libraries like jQuery or analytics tools from third-party CDNs without verifying their content hasn't been tampered with. We examine why adding a single integrity...
-
How Server Components Changed React Architecture
We break down the fundamental shift from client-side rendering to server components in modern web development. Using a recent case study of a major e-commerce platform, we explore how moving heavy JavaScript logic to the server reduced initial load times by over sixty percent and improved search...
-
How Edge Functions Are Rewriting Web Architecture
The shift from centralized server logic to edge computing is fundamentally altering how we build modern web applications. We examine how platforms like Cloudflare Workers and Vercel Edge Functions are moving code closer to the user, reducing latency for global audiences. The conversation drills...
-
How Web Components Solve Enterprise Code Chaos
Enterprise frontend teams are drowning in duplicate logic. We look at how a major logistics firm replaced their tangled React spaghetti with standard Web Components, cutting bundle size by forty percent and giving designers direct control over UI behavior. This episode breaks down the shift from...
-
How CSS Container Queries Fix Layout Logic
We explore how container queries are solving the stubborn problem of responsive design by letting components adapt to their own space rather than just the viewport. We look at why this shifts power from global layout rules to individual widgets, using a real-world example of a card component that...
-
How The Web Platform Is Killing Framework Fatigue
We explore how native browser capabilities like CSS Nesting, View Transitions, and Container Queries are finally making complex JavaScript frameworks optional rather than mandatory. Lucas and Luna break down the specific technical shifts happening in September 2026 that allow developers to build...
-
How Browser Rendering Pipelines Changed Web Speed
We dive into the often-overlooked browser rendering pipeline, specifically how modern browsers handle layout, paint, and composite stages to deliver smooth user experiences. Lucas breaks down why your site feels sluggish despite fast server responses, focusing on the critical path of DOM...
-
How Web Workers Make JavaScript Nonblocking
We break down the hidden engine behind smooth user interfaces: Web Workers. Lucas and Luna explore how offloading heavy computation to background threads prevents browser freezing, using a real-world example of image processing in the browser. We look at the specific performance gains when moving...
-
How The Web Platform Killed Framework Fatigue
Lucas and Luna dissect why the modern web stack is finally shedding its dependency on heavy JavaScript frameworks. They examine the shift toward native browser capabilities, server-side rendering defaults, and component isolation techniques that reduce bundle sizes by up to forty percent. With a...
-
How Web Fonts Are Stealing Your Bandwidth
Web fonts have quietly become the largest asset on most pages, often consuming more bandwidth than images. We look at how variable fonts and modern loading strategies like font-display swap are reshaping performance. Lucas and Luna break down why your typography choices matter for Core Web Vitals...
-
The Silent Cost of JavaScript Bloat on Web Performance
We dissect the hidden performance tax of modern JavaScript frameworks by examining a specific case study of a major e-commerce platform that reduced bundle size by forty percent without changing its user interface. Lucas and Luna explore how tree shaking, code splitting, and framework selection...
-
How The Web Platform Killed Framework Fatigue
We explore the accelerating shift away from heavy JavaScript frameworks toward native web standards. With modern browsers now supporting features like CSS Container Queries, View Transitions, and robust Shadow DOM encapsulation, developers are finding they can build complex, high-performance...
-
How The Web Platform Is Killing Framework Fatigue
In this episode, Lucas and Luna explore how native web standards like Shadow DOM, Custom Elements, and Declarative Shadow DOM are finally replacing the heavy lifting previously done by JavaScript frameworks. They examine a specific case where a major e-commerce platform reduced its initial...
-
How WebAssembly Makes the Browser Feel Native
In this episode, Lucas and Luna explore how WebAssembly is transforming the web from a document display layer into a high-performance computing environment. They look at specific use cases like browser-based video editing and complex data visualization where JavaScript alone hits a wall. The...
-
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...
-
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...
-
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...
-
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...
-
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...
-
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...
-
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…
more -
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...
-
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...
-
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...
-
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...
-
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...
-
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...
-
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...
-
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…
more -
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...
-
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…
more -
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...
-
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...
We're indexing this podcast's transcripts for the first time — this can take a minute or two. We'll show results as soon as they're ready.
No matches for "" in this podcast's transcripts.
No topics indexed yet for this podcast.
Loading reviews...
ABOUT THIS SHOW
The Web Development Podcast with Fexingo is Lucas and Luna's weekly exploration of the modern web stack, from frontend frameworks to backend infrastructure. Each episode dissects a specific technology or workflow — think React Server Components vs. traditional SSR, the economics of cloud-native databases, or the practical trade-offs of a micro-frontend architecture — with real benchmarks and open-source case studies. Lucas, a former full-stack engineer turned journalist, asks the hard questions about developer productivity and deployment costs, while Luna, a senior architect in a high-traffic fintech org, brings battle-tested insight into scaling and maintainability. Their conversations avoid hype: no breathless takes on the latest framework until they've stress-tested it against production data. The listener is a working developer (mid-level to senior) who needs to make informed decisions about tooling, architecture, and team practices. Expect arguments backed by numbers — like Redis
HOSTED BY
Fexingo
CATEGORIES
Loading similar podcasts...
Frequently Asked Questions
How many episodes does The Web Development Podcast with Fexingo: Frontend, Backend, and Modern Web Stack have?
The Web Development Podcast with Fexingo: Frontend, Backend, and Modern Web Stack currently has 183 episodes available on PodParley. New episodes are automatically indexed when they're published to the podcast feed.
What is The Web Development Podcast with Fexingo: Frontend, Backend, and Modern Web Stack about?
The Web Development Podcast with Fexingo is Lucas and Luna's weekly exploration of the modern web stack, from frontend frameworks to backend infrastructure. Each episode dissects a specific technology or workflow — think React Server Components vs. traditional SSR, the economics of cloud-native...
How often does The Web Development Podcast with Fexingo: Frontend, Backend, and Modern Web Stack release new episodes?
The Web Development Podcast with Fexingo: Frontend, Backend, and Modern Web Stack publishes regularly with 183 episodes available. Check the episode list for the typical release schedule.
Where can I listen to The Web Development Podcast with Fexingo: Frontend, Backend, and Modern Web Stack?
You can listen to The Web Development Podcast with Fexingo: Frontend, Backend, and Modern Web Stack on PodParley by clicking any episode. We provide an embedded audio player for direct listening, and you can also subscribe via your preferred podcast app using the RSS feed.
Who hosts The Web Development Podcast with Fexingo: Frontend, Backend, and Modern Web Stack?
The Web Development Podcast with Fexingo: Frontend, Backend, and Modern Web Stack is created and hosted by Fexingo.
URL copied to clipboard!