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

Lucas and Luna dive into server-side rendering's hidden bottleneck: HTML streaming. They break down why most developers see Time to First Byte balloon from 200ms to over a second, explaining how traditional render-to-string blocks the response until the entire page is generated. The episode centers on a real-world case: a SaaS dashboard that dropped from 1.2s TTFB to 340ms by switching to React's...

WebSockets power real-time features like live chat and dashboards, but every open connection can silently leak memory in your Node.js backend. This episode walks through a real case from a fintech startup whose dashboard latency doubled after 200 concurrent users. Lucas explains how event listeners, closure references, and unresolved promises inside WebSocket handlers create memory leaks that garb...

Rate limiters are supposed to protect your API, but they often introduce surprising latency spikes. In this episode, Lucas and Luna dig into a real-world case: a SaaS company that added a Redis-based rate limiter and saw p99 response times jump from 120ms to over 900ms. They trace the problem to a subtle queue buildup under burst traffic, then walk through three practical solutions — sliding windo...

In this episode of The Web Development Podcast with Fexingo, Lucas and Luna dive into the overlooked impact of image file formats on web performance. They compare WebP, AVIF, and JPEG XL, breaking down real-world compression ratios and browser support. Using a 1.2 MB photo as a case study, they show how switching from JPEG to AVIF can cut size by 63 percent while preserving quality, but also warn...

Lucas and Luna dive into the overlooked art of error messages in web development. They discuss a real-world case where a major booking site lost 12% of conversions due to confusing error states, and how a simple rewrite of error copy and UI patterns recovered 8% of that loss. The episode covers key principles for writing clear, action-oriented error messages, the importance of inline validation vs...

Lucas and Luna dig into the hidden bloat that makes your CSS bundle 400KB or more, slowing down initial page load. They break down a real-world example from a mid-size e‑commerce site where unused styles, overly specific selectors, and duplicate declarations added 300KB of waste. Lucas explains how modern tools like PurgeCSS and PostCSS can strip dead weight, while Luna points out the trap of CSS-...

Episode 23 of The Web Development Podcast with Fexingo dives into a hidden performance killer for teams using monorepos: the innocent-looking dependency graph that makes CI pipelines run 3x slower than necessary. Lucas and Luna walk through a real case from a 40-developer team at a mid-size SaaS company, where a single shared utility library caused cascading rebuilds every time any file changed. T...

Episode 22 digs into the specific developer-experience gap between Vite and Webpack. Lucas and Luna break down why Vite's native-ESM dev server starts in under a second while Webpack takes 3–5 seconds for a medium project — and what that difference means for daily developer flow. They walk through the cold-start vs. warm-start mechanics, how esbuild pre-bundling slashes the initial handshake, and...

Episode 21 of The Web Development Podcast digs into the hidden cost of third-party scripts. Lucas and Luna walk through a real case: a mid-size e-commerce site that unknowingly loaded 14 widgets — analytics, chat, A/B testing, ad retargeting — and saw its median LCP balloon to 8.2 seconds. They explain why each script is a synchronous bottleneck, how request chains amplify latency, and the one met...

Episode 20 of The Web Development Podcast with Fexingo digs into a hidden performance killer: service workers that silently delay first paint. Lucas and Luna break down how a single misconfigured 'install' event listener can add 600 milliseconds of blocking time on initial load, using a real case from a mid-sized e-commerce site that saw a 12 percent bounce rate drop after fixing it. They explain...

Episode 19 of The Web Development Podcast with Fexingo digs into a silent performance killer: webpack cache invalidation. Lucas and Luna explore why your incremental builds are rebuilding entire bundles from scratch, how a simple loader misconfiguration can throw away cache hits, and the one trick — deterministic hashing with content hashes — that shaved 60 seconds off a real-world CI pipeline. Th...

Lucas and Luna tackle a silent performance killer in Node.js applications: memory leaks that don't crash your app but gradually consume CPU and degrade throughput. They walk through a real case where a forgotten `setInterval` combined with a closure referencing a large data structure caused a 40 percent CPU increase over three weeks. You'll learn how to spot the pattern using heap snapshots and wh...

Lucas and Luna dig into a common but invisible performance drain: unused npm dependencies. They walk through a real case where a startup's production bundle included 3,000 unused packages, adding 2MB to the JavaScript payload and slowing startup time by 1.2 seconds. They explain how tree-shaking fails with side-effect flags, how tools like depcheck and webpack-bundle-analyzer surface the bloat, an...

Episode 16 of The Web Development Podcast uncovers a quiet but costly problem: GraphQL schemas that drift out of sync with frontend expectations. Lucas and Luna walk through a real-world case where a single renamed field in a GraphQL resolver caused a $150,000 production outage for an e-commerce startup. They explain how schema-first development, contract testing, and tools like GraphQL Inspector...

Episode 15 of The Web Development Podcast with Fexingo dives into a silent killer in modern web apps: background jobs that fail silently. Lucas and Luna explore a real case where a fintech startup lost $45,000 in transaction fees because a Sidekiq worker crashed on malformed JSON with zero logs. They break down why most error monitoring tools miss silent failures, how to use structured logging wit...

Episode 14 of The Web Development Podcast dives into a hidden performance killer: your TypeScript configuration. Lucas and Luna explore how default tsconfig settings—like enabling strict mode without incremental builds, or using path aliases without baseUrl—can add minutes to compile times. They walk through a real-world example from a mid-stage startup whose CI pipeline was taking over twelve min...

Lucas and Luna dive into the hidden gaps in web accessibility audits. Most teams focus on automated checks for contrast ratios and alt text, but miss the deeper UX failures: keyboard traps, confusing focus indicators, and screen reader context loss. Lucas reveals how a major e-commerce site found 70% of its accessibility issues only through manual testing with assistive technology — and how a sing...

Episode 12 of The Web Development Podcast digs into a silent killer of CI pipelines: the package lockfile. Lucas and Luna trace how a single mismatched lockfile—generated by different npm versions—caused a 12-person team to lose three full developer-days to phantom dependency failures. They walk through why lockfiles like package-lock.json and yarn.lock aren't optional, how to audit them for integ...

Episode 11 of The Web Development Podcast digs into the overlooked cost of bloated Docker images. Lucas and Luna explain how a single unnecessary system dependency can balloon an image from 200MB to over 2GB, slowing deployments and eating bandwidth. They walk through a real case where a startup's CI pipeline was taking 12 minutes per build because of an Alpine vs. Debian base image choice and unp...

Episode 10 of The Web Development Podcast dives into a pervasive performance pitfall: aggressive lazy loading that actually degrades user experience. Lucas and Luna examine a real-world case where a major e-commerce site saw its Largest Contentful Paint spike from 1.2 seconds to 4.8 seconds after implementing an off-the-shelf lazy loading library for images and iframes. They break down the mechani...

Lucas and Luna dig into the real reason many web apps feel sluggish on mobile devices: the Long Task problem in the browser's main thread. Using a concrete example — a React dashboard that freezes for 400 milliseconds when fetching user data — they explain how long tasks block the event loop, wrecking interaction readiness and First Input Delay. Lucas walks through the Chrome DevTools Performance...

Lucas and Luna dig into a common but overlooked performance bottleneck in modern web development: the build pipeline. They break down why incremental builds in Next.js can slow to a crawl, using the real-world example of a SaaS startup that saw its CI/CD pipeline balloon from 90 seconds to over 4 minutes after adding just a few dynamic routes. Lucas explains how React Server Components, static gen...

Lucas and Luna dive into the hidden cost of JavaScript framework updates on Core Web Vitals. Using the real-world case of a mid-size e-commerce site that saw its Largest Contentful Paint (LCP) jump from 2.1 seconds to 4.7 seconds after a routine React 18 to React 19 migration, they unpack what actually happened under the hood. They walk through the specific culprits: concurrent rendering introduci...

Episode 6 dives into a hidden cost of modern web development: image delivery. Lucas and Luna dissect a real case where a mid-market e-commerce platform was bleeding $3,200 a month on image CDN costs — not from traffic spikes, but from suboptimal configuration. They walk through how oversized origin images, missing cache-control headers, and unnecessary transformations compound into a six-figure an...

Episode 5 of The Web Development Podcast investigates a silent performance bottleneck plaguing modern web apps: connection setup overhead. Lucas and Luna walk through a real case from a mid-size SaaS company where every API call spent 1.8 seconds in TCP handshake and TLS negotiation before sending a single byte. They explain why this happens, how HTTP/2 multiplexing helps but doesn't solve it, and...