The Developer Tools Podcast with Fexingo: APIs, Infrastructure, and Software for Engineers

The Developer Tools Podcast with Fexingo: APIs, Infrastructure, and Software for Engineers

Lucas and Luna examine the developer tools landscape — APIs, infrastructure, and software designed for engineers — through the lens of business viability and technical merit. Each episode picks a specific tool or platform: how it was built, what problem it solves, who pays for it, and whether its architecture gives it a durable advantage. They compare pricing models, study public SDKs and changelogs, and trace the decisions that turn an open-source side project into a billion-dollar company. No demos, no tutorials — just two co-hosts reading documentation, running benchmarks, and asking whether a tool's design actually makes engineers more productive or just more dependent. Past topics: the economics of API gateways, why gRPC is replacing REST in microservices, the rise of WebAssembly beyond the browser, and the hidden costs of managed Kubernetes. Listeners walk away with a concrete framework for evaluating developer tools — not as a user, but as a buyer, builder, or investor. What does it take for infrastructure software to earn the trust of engineers who have seen too many promises break in production? #DeveloperTools #APIs #Infrastructure #SoftwareEngineering #CloudComputing #OpenSourceBusiness #GRPC #WebAssembly #Kubernetes #SDKs #DevOps #PlatformEngineering #Technology #FexingoBusiness #BusinessPodcast #Business #EngineeringPodcast #TechBusiness Keep every episode free: buymeacoffee.com/fexingo

Episodes

June 21, 2026 11 mins
Episode 64 of The Developer Tools Podcast digs into why OpenAPI specs and auto-generated docs are not enough to make developers productive. Lucas and Luna explore a real case from Stripe's early API docs, the friction of onboarding with only a spec file, and why Anthropic's Claude prompt engineering guide teaches more about usability than most API portals do. They discuss what makes documentation stick: concept guides, error messag...
Listen
Watch
Mark as Played
Lucas and Luna examine how exponential backoff in webhook retries can accidentally multiply failures across dependent services. They walk through a real incident at a payment processor where a 5-minute database slowdown triggered 14 hours of cascading retry storms, costing $3.2 million in failed transactions and lost processing fees. The episode covers why naive retry strategies treat symptoms, not root causes, and how techniques l...
Listen
Watch
Mark as Played
Episode 62 of The Developer Tools Podcast. Lucas and Luna dig into why aggressive API throttling, intended to protect infrastructure, often backfires by eroding developer trust. They examine the case of a major cloud provider's 2025 throttling incident that caused widespread outages for third-party apps, and contrast it with a fintech API that uses graduated backpressure instead of hard limits. The hosts discuss the trade-offs betw...
Listen
Watch
Mark as Played
Episode 61 of The Developer Tools Podcast tackles the persistent gap between API specs and real developer experience. Lucas and Luna examine why even well-designed APIs with OpenAPI 3.1 schemas, Postman collections, and interactive playgrounds still leave developers frustrated. They look at Stripe's 2025 API documentation audit, which found that 68 percent of support tickets originated from unclear docs — even though Stripe's...
Listen
Watch
Mark as Played
Episode 60 of The Developer Tools Podcast dives into a common but often overlooked performance bottleneck: the API gateway. Lucas and Luna examine a real case from Shopify, where their internal API gateway introduced 87 milliseconds of median latency per request in early 2026. They break down the causes—serialization overhead, TLS handshake costs, and bloated middleware chains—and discuss how Shopify cut that latency by...
Listen
Watch
Mark as Played
Episode 59 of The Developer Tools Podcast looks at a hidden productivity drain: APIs that force developers into context switching. Lucas and Luna discuss how overly complex authentication flows, inconsistent response formats, and poorly designed endpoints erode focus—and what Stripe, Twilio, and GitHub do differently. They break down a 2025 study from the Developer Experience Lab that found developers lose an average of 12 mi...
Listen
Watch
Mark as Played
Episode 58 of The Developer Tools Podcast explores a subtle but costly failure in API observability: when your logging pipeline is configured to capture the wrong fields, you end up with petabytes of noise and zero signal. Lucas and Luna dissect a real-world case from a mid-stage payments company that was logging entire request and response bodies for every API call, burning through $40,000 a month in data ingestion costs while mis...
Listen
Watch
Mark as Played
Episode 57 of The Developer Tools Podcast with Fexingo digs into a hidden source of bugs in modern APIs: pagination. Lucas and Luna break down why naive offset and page-number pagination causes duplicate or missing records when data changes between requests, and how cursor-based pagination solves the problem. They walk through a real example — a SaaS analytics dashboard that showed different totals every time a user paged thr...
Listen
Watch
Mark as Played
Episode 56 of The Developer Tools Podcast examines API token rotation—why static tokens are a security liability and how automated rotation limits blast radius. Lucas and Luna break down a real-world GitHub token leak incident, explain the difference between refresh tokens and access tokens, and discuss implementation trade-offs including token lifespan vs. performance cost. They also cover current best practices like OAuth 2...
Listen
Watch
Mark as Played
In this episode of The Developer Tools Podcast, Lucas and Luna dive into webhook payload signing — a critical but often overlooked security layer. They explain how signing works with HMAC, why plain HTTP verification leaves systems vulnerable to replay and tampering attacks, and walk through a real example from Stripe's webhook design. They also cover common implementation mistakes including time-window validation and secret ...
Listen
Watch
Mark as Played
Episode 54 of The Developer Tools Podcast explores how webhook retries in payment APIs can trigger duplicate charges — and why standard at-least-once delivery guarantees are often the culprit. Lucas and Luna break down a real-world case from a mid-size e-commerce platform that lost $40,000 in two hours due to missing idempotency checks on webhook receivers. They discuss how idempotency keys, exactly-once semantics, and receiv...
Listen
Watch
Mark as Played
Episode 53 of The Developer Tools Podcast dives into a hidden performance bottleneck: uncompressed API responses. Lucas and Luna explore why many developers skip gzip or brotli compression, how one mid-sized SaaS startup cut average response time from 340ms to 170ms just by enabling compression on their REST endpoints, and the surprising catch: compression trade-offs for very small payloads and streaming endpoints. They also cover ...
Listen
Watch
Mark as Played
Lucas and Luna dig into API fuzzing — why sending random garbage to your endpoints is one of the most effective ways to find vulnerabilities before attackers do. They walk through a real case: a fintech startup that fuzzed its payment API and discovered an integer overflow that would have let a bad actor charge negative amounts. They explain how property-based testing frameworks like QuickCheck and Rust's proptest apply fuzzi...
Listen
Watch
Mark as Played
Episode 51 of The Developer Tools Podcast with Fexingo dives into a silent integration killer: API deprecation without proper headers. Lucas and Luna break down how companies like Stripe and Twilio use Sunset and Deprecation headers to give developers months of warning before breaking changes. They discuss a real case where a major payment API's undocumented deprecation caused a week-long outage for a SaaS platform, costing $200K i...
Listen
Watch
Mark as Played
In Episode 50 of The Developer Tools Podcast, Lucas and Luna dive into the hidden costs and operational risks of choosing the wrong API versioning strategy. They compare URI versioning, header-based versioning, and query-parameter versioning using real-world examples from Stripe, Twilio, and GitHub's API v3 to v4 migration. The hosts break down trade-offs in caching, backward compatibility, and client migration overhead, and explai...
Listen
Watch
Mark as Played
Episode 49 of The Developer Tools Podcast tackles a common API design mistake: applying the same rate limit to every user. Lucas and Luna walk through a real-world example from a fictional SaaS analytics platform, showing how flat rate limits punish power users and leave revenue on the table. They discuss tiered rate limiting, burst allowances, and how to align API quotas with customer value. If you build or manage APIs, this episo...
Listen
Watch
Mark as Played
Most developers have dealt with cryptic API error messages like '500 Internal Server Error' or vague 'Something went wrong' responses. But bad error responses aren't just annoying — they cause real damage: debugging delays, frustrated developers, and even security leaks. In this episode, Lucas and Luna explore why structured error responses matter, using concrete examples like a payment API that returns different error format...
Listen
Watch
Mark as Played
In this episode of The Developer Tools Podcast, Lucas and Luna explore how standard API rate limiting strategies can inadvertently punish your most valuable users. They break down the problem using a concrete example from the fintech world — a payment API that throttles a high-volume merchant during peak checkout — and explain why naïve token-bucket algorithms lead to frustrated customers and lost revenue. Lucas introdu...
Listen
Watch
Mark as Played
This episode dives into the hidden cost of API rate limiting — punishing your most valuable users. Lucas and Luna examine a real case where a developer cut off their own biggest client with a 429 status code, and explore alternatives like cost-based limiting and queue-backed admission that prioritize high-value traffic. They also unpack how companies like Stripe and GitHub handle this differently, and why your rate limiting s...
Listen
Watch
Mark as Played
Episode 45 of The Developer Tools Podcast tackles one of the hardest problems in distributed systems: making APIs truly idempotent when networks drop, retry, and duplicate requests. Lucas and Luna break down why naive idempotency-key implementations fail — using the real-world example of a payment API that double-charged 200 customers because the key storage wasn't atomic. They walk through the actual engineering choices that...
Listen
Watch
Mark as Played

Popular Podcasts

    Hey Jonas! The official Jonas Brothers podcast. Hosted by Kevin, Joe, and Nick Jonas. It’s the Jonas Brothers you know... musicians, actors, and well, yes, brothers. Now, they’re sharing another side of themselves in the playful, intimate, and irreverent way only they can. Spend time with the Jonas Brothers here and stay a little bit longer for deep conversations like never before.

    Dateline NBC

    Current and classic episodes, featuring compelling true-crime mysteries, powerful documentaries and in-depth investigations. Follow now to get the latest episodes of Dateline NBC completely free, or subscribe to Dateline Premium for ad-free listening and exclusive bonus content: DatelinePremium.com

    Stuff You Should Know

    If you've ever wanted to know about champagne, satanism, the Stonewall Uprising, chaos theory, LSD, El Nino, true crime and Rosa Parks, then look no further. Josh and Chuck have you covered.

    The MeatEater Podcast

    Building on the belief that a deeper understanding of the natural world enriches all of our lives, host Steven Rinella brings an in-depth and relevant look at all outdoor topics including hunting, fishing, nature, conservation, and wild foods. Filled with humor, irreverence, and things that will surprise the hell out of you, each episode welcomes a diverse group of guests who add their own expertise to the vast world of the outdoors. Part of The MeatEater Podcast Network.

    The Joe Rogan Experience

    The official podcast of comedian Joe Rogan.

Advertise With Us
Music, radio and podcasts, all free. Listen online or download the iHeart App.

Connect

© 2026 iHeartMedia, Inc.

  • Help
  • Privacy Policy
  • Terms of Use
  • AdChoicesAd Choices