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

Episode 60 of The Web Development Podcast digs into a hidden privacy & performance issue: third-party scripts that exfiltrate user data from your web app in plain sight. Lucas and Luna use a real-world case—a mock e-commerce site loading a tracking script from a seemingly reputable CDN—to show how a single fetch call can silently leak browsing history, cart contents, and even keystrokes. They walk through code examples using the Network tab, explain how subresource integrity (SRI) fails when scripts are dynamically appended, and demonstrate a fix using Content Security Policy (CSP) with script-src and nonce. The episode also covers how to audit existing dependencies with tools like Lighthouse and Sentry. No alarmism—just practical steps to protect users. If today's tech conversation gave you something usable, consider supporting the show at buy me a coffee dot com slash fexingo. #ThirdPartyScripts #DataLeak #WebSecurity #ContentSecurityPolicy #SubresourceIntegrity #CSP #SRI #Privacy #JavaScript #WebDev #Frontend #Performance #Audit #Lighthouse #Sentry #Technology #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

Lucas and Luna dig into the hidden flaws of Google's Lighthouse performance score — how the weightings misalign with real user experience, why a perfect 100 can still feel slow, and what tools like WebPageTest and the Chrome User Experience Report actually tell you. They break down the specific scoring categories, the gap between lab data and field data, and practical steps to audit your audits. If you've ever chased a green Lighthouse badge only to wonder why your site still drags, this episode is your reality check. #Lighthouse #WebPerformance #CoreWebVitals #PerformanceAuditing #LabVsField #Frontend #WebDev #Tech #FexingoBusiness #BusinessPodcast #WebDevelopmentPodcastWithFexingo #LucasAndLuna #PerformanceScore #WebPageTest #CrUX #SiteSpeed #SEO #DeveloperTools Keep every episode free: buymeacoffee.com/fexingo

Episode 58 of The Web Development Podcast: Lucas and Luna dive into the hidden cost of images on web performance. They explore why a single unoptimized hero image can add seconds to load time, how modern formats like AVIF and WebP compare, and why responsive images with srcset and sizes attributes are still underused. With real numbers and a walkthrough of Lighthouse audits, they show how simple fixes can cut image payload by 60% or more. Plus, a quick behind-the-scenes on how listener support keeps the show ad-free. Perfect for frontend developers and site owners who want faster pages without sacrificing quality. #WebPerformance #ImageOptimization #AVIF #WebP #Lighthouse #CoreWebVitals #ResponsiveImages #srcset #SizesAttribute #LazyLoading #Technology #Frontend #WebDev #FexingoBusiness #BusinessPodcast #WebDevelopment #PerformanceBudget #ImageCompression Keep every episode free: buymeacoffee.com/fexingo

Lucas and Luna dig into a quietly pervasive issue in modern NextJS apps: server actions that inadvertently expose internal API endpoints, database schemas, or even PII through client-server boundary leaks. They walk through a real-world example from a fintech startup's recent security audit, showing how a simple form action can leak your entire Prisma schema, and explain the one-line fix most teams miss. Touching on framework design trade-offs, Vercel's stance, and the broader trend of server components blurring the line between client and server, this episode gives you a concrete audit checklist for your own codebase. #NextJS #ServerActions #WebSecurity #DataLeakage #ReactServerComponents #Vercel #Prisma #APILeak #FrontendSecurity #WebDevelopment #Technology #FexingoBusiness #BusinessPodcast #LucasAndLuna #WebDevPodcast #Fintech #CodingBestPractices #BundleAnalysis Keep every episode free: buymeacoffee.com/fexingo

In this episode, Lucas and Luna dig into one of the most insidious performance bugs in modern web apps: memory leaks caused by JavaScript closures. They break down how closures work under the hood, why they can hold onto references long after you think they're gone, and real-world examples like React's useEffect and event listeners. You'll learn practical patterns to avoid accidental retention, how to use WeakMap and WeakRef, and why Chrome DevTools memory snapshots are your best friend. If you've ever seen a page slow down after a few minutes, this episode explains why and how to fix it for good. #JavaScript #Closures #MemoryLeak #WebPerformance #React #DevTools #Frontend #Backend #Technology #WebDevelopmentPodcast #Fexingo #FexingoBusiness #BusinessPodcast #Episode56 #MemoryManagement #ChromeDevTools #WeakRef #EventListeners Keep every episode free: buymeacoffee.com/fexingo

Lucas and Luna tackle a surprisingly common web performance issue: images loading twice in the browser. They break down the root cause—unoptimized responsive image markup and missing size attributes—and walk through concrete fixes using srcset, sizes, and lazy loading. Along the way, they share real-world data: a typical media-heavy site wastes over 200KB per page load on duplicate image requests. Perfect for any developer who's ever seen their network tab full of 200s for the same image file. #WebPerformance #ImageOptimization #ResponsiveImages #Srcset #SizesAttribute #LazyLoading #Frontend #WebDev #PageSpeed #CoreWebVitals #LCP #CLS #ChromeDevTools #Technology #WebDevelopment #FexingoBusiness #BusinessPodcast #Fexingo Keep every episode free: buymeacoffee.com/fexingo

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 data from Chrome DevTools memory profiling showing a 200MB leak in under an hour. The episode ends with a practical checklist for auditing your own app for closure-related leaks. A short, honest mention of listener support via buy me a coffee dot com slash fexingo keeps the show ad-free. #React #MemoryLeak #JavaScriptClosures #WebPerformance #Hooks #UseRef #UseCallback #ChromeDevTools #SaaS #Frontend #Technology #FexingoBusiness #BusinessPodcast #WebDev #Debugging #PerformanceOptimization #GarbageCollection #ReactHooks Keep every episode free: buymeacoffee.com/fexingo

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 why Babel and TypeScript disagree on async generator transpilation, how unused `__awaiter` helpers accumulate, and exactly which webpack analyzer tool surfaces the issue. Listeners walk away with a concrete checklist: two TypeScript compiler flags to toggle, one webpack plugin to add, and a 30-second Lighthouse audit step that catches this pattern. No abstract theory — just a fix that drops bundle size by 8 percent on a typical React app. #TypeScript #Webpack #BundleOptimization #AsyncFunctions #DownlevelIteration #JavaScript #WebPerformance #Lighthouse #Babel #TreeShaking #Technology #WebDevelopment #FexingoBusiness #BusinessPodcast #Episode53 #Fintech #WebDevTips #CodeBloat Keep every episode free: buymeacoffee.com/fexingo

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 the initial load. The episode explores automated solutions: icon subsetting with SVGO-based build plugins, dynamic imports with icon-loading strategies, and lint rules that flag unused icon imports. Listeners learn one specific fix they can apply today to shave seconds off their Lighthouse performance score and reduce bandwidth by 30 percent. #WebPerformance #Webpack #SVG #IconBundles #TreeShaking #BundleSize #FrontendOptimization #MaterialIcons #FontAwesome #SVGO #Lighthouse #React #BuildTools #Technology #WebDev #FexingoBusiness #BusinessPodcast #Fexingo Keep every episode free: buymeacoffee.com/fexingo

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 actually worth the cost, and show how tree-shaking fails on most enum patterns. By the end, you'll know exactly when to reach for an enum and when to use a 50-byte alternative. Plus: a quick note on how listener support keeps this show ad-free. #TypeScript #JavaScript #BundleSize #WebPerformance #Frontend #React #TreeShaking #Coding #WebDev #FexingoTechnology #TechnologyPodcast #SoftwareEngineering #WebDevelopmentPodcast #Enum #ConstObject #UnionType #BuildOptimization #CodeReview #TypeScript #JavaScript #BundleSize #WebPerformance #Frontend #React #TreeShaking #Coding #WebDev #FexingoTechnology #TechnologyPodcast #SoftwareEngineering #WebDevelopmentPodcast #Enum #ConstObject #UnionType #BuildOptimization #CodeReview Keep every episode free: buymeacoffee.com/fexingo

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 degradation when the network blips. With browser APIs like CacheStorage and Background Sync, you can build apps that don't silently lose user data. The episode ends with a practical tip: test your app with a 3-second network throttle and watch which features break. #OfflineFirst #ServiceWorker #CacheStorage #BackgroundSync #WebDevelopment #ProgressiveWebApp #NetworkFailure #GracefulDegradation #UserExperience #CheckoutFlow #RetailTech #JavaScript #PWA #Connectivity #WebAPIs #Technology #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 DevTools Memory tab and the 'detached DOM nodes' filter, then explains the fix: a custom plugin that hooks into the 'done' compiler hook to force-close stale sockets. Listeners will walk away with a concrete script they can drop into their webpack config today to keep their dev server lean during all-day coding marathons. #WebpackDevServer #MemoryLeak #HotModuleReplacement #WebSocket #ChromeDevTools #DetachedDOMNodes #DevServer #JavaScript #Performance #Frontend #Debugging #Technology #WebDevelopment #FexingoBusiness #BusinessPodcast #Coding #NodeJS #BuildTooling Keep every episode free: buymeacoffee.com/fexingo

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 300 milliseconds just by serving a properly optimized favicon. The episode covers how the browser requests the favicon before any CSS or JavaScript, why a 404 on favicon.ico is worse than you think, and the three steps to fix it: inline SVG, preconnect hints, and HTTP cache headers. If you manage a web app or a content site, this 10-minute episode will change how you think about that tiny browser tab icon. #Favicon #DNSprefetch #WebPerformance #Frontend #BrowserOptimization #FirstPaint #HTTPCache #InlineSVG #Preconnect #CriticalPath #WebDev #PerformanceBudget #FexingoTech #TechPodcast #LucasAndLuna #WebDevelopment #PageSpeed #DeveloperTips Keep every episode free: buymeacoffee.com/fexingo

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 default on grid items. Lucas walks through the actual CSS properties involved: grid-template-columns with minmax, the implicit min-width of 300 pixels on grid children, and how overflow-x: hidden only masks the symptom. They also show how to prevent the overflow using minmax(0, 1fr) and explicit min-width: 0. By the end you will know exactly why your grid overflows and the two-line fix that stops it. #CSSGrid #CSSOverflow #ResponsiveDesign #FrontendPerformance #WebLayout #MobileFirst #CSSMistakes #GridLayout #CSSMinmax #OverflowHidden #MinWidthZero #CSSGridColumn #ImplicitTracks #WebDev #Technology #FexingoBusiness #BusinessPodcast #LucasAndLuna Keep every episode free: buymeacoffee.com/fexingo

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 300KB to under 10KB. They also cover how to audit your bundle with PurgeCSS stats and how to avoid common pitfalls with dynamic class names. If you've ever wondered why your Tailwind CSS feels heavy, this episode gives you a clear diagnosis and a fix you can implement today. #TailwindCSS #CSSBundle #WebPerformance #BundleSize #PurgeCSS #JITEngine #Frontend #WebDev #Technology #FexingoBusiness #BusinessPodcast #WebDevelopmentPodcast #LucasAndLuna #CSSOptimization #DynamicClasses #ContentConfig #BuildArtifacts #SafelistPattern Keep every episode free: buymeacoffee.com/fexingo

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 instead. They also discuss browser support (95% globally as of June 2026), performance implications (no layout thrashing), and gotchas like containment and naming. By the end, you'll know exactly when to reach for Container Queries and when to stick with media queries. #CSS #ContainerQueries #ResponsiveWebDesign #Frontend #WebDevelopment #CSSContainerQueries #ModernCSS #Layout #Performance #BrowserSupport #MediaQueries #WebDevTips #Coding #Technology #FexingoBusiness #BusinessPodcast #Fexingo #Podcast Keep every episode free: buymeacoffee.com/fexingo

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 browser's critical rendering path gets blocked, why the first paint can take five seconds on a 3G connection, and what developers can do about it: route-level code splitting, preload hints, and the trade-offs of server-side rendering versus static generation. They also touch on why Google's Core Web Vitals penalize sites that fail the Largest Contentful Paint threshold, and how a simple 'script type=module' with async loading can cut perceived load time in half. No abstract theory — just a focused investigation into one performance bottleneck that affects millions of users. #WebPerformance #CoreWebVitals #JavaScriptBundles #CodeSplitting #LazyLoading #StaticSites #SSR #SSG #LCP #CriticalRenderingPath #Preload #ScriptTypeModule #AsyncLoading #SlowNetworks #3GPerformance #WebDev #Technology #FexingoBusiness Keep every episode free: buymeacoffee.com/fexingo

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 — excessive fetch handlers, long-lived caches, and background sync intervals — and walk through concrete fixes like event-scope narrowing, cache-first strategies, and using the Background Sync API sparingly. If you're running a progressive web app or even just a simple caching service worker, this episode will change how you think about background scripts. No fluff, just actionable web performance advice. #ServiceWorker #BatteryDrain #WebPerformance #PWAs #ProgressiveWebApps #MobileWeb #FetchHandler #CacheFirst #BackgroundSync #Navigator #ChromeDevTools #WebDev #Frontend #Technology #FexingoBusiness #BusinessPodcast #LucasAndLuna #WebDevelopmentPodcast Keep every episode free: buymeacoffee.com/fexingo

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 worker_threads internals, the specific CPU instruction stalls, and the two-line fix using worker-data serialization flags that restores parity. The episode also covers why this issue silently affects CI runners and how to detect it with a simple benchmark script. A concrete deep dive for any web developer using Webpack on Apple Silicon machines. #Webpack #M4Mac #AppleSilicon #Performance #ARM #NodeJS #TerserPlugin #WebDevelopment #Frontend #BuildTools #CI #CPUArchitecture #MemoryPrefetcher #ParallelWorkers #Benchmarking #Technology #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 misconfigured cache header can blow up your Lighthouse score. Luna questions whether CDN edge caching is worth the complexity, and Lucas shares a real case where switching from short-lived to long-lived cache with content hashing cut repeat-load times by 40 percent. They also touch on stale-while-revalidate strategies and why service workers aren't a silver bullet. No fluff, no clickbait — just a drill into one specific performance problem that touches nearly every web app in production. #WebPerformance #HTTPCaching #CacheControl #JavaScript #Frontend #Backend #WebDev #TechPodcast #Lighthouse #CDN #ServiceWorker #ContentHashing #StaleWhileRevalidate #BundleOptimization #FexingoBusiness #BusinessPodcast #Technology #WebDevelopment Keep every episode free: buymeacoffee.com/fexingo

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 difference between render cache and data cache, why stale-while-revalidate isn't a silver bullet, and how one team cut their time-to-first-byte by 40% by shifting to incremental static regeneration with a smart invalidation key. Luna pushes back on complexity — isn't this just over-engineering? Lucas argues the cost of a cache miss is often lower than the cost of a cache hit with stale data. Specific, practical, and grounded in real metrics. #SSR #CacheStaleness #WebPerformance #ServerSideRendering #IncrementalStaticRegeneration #StaleWhileRevalidate #TTFB #FrontendPerformance #WebDev #NextJS #CDN #CacheInvalidation #EcommercePerformance #ConversionRate #WebVitals #Technology #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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. They discuss the gap between Chrome User Experience Report (CrUX) data and synthetic testing, how session-level aggregation hides p99 issues, and why your analytics provider might be filtering out your slowest users. Luna pushes back on the idea that a single number can capture user experience, and they explore practical fixes: using RUM with proper thresholds, segmenting by connection type, and the one metric you should literally ignore. By the end, you'll know exactly why your Web Vitals score is probably wrong — and what to do about it. #WebVitals #CoreWebVitals #LCP #CLS #FID #INP #RUM #CrUX #PerformanceMonitoring #Lighthouse #WebPerformance #Frontend #RealUserMonitoring #Technology #FexingoBusiness #BusinessPodcast #WebDev #PerformanceOptimization Keep every episode free: buymeacoffee.com/fexingo

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 the way, they talk about how Google's Core Web Vitals flags interaction delays like this, and why a seemingly small 200ms lag can slash conversion rates by up to 10 percent. If you've ever clicked a dropdown and felt that half-beat delay before the options appear, this episode explains exactly what's happening under the hood — and how to fix it with fewer than 20 lines of code. No fluff, just a focused case study on one of the web's most common UX speed bumps. #DropdownMenu #WebPerformance #CoreWebVitals #InteractionDelay #LayoutThrashing #EventDelegation #PassiveEventListeners #CSSContainment #WebDevelopment #Frontend #UX #ConversionRate #JavaScript #React #PerformanceOptimization #LucasAndLuna #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 difference between hidden-source-map and nosources-source-map, and why Webpack's default settings are dangerously permissive. You'll learn a single-line config change that stops the leak cold, plus how to verify the fix with curl. No scaremongering — just concrete steps to lock down what should never leave your build server. #Webpack #SourceMaps #WebSecurity #Frontend #JavaScript #DevTools #ProductionSecurity #WebpackConfig #HiddenSourceMap #NosourcesSourceMap #CDNLeak #CodeExposure #SecurityAudit #Technology #FexingoBusiness #BusinessPodcast #WebDevPodcast #FexingoTech Keep every episode free: buymeacoffee.com/fexingo

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 navigation and infinite loops. Lucas explains why overlays fail the WCAG success criteria they promise to meet, and Luna shares data from the WebAIM Million report showing that overlay users often face more barriers than before. They discuss better alternatives: semantic HTML, proper ARIA attributes, and manual testing with real assistive technology. No ad breaks, just honest technical discussion. #WebDevelopment #Accessibility #A11y #Overlays #WCAG #ScreenReaders #Lighthouse #WebAIM #SemanticHTML #ARIA #InclusiveDesign #UserExperience #Technology #Frontend #FexingoBusiness #BusinessPodcast #WebDev #NoAds Keep every episode free: buymeacoffee.com/fexingo

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 batching and missing dependency arrays cause cascading re-renders that bloat render time from 200 milliseconds to nearly four seconds. The episode walks through React 18's automatic batching, the difference between urgent and non-urgent updates, and a practical migration path from useEffect to useSyncExternalStore for data subscriptions. Lucas references a real-world case where a SaaS team cut initial render count from 37 to 4 by splitting one component into three micro-components and switching to React Query for caching. Luna adds a note on React DevTools profiler output and how to interpret the flame graph's 'why did this render' tags. The conversation ends with a forward-looking note on React Forget, the compiler that aims to automate memoization in React 19. #React #ReactPerformance #ReRenders #useEffect #React18 #React19 #ReactForget #useSyncExternalStore #WebPerformance #Frontend #JavaScript #ReactDevTools #StateBatching #StaleClosures #ReactQuery #Memoization #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 play well with GitHub Actions' cache keys. He walks through the exact `npm ls` commands to detect the duplication, explains why pnpm's content-addressable store avoids the problem entirely, and shares a minimal `node_modules` traversal script to validate your own hoisting. Luna pushes back on whether the switch to pnpm is worth the migration cost, and Lucas offers a pragmatic middle path: pinning cache keys to the lockfile hash and using `--install-strategy=nested` to force local installations. The episode ends with a concrete checklist for any team running a monorepo on NPM today. #Monorepo #NPMWorkspaces #CIPipeline #DependencyHoisting #GitHubActions #CacheKeys #Pnpm #NodeModules #npmLs #Lockfile #InstallStrategy #BuildPerformance #DevOps #WebDev #Technology #FexingoBusiness #BusinessPodcast #WebDevelopmentPodcast Keep every episode free: buymeacoffee.com/fexingo

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 slower. They explain how B-tree depth, index selectivity, and write amplification interact, and why a multi-column index that seems perfect for a query can actually force the database to scan more pages than a full table scan. Luna shares a story about a PostgreSQL query planner choosing a bitmap scan over a perfectly good single-column index because the statistics were stale — and what the team did to fix it. They also cover practical tips for monitoring index bloat, using pg_stat_user_indexes, and knowing when to drop an index entirely. If you've ever added an index and seen no improvement, or worse, a regression, this episode is for you. #DatabasePerformance #PostgreSQL #Indexing #QueryOptimization #WebDev #Technology #FexingoBusiness #BusinessPodcast #Backend #SQL #BTree #WriteAmplification #IndexBloat #pgStatUserIndexes #CompositeIndex #BitmapScan #EcommerceBackend #DatabaseTuning Keep every episode free: buymeacoffee.com/fexingo

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 handle decimal data differently, and the single test pattern you can adopt today to catch it. If you've ever seen a $0.01 discrepancy or a checkout total that felt 'off', this episode will change how you think about data integrity on the front end. #SilentDataCorruption #JavaScript #FloatingPoint #DecimalMath #Postgres #SQLite #ECommerceBug #DataIntegrity #WebDevelopment #Frontend #Backend #NumberType #RoundingErrors #Testing #SoftwareBugs #FexingoBusiness #BusinessPodcast #TechPodcast Keep every episode free: buymeacoffee.com/fexingo

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 where a team reduced API latency by 80 percent with one library swap. They also discuss how to detect the problem early with Apollo Studio and query logging. No hype, just practical debugging for your stack. #GraphQL #APIOptimization #DataLoader #NPlusOneProblem #WebPerformance #NodeJS #Backend #ApolloServer #DatabaseQueries #WebDev #FexingoBusiness #BusinessPodcast #Technology #SoftwareEngineering #Coding #WebDevelopment #PerformanceOptimization #TechTips Keep every episode free: buymeacoffee.com/fexingo

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 client, triggered a 500ms GC pause, and took down a production app. You'll learn how to detect backpressure failure using a single Node.js metric and why a simple 'isWritable' check can prevent the entire class of failure. No jargon — just a practical pattern you can apply today. #WebSocket #Backpressure #NodeJs #FlowControl #MemoryLeak #GarbageCollection #ServerCrash #RealTimeApps #ChatServer #WritableStream #DrainEvent #ProductionDebugging #WebDev #Technology #FexingoBusiness #BusinessPodcast #WebDevPodcast #Episode30 Keep every episode free: buymeacoffee.com/fexingo

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 renderToPipeableStream. They explore how Node.js backpressure, chunked transfer encoding, and Suspense boundaries interact — and why many streaming implementations accidentally serialize chunks instead of piping them. Listeners learn a specific diagnostic technique: measuring the time between the first byte of the HTML open tag and the first content to detect accidental buffering. The conversation also touches on edge cases: what happens when a downstream database call is slow and how to fall back gracefully without breaking the stream. No fluff, just a focused technical deep dive into one of the most misunderstood performance levers in modern web frameworks. #WebPerformance #HTMLStreaming #TTFB #ServerSideRendering #React #NodeJs #Backpressure #ChunkedTransferEncoding #StreamingArchitecture #FrontendPerformance #Technology #WebDev #Suspense #RenderToPipeableStream #SaaS #Latency #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 garbage collection can't fix. Luna shares a surprising data point: a single unclosed WebSocket handler can retain up to 2 MB of heap memory per user. They discuss practical fixes — using WeakRef for listener cleanup, implementing heartbeat-based connection draining, and profiling WebSocket memory with Chrome DevTools and clinic.js. By the end, you'll know exactly what to look for in your ws or Socket.IO setup before your production app starts gasping. #WebSocket #MemoryLeak #NodeJS #Backend #RealTimeApps #JavaScript #WebDev #Performance #Debugging #GC #HeapMemory #WeakRef #SocketIO #ClinicJS #Fintech #Technology #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 window counters, token buckets at the edge, and careful placement of the limiter in the request pipeline. If you've ever wondered why your API slows down after adding 'protection,' this episode gives you the concrete debugging steps and the specific trade-offs each fix carries. No theory without numbers: the episode opens with a specific latency chart from production and closes with a forward-looking question about AI inference rate limiting. #RateLimiting #APIPerformance #BackendEngineering #Redis #Latency #NodeJS #WebPerformance #SystemDesign #Scalability #BurstTraffic #TokenBucket #SlidingWindow #TechPodcast #WebDev #SoftwareEngineering #FexingoBusiness #BusinessPodcast #Technology Keep every episode free: buymeacoffee.com/fexingo

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 about decode-time trade-offs. Lucas explains why JPEG XL is the dark horse for the future, and Luna questions whether the format decision tree matters more than image dimensions. Perfect for developers looking to shave seconds off load times without sacrificing visuals. #WebPerformance #ImageOptimization #WebP #AVIF #JPEGXL #Frontend #WebDev #PageSpeed #Compression #BrowserSupport #Lighthouse #CoreWebVitals #Technology #WebDevelopment #DevTips #FexingoBusiness #BusinessPodcast #TechPodcast Keep every episode free: buymeacoffee.com/fexingo

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. page-level errors, and how to use error states as an opportunity to build user trust rather than frustration. Listeners walk away with a concrete checklist for auditing their own app's error handling. #ErrorMessages #UXWriting #WebDevelopment #ConversionRate #UserExperience #Frontend #Backend #WebDev #Technology #FexingoBusiness #BusinessPodcast #Episode25 #Fexingo #LucasAndLuna #WebApp #UserRetention #UI #BestPractices Keep every episode free: buymeacoffee.com/fexingo

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-in-JS runtime overhead. They also cover practical steps to audit your stylesheet, set up build-time trimming, and avoid common pitfalls that keep your CSS heavy. By the end, you'll have a concrete checklist to shrink your bundle without breaking layout or losing maintainability. #CSS #WebPerformance #FrontendOptimization #PurgeCSS #PostCSS #CSSBloat #BundleSize #PageSpeed #Ecommerce #DeveloperTools #Technology #FexingoBusiness #BusinessPodcast #WebDev #BuildOptimization #CSSInJS #UnusedCSS #PerformanceAudit Keep every episode free: buymeacoffee.com/fexingo

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. They explain why common tools like Lerna and Nx can mask the problem, and what a proper affected-project detection setup looks like. They also touch on the trade-off between developer convenience and build speed, and why moving to separate repos isn't always the answer. If your team's CI feels sluggish and you suspect the monorepo is to blame, this episode gives you the concrete diagnosis and fix. #Monorepo #CI #BuildPipeline #Nx #Lerna #DependencyGraph #WebPerformance #DevOps #ContinuousIntegration #Technology #FexingoBusiness #BusinessPodcast #WebDev #Frontend #Backend #SoftwareEngineering #BuildOptimization #DeveloperProductivity Keep every episode free: buymeacoffee.com/fexingo

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 why incremental module graph rebuilds keep the feedback loop tight. The hosts also discuss a real migration story from a 15-person team that cut their average dev-server boot time from 4.2 seconds to 0.8 seconds, with concrete numbers on node_modules scanning, cache invalidation, and the trade-offs of Vite's Rollup-based production build. No framework wars — just the structural decisions that make one approach faster, and what you lose or gain when you switch. #Vite #Webpack #ESBuild #Rollup #DevServer #HotModuleReplacement #Bundler #NativeESM #DeveloperExperience #JavaScriptTooling #BuildPerformance #NodeModules #ModuleGraph #FrontendTooling #MigrationStory #Technology #FexingoTechnology #FexingoPodcast Keep every episode free: buymeacoffee.com/fexingo

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 metric no one checks: total script execution time on the main thread. They also share a practical audit workflow using Chrome DevTools and a simple budget-based approach to decide what scripts stay. If you've ever added a snippet without measuring the cost, this episode will change how you think about every single embed. #ThirdPartyScripts #WebPerformance #LCP #CoreWebVitals #ChromeDevTools #SiteSpeed #JavaScriptBundles #EcommerceTech #WebDev #FrontendPerformance #PageSpeedInsights #ScriptAudit #WebOptimization #Technology #FexingoTechnology #WebDevPodcast #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 the browser's registration timeline, the difference between 'install' and 'activate' phases, and why developers often forget that service workers run on a separate thread but still block critical rendering through importScripts. The episode also covers practical debugging steps using Chrome DevTools' Service Worker pane and the Application panel, plus a quick tip on using 'self.skipWaiting()' correctly. No fluff, just one concrete fix you can audit in your own project today. #ServiceWorkers #WebPerformance #FirstPaint #JavaScript #ProgressiveWebApps #ChromeDevTools #Frontend #WebDev #Caching #PerformanceOptimization #PWAs #LoadTime #BrowserAPI #Tech #Technology #FexingoBusiness #BusinessPodcast #WebDevPodcast Keep every episode free: buymeacoffee.com/fexingo

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. They walk through cache busting gone wrong, the difference between module and chunk hashes, and why you should never let timestamps into your build output. No jargon dumps: just a specific, actionable fix for a problem every webpack user has felt but few debug. Plus, a quick moment on how listener support keeps this show ad-free. #Webpack #WebpackCache #BuildPerformance #JavaScript #CI/CD #DevTools #SoftwareEngineering #Frontend #WebDev #CodeOptimization #IncrementalBuilds #CacheInvalidation #Technology #WebDevelopment #FexingoBusiness #BusinessPodcast #WebDevPodcast #Fexingo Keep every episode free: buymeacoffee.com/fexingo

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 why tools like `clinic` or Chrome DevTools' memory tab matter more than just checking memory usage. The episode ends with practical strategies: scoping timers, weak references, and monitoring for gradual growth rather than static thresholds. #NodeJS #MemoryLeak #CPUProfiling #Performance #Backend #ClinicJS #ChromeDevTools #HeapSnapshot #JavaScript #ServerSide #Debugging #setInterval #WeakRef #GarbageCollection #Technology #FexingoBusiness #BusinessPodcast #WebDev Keep every episode free: buymeacoffee.com/fexingo

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, and a practical workflow for keeping your node_modules lean. By the end, you'll know exactly how to audit your own project and cut the dead weight. #Webpack #npm #TreeShaking #JavaScriptBundling #DependencyHell #PerformanceOptimization #WebDevelopment #Technology #FexingoBusiness #BusinessPodcast #Depcheck #BundleAnalyzer #NodeModules #SideEffectsFlag #FrontendPerformance #BuildOptimization #Startup #DeveloperTools Keep every episode free: buymeacoffee.com/fexingo

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 can catch these issues before they reach users. The episode also covers practical strategies for maintaining alignment between frontend and backend teams, including shared type definitions, automated checks in CI/CD, and the trade-offs of using generated TypeScript types from GraphQL schema files. If you build APIs or consume them, this episode offers a concrete lesson in why your schema is a contract that needs enforcement. #GraphQL #SchemaDrift #FrontendBackend #API #TypeScript #GraphQLInspector #ContractTesting #WebDevelopment #Technology #FexingoBusiness #BusinessPodcast #TechPodcast #WebDev #APIErrors #SoftwareEngineering #CodeReview #CI_CD #TypeSafety Keep every episode free: buymeacoffee.com/fexingo

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 with correlation IDs to trace failures end-to-end, and the single configuration change that surfaces 90% of hidden job deaths. If you've ever had a data sync mysteriously stop or a report never generate without any alert, this episode is for you. Plus, the hosts share a quick behind-the-scenes on how listener support keeps the show ad-free. #BackgroundJobs #Sidekiq #SilentFailures #JobQueues #ErrorMonitoring #StructuredLogging #CorrelationIDs #Fintech #TransactionProcessing #Resilience #WebDev #DeveloperTools #ProductionDebugging #Observability #Backend #TechPodcast #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

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 minutes per build, and show how switching to project references and incremental compilation cut that to under three. Along the way, they discuss trade-offs between developer experience and compilation speed, when skipLibCheck is safe, and why composite projects are worth the upfront setup. This episode is for any developer who has watched their TypeScript compiler run longer than their actual tests. #TypeScript #BuildPerformance #WebDevelopment #Technology #Frontend #Backend #Compiler #CI #DevOps #IncrementalBuilds #ProjectReferences #PathAliases #TsConfig #DeveloperExperience #Startup #FexingoBusiness #BusinessPodcast #WebDev Keep every episode free: buymeacoffee.com/fexingo

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 single overlooked aria-label cost them an ADA lawsuit settlement. Luna pushes back on audit culture, asking whether compliance checklists create a false sense of inclusion. They explore the difference between 'passing WCAG' and actually building for real users, with concrete examples from complex web apps like data dashboards and multi-step forms. The episode closes on a forward-looking question: as AI-generated UI becomes more common, will accessibility audits scale or fall further behind? #WebAccessibility #WCAG #AriaLabels #ScreenReader #KeyboardNavigation #InclusiveDesign #AuditCulture #AdaLawsuit #AssistiveTechnology #Frontend #UX #TechPodcast #WebDev #FexingoBusiness #BusinessPodcast #Technology #ManualTesting #AccessibilityGaps Keep every episode free: buymeacoffee.com/fexingo

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 integrity, and the one command that catches corruption before it hits staging. If you've ever had a build mysteriously fail on one machine but work on another, this episode gives you the forensic checklist. No theory, just the mechanic's view of the modern web stack. #PackageLockfile #Npm #Yarn #NodeJs #CIPipeline #DependencyManagement #LockfileAudit #BuildFailures #WebDev #FrontendEngineering #DevOps #ReproducibleBuilds #SemVer #IntegrityCheck #TechPodcast #FexingoBusiness #BusinessPodcast #Technology Keep every episode free: buymeacoffee.com/fexingo

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 unpack the concept of layer caching gone wrong. You'll learn concrete techniques: using multi-stage builds, switching to distroless images, and auditing your Dockerfile with tools like dive and docker-slim. The hosts also share a quick, honest moment about how listener support keeps the show ad-free. By the end, you'll know exactly how to trim your container images without breaking your app. #Docker #Containerization #DevOps #WebDevelopment #CI/CD #Dockerfile #MultiStageBuilds #AlpineLinux #DistrolessImages #LayerCaching #DockerSlim #Dive #ImageOptimization #Deployment #Technology #FexingoBusiness #BusinessPodcast #Performance Keep every episode free: buymeacoffee.com/fexingo