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

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

By FexingoBusiness
Download on the App Store

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

  • Why Your Package Lockfile Is Breaking Your Builds

    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

    8 min
  • Why Your Docker Images Are 2GB Too Large

    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

    6 min
  • Why Your Lazy Loading Is Breaking User Experience

    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 mechanics of intersection observer thresholds, explain why 'loading=lazy' isn't a silver bullet, and walk through a better approach using native loading attributes with explicit fetch priority hints. Along the way, they discuss how Chrome DevTools can reveal hidden lazy loading costs and offer practical thresholds for when not to lazy load at all. If you're a frontend developer shipping React, Vue, or plain HTML, this episode will change how you think about deferred loading.

    #LazyLoading #WebPerformance #CoreWebVitals #LCP #IntersectionObserver #FrontendOptimization #ChromeDevTools #ImageOptimization #IframeLoading #UserExperience #WebDev #React #VueJS #HTML #FexingoBusiness #BusinessPodcast #Technology #LoadingPerformance

    Keep every episode free: buymeacoffee.com/fexingo

    9 min
  • Why Your Web App Feels Slow on Mobile

    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 panel to identify a 280-millisecond script parse bottleneck, then shows how code splitting and requestIdleCallback cut long tasks from 12 to 3 per page load. Luna questions whether the fixes introduce complexity for teams that aren't Facebook-scale, and they debate when it's worth deferring work vs. moving it to a Web Worker. By the end, you'll know exactly how to audit your own app's long tasks and why 50 milliseconds is the threshold you can't ignore.

    #WebPerformance #LongTasks #Frontend #React #JavaScript #CoreWebVitals #FID #BrowserMainThread #ChromeDevTools #CodeSplitting #WebWorker #requestIdleCallback #InteractionReadiness #PerformanceAudit #Technology #FexingoBusiness #BusinessPodcast #TheWebDevelopmentPodcast

    Keep every episode free: buymeacoffee.com/fexingo

    9 min
  • Why Your Next.js Build Takes 40 Seconds Longer Than It Should

    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 generation, and caching headers interact in ways that trip up even experienced teams. Luna shares data on how build times correlate with developer churn and deployment frequency. By the end, you'll understand why your build is slow and have a concrete checklist to fix it — no framework upgrade required.

    #NextJS #BuildPerformance #WebDevelopment #IncrementalBuilds #ReactServerComponents #StaticGeneration #CICD #SaaS #DeveloperExperience #Frontend #Backend #Technology #WebDevPodcast #FexingoBusiness #BusinessPodcast #BuildPipeline #Caching #PerformanceOptimization

    Keep every episode free: buymeacoffee.com/fexingo

    11 min
  • Why Your Web Vitals Scores Plummet After a JavaScript Framework Update

    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 introducing layout thrashing, a third-party analytics script that ballooned from 12KB to 89KB, and how the new Suspense boundaries triggered waterfalls that the old code didn't. Lucas explains why many teams miss performance regressions in staging environments, and Luna shares a practical tip about using Lighthouse CI in pull requests as a safety net. The episode also touches on when to resist framework upgrades and how to audit dependencies for invisible bloat. A must-listen for any frontend developer dealing with slow sites after an upgrade.

    #WebVitals #CoreWebVitals #JavaScript #React #Performance #LCP #Frontend #WebDev #FrameworkUpgrade #React19 #Lighthouse #CI #ThirdPartyScripts #Suspense #ConcurrentRendering #Technology #FexingoBusiness #BusinessPodcast

    Keep every episode free: buymeacoffee.com/fexingo

    9 min
  • Why Your Image CDN Setup Might Be Costing You More Than Bandwidth

    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 annual expense. The episode focuses on one concrete fix: implementing a tiered image pipeline with WebP fallback, on-the-fly resizing, and a shared CDN cache key strategy. By the end, listeners will know exactly how to audit their own image pipeline for cost overruns, and why the cheapest CDN isn't always the cheapest option.

    #ImageCDN #WebPerformance #WebDevelopment #CostOptimization #CDN #WebP #ImageOptimization #Frontend #Backend #DevOps #Technology #FexingoBusiness #BusinessPodcast #WebDevPodcast #LucasAndLuna #ImagePipeline #CacheHeaders #Transformations

    Keep every episode free: buymeacoffee.com/fexingo

    15 min
  • Why Your API Calls Take 2 Seconds to Start

    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 the one configuration change that slashed latency by 40%. No fluff, just a concrete debugging story with a lesson that applies to any API-heavy frontend or backend. If you've ever opened Chrome DevTools and wondered why your requests spend most of their time in 'Connection Start' or 'Stalled', this episode is for you.

    #WebPerformance #APILatency #HTTP2 #ConnectionPooling #TLS #TCPHandshake #KeepAlive #DevTools #NetworkTab #SaaS #Backend #Frontend #WebDev #Technology #FexingoBusiness #BusinessPodcast #LucasAndLuna #PerformanceOptimization

    Keep every episode free: buymeacoffee.com/fexingo

    10 min
  • Why Your Database Queries Are 10x Slower Than They Should Be

    Lucas and Luna dig into a single overlooked setting — connection pooling — that silently throttles most web applications. Using a real 2025 incident where a 12-person startup saw API latency jump from 30ms to 1.2 seconds because their Postgres pool was misconfigured, they explain how pooling works, why ORMs hide it, and the one config change that fixed it. No theoretical lecture — just a concrete debugging story with a number you can check in your own stack today.

    #ConnectionPooling #Postgres #APILatency #DatabasePerformance #BackendOptimization #WebDev #Startup #Technology #FexingoBusiness #BusinessPodcast #LucasAndLuna #QueryPerformance #PgBouncer #ORM #Prisma #DatabaseConfig #WebPerformance #SoftwareEngineering

    Keep every episode free: buymeacoffee.com/fexingo

    10 min
  • Why Your CSS Framework Is Making Your Site 800KB Heavier

    Episode 3 of The Web Development Podcast dives into the hidden bloat of CSS frameworks. Lucas and Luna break down why a typical Bootstrap 5 setup delivers over 800KB of unused CSS — and how modern alternatives like utility-first Tailwind CSS or CSS Container Queries can slash that to under 10KB. They walk through real-world numbers from a 2025 e-commerce site rebuild, compare the bundle-size impact of popular frameworks, and explain why the web's median page weight has crept past 2.5MB. If you've ever wondered whether your CSS framework is slowing down your users, this episode gives you the data to decide — plus practical tips for auditing your own stylesheet with tools like PurgeCSS and Chrome DevTools coverage reports.

    #WebDevelopment #CSS #Performance #TailwindCSS #Bootstrap #BundleSize #Frontend #WebDev #PurgeCSS #ContainerQueries #Ecommerce #TechPodcast #FexingoBusiness #BusinessPodcast #LucasAndLuna #WebPerf #CSSFrameworks #Optimization

    Keep every episode free: buymeacoffee.com/fexingo

    12 min

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

From the publisher's feed

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 vs. Memcached under 100K QPS — and candid postmortems of real outages. You'll leave each episode with a sharper mental model of the web's moving parts, and maybe a new library to try. But Lucas and Luna won't sell you a silver bullet; they'll hand you a weighted decision tree.