The API Podcast with Fexingo: REST, GraphQL, and Modern Web APIs

Episode 54 of The API Podcast explores how API metadata — things like operation IDs, descriptions, and deprecation notices — can dramatically reduce integration friction. Lucas and Luna walk through a real case from Stripe's API documentation, where a single metadata field saved a developer team weeks of debugging. They discuss how OpenAPI 4.0 is making metadata more structured, why metadata-drive...

Lucas and Luna dive into API pagination strategies, exploring why cursor-based pagination is overtaking traditional offset-limit approaches. They discuss real-world trade-offs using examples from GitHub, Twitter, and Postgres databases, and explain how poor pagination can silently double your database load. The episode also covers cursor encoding, stability over ordered datasets, and the surprisin...

WebTransport is a new protocol that combines the low latency of WebSockets with the reliability of HTTP/3. In this episode, Lucas and Luna explore how WebTransport enables efficient, bidirectional, real-time communication for applications like live gaming, collaborative editing, and IoT streaming. They walk through a concrete example: a startup building a multiplayer drawing app that switches from...

Episode 51 of The API Podcast digs into WebSockets — the protocol that flips the typical request-response model on its head. Lucas and Luna walk through a concrete example: how a real-time dashboard for a logistics startup cut latency from three seconds to under a hundred milliseconds by switching from polling to a persistent WebSocket connection. They discuss when WebSockets make sense (and when...

In this milestone 50th episode, Lucas and Luna dive into how modern API teams are moving away from explicit versioning in favor of backward-compatible evolution. They examine a real-world case: how a major payment processor—think Stripe-level scale—added a new required field to an existing endpoint without bumping the version number or breaking existing integrations. The conversation covers the th...

Episode 49 of The API Podcast explores how API designers are preparing for the threat of quantum computers breaking current encryption. Lucas and Luna discuss the specific algorithms NIST is standardizing, why hybrid certificates matter now, and how companies like Cloudflare are already testing post-quantum TLS. They examine the timeline concern—harvest now, decrypt later—and what that means for A...

Webhooks have become the backbone of real-time event-driven integrations across modern APIs. In this episode, Lucas and Luna break down how webhooks differ from polling, why platforms like Stripe and GitHub rely on them for instant notifications, and the hidden challenges developers face—retry logic, security verification, and idempotency. They walk through a concrete example: a payment webhook fr...

Episode 47 of The API Podcast dives into the 'thundering herd' problem — when thousands of clients retry simultaneously after a rate limit reset, crushing your API. Lucas and Luna explore how Stripe and GitHub use headers like Retry-After and X-RateLimit-Reset to stagger retries, why exponential backoff isn't enough, and how API gateways can deduplicate incoming requests to keep services stable. T...

Lucas and Luna explore the practice of API stubbing — how developers replace real backends with lightweight mock services during testing. They break down a specific case: a fintech startup that cut its integration-test suite from 45 minutes to under 3 by stubbing payment and ledger APIs. The episode contrasts stubs with mocks and fakes, explains when stubbing hides real bugs (the 'false green' pro...

Episode 45 of The API Podcast dives into the growing rift between informal design conventions and the push for machine-verifiable API contracts. Lucas and Luna examine how tools like OpenAPI 4.0, AsyncAPI, and JSON Schema enable automated validation, break fewer clients, and catch mismatches before they reach production. Through the example of a mid-size e-commerce platform that cut integration bu...

When a microservice goes down, cascading failures can take out your entire system. In this episode, Lucas and Luna dig into the circuit breaker pattern—a design approach that prevents one failing API call from snowballing into a full outage. They walk through a real example: how a payment gateway timeout could freeze an e‑commerce checkout, and how a circuit breaker with a half‑open state avoids t...

In this episode, Lucas and Luna explore the impact of OpenAPI 4.0 on API design and standardization. They discuss how the new specification improves contract-first development with enhanced type safety, better tooling support, and streamlined documentation. The hosts examine real-world adoption by companies like GitHub and Stripe, and explain why OpenAPI 4.0 matters for reducing integration fricti...

Lucas and Luna dive deep into API idempotency, the unsung hero preventing double charges and duplicate actions in distributed systems. They break down how Stripe's idempotency keys work, why the concept is tougher than it sounds, and what happens when idempotency fails. Using concrete examples from payment APIs and order systems, they explain the trade-offs between strict and loose idempotency, an...

Episode 41 of The API Podcast dives into the hidden cost of runaway API requests. Lucas and Luna unpack a real-world case: a fintech startup whose monthly cloud bill jumped from $12,000 to $47,000 in three months due to an unthrottled internal API. They walk through how exponential backoff, token bucket algorithms, and thoughtful rate limit headers turned the situation around—and why most teams di...

Episode 40 of The API Podcast examines the shift from traditional API versioning to versionless or 'evolvable' APIs. Lucas and Luna discuss how companies like Stripe and GitHub now design endpoints that never increment a version number, using techniques like additive-only changes, field deprecation with sunset headers, and backward-compatible schema evolution. They walk through a concrete example:...

In this episode of The API Podcast, Lucas and Luna explore idempotency keys — the unsung design pattern that stops payment APIs from charging a customer twice when a network failure causes a retry. They trace how Stripe made idempotency a standard expectation, explain why a simple unique key in the request header is surprisingly hard to implement correctly at scale, and unpack real-world edge case...

In this episode, Lucas and Luna dive into the challenge of API schema evolution — how services like Stripe and GitHub manage to add fields, change types, and deprecate endpoints without breaking their millions of client integrations. They discuss real-world strategies including additive-only changes, deprecation headers, and the 'tolerant reader' pattern. The conversation covers specific examples...

In this episode of The API Podcast, Lucas and Luna explore how API gateways have evolved from simple reverse proxies into critical security perimeters. They break down a real-world case: how a mid-sized fintech company used gateway-level policies to block a credential-stuffing attack before it reached their application servers. Topics include gateway authentication strategies, the trade-off betwee...

When a network call fails, should your API retry immediately or back off? This episode of The API Podcast drills into retry strategies — exponential backoff, jitter, and the dreaded thundering herd problem. Lucas and Luna unpack how Stripe handles idempotent retries for payment intents, why Amazon S3 uses truncated exponential backoff, and what happens when every client retries at the exact same s...

Most developers think of caching as a performance optimization—something that makes your API faster, snappier, less painful for users. But this episode flips that script and looks at caching as a financial instrument. Lucas and Luna walk through a real case: a mid-stage SaaS company that was burning $80,000 a month on its API infrastructure, mostly on redundant database queries and repeated comput...

Episode 34 of The API Podcast: Lucas and Luna dive into the mechanics of API rate limiting — why it's not just about blocking bad actors but about protecting shared resources and keeping your app responsive. They unpack the token bucket and leaky bucket algorithms using real-world examples from GitHub and Twitter, explain how headers like X-RateLimit-Remaining help developers build smarter clients...

HTTP/3 and the QUIC protocol are redefining how APIs communicate over the internet, promising faster connections and better reliability. In this episode, Lucas and Luna break down the key differences from HTTP/2, why companies like Google and Cloudflare are leading the charge, and what API developers need to know before making the switch. They dive into real-world performance gains, challenges wit...

In episode 32 of The API Podcast, Lucas and Luna explore how companies like Stripe and Twilio turned API documentation from a neglected afterthought into a core competitive advantage. They break down the specific design patterns — interactive consoles, copy-paste-ready code samples, consistent error messages — that make developers fall in love with an API. The hosts discuss why the best docs feel...

Episode 31 of The API Podcast examines the shift away from traditional versioning in REST and GraphQL APIs. Lucas and Luna explore how companies like Shopify and GitHub are adopting versionless approaches—using techniques like additive changes, field deprecation with sunset headers, and GraphQL's built-in schema evolution. They discuss a real case where a major e-commerce platform cut breaking cha...

In this episode of The API Podcast, Lucas and Luna explore how distributed systems maintain data consistency without traditional transactions. They walk through the saga pattern using an e-commerce case study: placing an order, reserving inventory, and processing payment across three separate services. You'll learn why two-phase commits fail in microservices, how choreographed sagas keep services...