Épisodes

  • Why Your API Should Use GraphQL Subscriptions for Live Updates

    Why Your API Should Use GraphQL Subscriptions for Live Updates
    Jul 19 2026
    Episode 120 of The Developer Tools Podcast explores why REST-based polling is outdated for real-time features like live dashboards and collaborative editing. Lucas and Luna break down how GraphQL subscriptions use WebSocket connections to push only changed data, reducing bandwidth by up to 90% compared to polling. They walk through a real-world case: a logistics company that cut server costs by 40% after switching from REST polling to subscriptions for their shipment tracking dashboard. The hosts also discuss trade-offs: connection state management, backpressure, and when to fall back to polling. If you've ever built a feature that needed 'live' updates, this episode explains why subscriptions are the pattern you're missing. #GraphQL #Subscriptions #WebSockets #RealTime #API #Backend #DeveloperTools #BusinessAndTechnology #SoftwareEngineering #FexingoBusiness #BusinessPodcast #LiveUpdates #Polling #Performance #Scalability #Logistics #CaseStudy #DevTools Keep every episode free: buymeacoffee.com/fexingo
    Afficher plus Afficher moins
    8 min
  • Why Your API Should Use a Webhook Registry Pattern

    Why Your API Should Use a Webhook Registry Pattern
    Jul 18 2026
    Webhooks are everywhere — but most teams manage them like tribal knowledge buried in siloed code. This episode explains why a webhook registry pattern — a central, versioned, discoverable store of every webhook your API sends — solves the chaos. Lucas walks through how Stripe and GitHub each tackled webhook sprawl, and why a $15/month open-source tool like Hookdeck is reshaping how small teams think about reliability. Luna pushes back on the maintenance tax, and they land on a practical balance for teams of 5 to 50 engineers. A concrete pattern for anyone shipping events. #Webhooks #WebhookRegistry #API #APIArchitecture #SoftwareEngineering #EventDriven #DeveloperTools #Stripe #GitHub #Hookdeck #APIReliability #DeveloperExperience #BusinessAndTechnology #FexingoBusiness #BusinessPodcast #TheDeveloperToolsPodcast #Engineering #PatternCatalog Keep every episode free: buymeacoffee.com/fexingo
    Afficher plus Afficher moins
    7 min
  • Why Your API Should Use Async Pagination for Real-Time Data

    Why Your API Should Use Async Pagination for Real-Time Data
    Jul 18 2026
    Lucas and Luna dive into the limitations of traditional pagination for real-time APIs. Using the example of a stock-price feed that updates every second, Lucas explains how offset-based pagination fails when data changes between requests. He introduces cursor-based pagination with a unique, time-ordered key and explains why it avoids duplicates and gaps in volatile datasets. Luna questions the implementation complexity and caching implications. The episode also touches on combining async pagination with WebSockets for live streams, and the trade-off between consistency and throughput. A focused, practical episode for developers building data-intensive APIs. #AsyncPagination #CursorBasedPagination #RealTimeAPI #APIDesign #DataConsistency #WebSockets #PaginationStrategy #OffsetVsCursor #LiveDataStreams #APIReliability #BackendEngineering #DeveloperTools #BusinessAndTechnology #FexingoBusiness #BusinessPodcast #LucasAndLuna #APIPatterns #TechDeepDive Keep every episode free: buymeacoffee.com/fexingo
    Afficher plus Afficher moins
    10 min
  • Why Your API Should Version with Breaking Changes Not SemVer

    Why Your API Should Version with Breaking Changes Not SemVer
    Jul 17 2026
    Lucas and Luna debate whether strict semantic versioning for APIs actually protects consumers or just creates technical debt. They use the real example of Stripe's API versioning model — explicit date-based versions rather than semver — and contrast it with the pain of maintaining major.minor.patch for REST endpoints. Lucas explains why many API teams are moving to a 'breaking changes only' approach, and why the right versioning strategy depends on whether you control your clients. Along the way, they discuss how to communicate breaking changes in changelogs, when to use URL vs header versioning, and why deprecation windows matter more than version numbers. A practical episode for anyone who's ever argued about v2 vs v3 in a code review. #API #Versioning #SemVer #BreakingChanges #Stripe #REST #BackwardCompatibility #DeveloperExperience #Changelogs #Deprecation #URLVersioning #HeaderVersioning #APIDesign #TechnicalDebt #BusinessAndTechnology #FexingoBusiness #BusinessPodcast #DevTools Keep every episode free: buymeacoffee.com/fexingo
    Afficher plus Afficher moins
    7 min
  • Why Your API Needs a Backpressure Strategy

    Why Your API Needs a Backpressure Strategy
    Jul 17 2026
    Lucas and Luna dive into the concept of backpressure in API design — why it's critical for system stability, how it differs from rate limiting and circuit breakers, and a concrete example from an early Slack integration that failed without it. They explain how backpressure signals upstream services to slow down, preventing cascading failures, and why it's a missing piece in many API architectures. If you're building or running systems that handle variable load, this episode gives you a clear reason to add backpressure to your design patterns. #APIDesign #Backpressure #SystemDesign #ReliabilityEngineering #RateLimiting #CircuitBreaker #Slack #EventDriven #MessageQueues #DistributedSystems #Resilience #SiteReliability #BackendEngineering #DevTools #BusinessAndTechnology #FexingoBusiness #BusinessPodcast #SoftwareEngineering Keep every episode free: buymeacoffee.com/fexingo
    Afficher plus Afficher moins
    9 min
  • Why API Retry Strategies Should Be Exponential Not Linear

    Why API Retry Strategies Should Be Exponential Not Linear
    Jul 16 2026
    Lucas and Luna dig into the design of API retry strategies—why linear retries flood your servers with pointless traffic while exponential backoff with jitter actually works. They walk through a real example from a major e-commerce platform whose cart checkout endpoint saw a 40% failure spike under linear retry during Cyber Monday, then a clean recovery after switching to exponential with jitter. They also cover retry budget headers, the danger of retry storms, and how to choose a base delay. If you're building or operating APIs, this episode gives you one concrete number—the 2x multiplier with 50% jitter—that can save your system under load. #API #RetryStrategy #ExponentialBackoff #Jitter #LinearRetry #RetryStorm #CyberMonday #ECommerce #BackendEngineering #SystemDesign #Reliability #Resilience #DevTools #Technology #FexingoBusiness #BusinessPodcast #SoftwareEngineering #APIDesign Keep every episode free: buymeacoffee.com/fexingo
    Afficher plus Afficher moins
    7 min
  • Why Your API Should Use Conditional Requests for Caching

    Why Your API Should Use Conditional Requests for Caching
    Jul 16 2026
    Episode 114 of The Developer Tools Podcast digs into conditional HTTP requests — the If-None-Match and If-Modified-Since headers that let APIs save bandwidth and reduce latency. Lucas and Luna walk through a real case: a mobile engineering team at a mid-size logistics startup that cut API response sizes by 60 percent just by adding ETags to their shipment-tracking endpoints. They explain the 304 Not Modified flow, how ETags differ from Last-Modified dates, and why weak ETags matter for load-balanced deployments. The hosts also discuss common gotchas: stale ETags behind CDNs, the cost of generating strong ETags on large payloads, and when conditional requests backfire on frequently mutated resources. No fluff, just concrete patterns for any team building REST or GraphQL APIs. #ConditionalRequests #HTTPCaching #ETags #APIDesign #WebPerformance #RESTAPI #GraphQL #DeveloperTools #LatencyOptimization #BandwidthSavings #HTTP304 #LastModified #CacheValidation #APIOptimization #BackendEngineering #Infrastructure #Technology #FexingoBusiness Keep every episode free: buymeacoffee.com/fexingo
    Afficher plus Afficher moins
    10 min
  • Why Your API Needs a Circuit Breaker Pattern

    Why Your API Needs a Circuit Breaker Pattern
    Jul 15 2026
    Lucas and Luna dive into the circuit breaker pattern for APIs, using a real-world case from a major ride-hailing service that avoided cascading failure during a peak-hour surge. They explain how circuit breakers differ from retries and rate limiting, why they matter for microservice resilience, and how to set thresholds without false positives. The episode includes specific metrics for three states (closed, open, half-open) and a cautionary tale about misconfigured timeouts that made things worse. Listeners will learn exactly when to implement a circuit breaker and when not to. #CircuitBreaker #APIReliability #Microservices #ResiliencePatterns #FailureMode #RetryStorm #CascadingFailure #ServiceMesh #TimeoutConfiguration #BulkheadPattern #Hystrix #SpringCloud #NetflixOSS #BackendEngineering #BusinessAndTechnology #DeveloperTools #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo
    Afficher plus Afficher moins
    9 min