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

Lucas and Luna break down how bloated API response envelopes — those nested wrappers full of metadata and status codes — are silently increasing latency, bandwidth costs, and client-side parsing overhead. They examine a real-world case from a fintech startup that cut response payload size by 40% by stripping unnecessary envelope layers, and discuss how GraphQL, HTTP status codes, and REST conventi...

Episode 78 of The Developer Tools Podcast digs into a deceptively simple API design choice: pagination defaults. Lucas and Luna walk through a real-world case where a major developer platform shipped a 100-record default page size, and how that single decision caused cascading failures in downstream CI/CD pipelines, data ingestion jobs, and even cost overruns. They explore the trade-offs between p...

Episode 77 of the Developer Tools Podcast dives into a subtle but dangerous problem: API debug endpoints that expose sensitive business logic and data in production. Lucas and Luna examine a real case from a mid-size fintech that left a /debug/vars endpoint active, leaking internal stack traces, connection pool details, and database query structures. They break down how this happens — often from c...

Episode 76 of The Developer Tools Podcast digs into a quietly destructive API anti-pattern: error messages that reveal more than they should. Lucas and Luna examine how seemingly helpful error details — like 'User not found' vs. 'Incorrect password' — hand attackers a map of your database schema, your authentication flow, and even your internal service names. They walk through real cases, from a 2...

Episode 75 of The Developer Tools Podcast digs into a hidden cost that most engineering teams overlook: API gateway latency. Lucas and Luna break down how a 50-millisecond delay per request at the gateway layer compounds across microservice call chains, silently eroding both developer productivity and cloud spend. They walk through a real case from a fintech startup that discovered 12 percent of i...

Episode 74 of The Developer Tools Podcast with Fexingo tackles one of the most frustrating and neglected aspects of API lifecycle management: deprecation notices. Lucas and Luna break down why most deprecation communications are broken — from vague sunset timelines to silent removals — and what a well-structured notice looks like, drawing on real examples from Stripe and Twilio. They discuss the c...

Episode 73 of The Developer Tools Podcast. Lucas and Luna dig into one of the most overlooked sources of API inconsistency: implicit caching. They walk through a real-world case where a ride-hailing app's surge-pricing endpoint returned stale fares because a CDN cached POST responses that were never meant to be cached. The conversation covers Cache-Control headers, ETags, the difference between sh...

Episode 72 of The Developer Tools Podcast with Fexingo dives into why API latency SLOs often mislead engineering teams. Lucas and Luna explore a common pitfall: teams optimize for median latency while ignoring tail latency at the 99th percentile, which kills real-world reliability for end users. They break down a case study from a SaaS company that hit its 200ms p50 SLO but saw customer complaints...

Episode 71 of The Developer Tools Podcast explores why most API versioning strategies — especially URL-based versioning — make life harder for developers. Lucas and Luna discuss how Stripe, Twilio, and GitHub handle backward compatibility, why version-as-date is gaining traction, and the hidden cost of maintaining multiple versions. They also look at how GraphQL sidesteps the problem entirely and...

Lucas and Luna explore why most API changelogs fail developers and how a machine-readable changelog standard could prevent integration breakage. They break down a real example where Stripe's human-readable changelog led to a production outage, contrast it with GitHub's structured changelog approach, and discuss the emerging OpenAPI Changelog extension. If you build or integrate APIs, this episode...

Lucas and Luna dig into one of the most overlooked parts of API design: error payloads. Most APIs return a string message or an empty body on failure, which forces developers to parse text or guess. They explore a real-world case from Stripe's API, where every error returns a structured JSON object with a type, code, and parameter. They break down how this reduces debugging time, prevents cascadin...

Episode 68 of The Developer Tools Podcast dives into a quiet but damaging problem: most API documentation examples are written by engineers who already understand the system, not by the developers who actually use it. Lucas and Luna unpack why example code that works for one team often breaks for another, using the real-world case of Stripe's migration from generic curl snippets to language-specif...

In this episode of The Developer Tools Podcast, Lucas and Luna dive into API idempotency keys — a critical pattern for preventing duplicate payments, duplicate orders, and data corruption in distributed systems. They explore how Stripe pioneered the concept, why idempotency breaks under retry storms, and how to implement idempotency keys correctly in your own API. Lucas explains the difference bet...

Lucas and Luna dive into the hidden costs of maintaining backward compatibility in public APIs. Using Stripe's 2015 API versioning model and GitHub's 2023 GraphQL schema changes as case studies, they explore why 'never breaking changes' can actually hurt developers more than they help. The episode covers strategies like sunset headers, migration windows, and the semantic versioning trap. Listeners...

Lucas and Luna dig into the hidden friction of API rate limits—how they don't just block abuse but also frustrate developers building legitimate integrations. Using examples from Stripe and GitHub, they explore why fixed-rate limits backfire on power users, how burst allowances help, and what companies like Twilio do differently. Plus, a look at the trade-off between protection and developer trust...

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...

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, no...

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. Th...

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 unclea...

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 Shop...

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 develo...

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 mont...

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 total...

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 curren...

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-...