The Web Development Podcast with Fexingo: Frontend, Backend, and Modern Web Stack

Lucas and Luna dive into a subtle but common cause of memory leaks in React apps: closures that capture stale references. They trace the problem from a real-world case at a mid-size SaaS company whose dashboard crashed after 15 minutes of use. Lucas explains how closures work in JavaScript, why React's hooks make the issue worse, and how the team fixed it with useRef and useCallback. Luna brings d...

Episode 53 of The Web Development Podcast dives into a silent performance killer in modern web applications: empty async functions generated by TypeScript's `downlevelIteration` and `importHelpers` settings. Lucas and Luna trace the problem from a single misconfigured `tsconfig.json` to a 12KB bloat in a production bundle, using a real-world case from a fintech startup's dashboard. They explain wh...

Lucas and Luna uncover a common performance drag in modern web apps: shipping entire icon libraries — often hundreds of SVGs — when only a handful are used. They trace the issue from webpack bundling defaults to tree-shaking failures, using Material Icons and Font Awesome as concrete examples. They show how a typical React app with a 20-icon menu still bundles 2,500+ unused SVGs, adding 150KB to t...

Episode 51 of The Web Development Podcast: Lucas and Luna investigate why TypeScript enums bloat your JavaScript bundle by 5KB or more. They walk through the actual compiled output — a reverse-lookup object — and compare it to simpler alternatives like const objects and union types. Using real-world examples from a 2026 React dashboard, they measure the bundle impact, discuss when an enum is actua...

Lucas and Luna explore the hidden assumption that has broken countless web apps: persistent connectivity. They dig into the real-world failure of a major retail site's checkout flow when a user's train entered a tunnel, and walk through the surprisingly simple service-worker pattern that fixes it. Along the way, they bust the myth that offline-first means 'no internet' — it actually means graceful...

Lucas and Luna dive into a silent productivity killer: memory leaks in webpack-dev-server that accumulate over long development sessions. They trace the problem to unclosed WebSocket connections from Hot Module Replacement, showing how a single missed cleanup in the dev server's event loop can balloon RAM usage to 4GB after eight hours. The episode walks through real debugging steps using Chrome D...

Episode 48 of The Web Development Podcast dives into a silent performance killer hiding in plain sight: your favicon. Lucas and Luna explain how a missing or slow favicon.ico can block DNS prefetch, delay initial page loads, and cause browsers to queue up extra network requests before your HTML even renders. They walk through a real example from a major news site that dropped first-paint time by 3...

Ever built a perfect CSS Grid layout on a desktop screen only to have it blow past the viewport on a phone? In this episode, Lucas and Luna dig into a specific example: a three-column dashboard grid that looks fine at 1200 pixels wide but triggers a horizontal scrollbar at 480 pixels. They trace the root cause to a common combination of fixed column widths, implicit grid tracks, and the min-width...

In this episode, Lucas and Luna dig into a specific problem that many developers encounter: a bloated Tailwind CSS production bundle. They trace the issue to unused utility classes generated by Tailwind's Just-in-Time engine, explain why the default content configuration often misses important template paths, and walk through a concrete fix using the `content` option to reduce bundle size from 300...

In this episode, Lucas and Luna dive deep into CSS Container Queries — the modern alternative to media queries for responsive design. They walk through a concrete example: a reusable card component that breaks in a sidebar layout with traditional media queries because it responds to the viewport, not its container. They show how Container Queries fix this by querying the parent's inline size inste...

Episode 44 of The Web Development Podcast with Fexingo: Lucas and Luna dig into a concrete problem that plagues static sites on slow networks — the hidden cost of JavaScript frameworks that ship hundreds of kilobytes of runtime code even for a simple blog. Using the real-world example of a site that had a 1.2 MB JavaScript bundle delivering just four paragraphs of text, they walk through how the b...

Episode 43 of The Web Development Podcast with Fexingo dives into a hidden performance cost that rarely gets discussed: the battery impact of service workers on mobile devices. Lucas and Luna break down a real-world example from a major news site where a poorly optimized service worker was waking the radio chip every 30 seconds, draining the battery twice as fast. They explain what causes this — e...

Episode 42 of The Web Development Podcast digs into a surprising performance regression: Webpack builds running 40% slower on Apple's new M4 Macs compared to M1 and M2 machines. Lucas and Luna trace the root cause to a change in the ARM microarchitecture's memory prefetcher behavior, which breaks assumptions in the terser-webpack-plugin's parallel worker hot-path. They walk through the Node.js wor...

Episode 41 of The Web Development Podcast with Fexingo digs into HTTP caching gone wrong. Lucas explains why most web apps treat JavaScript bundles as immutable when they aren't, causing users to re-download huge chunks of code on every visit. He walks through the difference between cache-control headers like 'no-cache' and 'no-store', explains content hashing done right, and shows how one misconf...

Server-side rendering should make your app faster, not slower. But if you're caching rendered pages for even a few seconds, you might be shipping stale content to users — and Google knows it. In this episode, Lucas walks through a real case: a content-heavy e-commerce site where caching SSR output for 10 seconds caused a 12% drop in conversion as users saw outdated inventory. He explains the diffe...

In this episode, Lucas and Luna dive into the messy reality of Web Vitals measurement. Most developers think their Core Web Vitals scores are accurate, but hidden sampling biases, single-page app quirks, and lab-vs-field mismatches lead to wildly misleading data. Lucas breaks down a real case where a team's Lighthouse score showed a perfect 100, yet real users experienced LCP times over 4 seconds....

Episode 38 of The Web Development Podcast with Fexingo. Lucas and Luna dig into a specific performance problem that plagues countless web apps: the seemingly trivial dropdown menu that lags by 200 milliseconds. They trace the root cause through re-renders, layout thrashing, and event delegation gone wrong, then walk through a practical fix using passive event listeners and CSS containment. Along t...

Lucas and Luna reveal how misconfigured source maps in production builds leak internal code paths, API endpoints, and even credentials to anyone who opens browser dev tools. They walk through a real incident where a major e-commerce site exposed its entire internal admin panel structure via a .map file served from their CDN. The episode covers how to audit your own source map exposure, the differe...

Episode 36 of The Web Development Podcast with Fexingo. Lucas and Luna dive into the hidden costs of accessibility overlays — third-party widgets that claim to fix web accessibility with one line of JavaScript. They break down a real-world case: an e-commerce site that added an overlay and saw its Lighthouse accessibility score drop by 15 points, while screen reader users reported broken navigatio...

Lucas and Luna break down a common performance trap in React applications: excessive re-renders on initial page load. They trace the problem from a developer's console warning about 22 renders in under two seconds to the root cause — misuse of useEffect and stale closure patterns. Using a concrete example of a dashboard app fetching three unrelated API endpoints, they show how improper state batch...

Episode 34 of The Web Development Podcast with Fexingo dives into a subtle but costly performance trap in monorepo setups: NPM workspaces' dependency hoisting logic that silently duplicates installs across CI cache layers. Lucas breaks down a real-world case where a 15-package monorepo's CI pipeline took 11 minutes per build—almost double what it should be—because npm's hoisting algorithm didn't p...

On this episode of The Web Development Podcast, Lucas and Luna dig into a counterintuitive database performance trap: the index that looks helpful on paper but quietly degrades your write throughput and even some reads. Lucas walks through a real-world case from a mid-size e-commerce platform where adding a composite index on order status and created_at made the nightly batch job run 40 percent sl...

Episode 32 of The Web Development Podcast tackles silent data corruption in web applications — the bug that doesn't crash, doesn't log, but slowly poisons your database. Lucas and Luna walk through a real-world case: an e-commerce site where price rounding errors cost $80,000 before anyone noticed. They explain how JavaScript's `Number` type behaves in financial math, why SQLite and Postgres handl...

In this episode, Lucas and Luna dive into a common but often invisible performance bug in GraphQL APIs: the N+1 query problem in resolvers. They break down how a single GraphQL query can trigger dozens of redundant database calls, using a concrete example of a blog with authors and comments. Lucas explains batching and DataLoader as a fix, walks through the mechanics, and shares a real-world case...

Episode 30 of The Web Development Podcast with Fexingo dives into a common but invisible backend problem: missing WebSocket backpressure. Lucas and Luna explain why most WebSocket servers lack built-in flow control, how this silently grows memory buffers until a crash, and what a real-world fix looks like. They walk through a concrete case: a chat server that held 200MB of pending messages per cli...