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

Fexingo
  • 0.0 (0)
  • Business
  • Updated Daily

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

  1. 15h ago

    Why Your API Should Rate Limit Per User Not Per Endpoint

    A single aggressive user can degrade your entire API. In this episode, Lucas and Luna break down why per-endpoint rate limiting is a blunt instrument and why per-user rate limiting — paired with user-tier quotas — is the smarter pattern. Using the real-world example of a fintech API that saw 40% error-rate spikes during a bot attack, they walk through the design decisions: user-level token bucket vs. fixed-window per route, how to handle burst traffic from legitimate power users, and why returning a 429 with a 'reset-at' timestamp beats a generic 'rate limit exceeded' message. They also touch on the business case — protecting paid tiers from free-tier abuse without throttling your highest-value customers. If you're building an API that serves multiple clients with wildly different usage patterns, this episode gives you the concrete trade-offs you need. #RateLimiting #APIDesign #BackendEngineering #FairUsage #TokenBucket #FexingoBusiness #BusinessPodcast #DeveloperTools #APIInfrastructure #SoftwareEngineering #Fintech #BotMitigation #UserTiering #HTTP429 #Scalability #APIReliability #BusinessAndTechnology #EngineeringPatterns Keep every episode free: buymeacoffee.com/fexingo

  2. 1d ago

    Why Your API Should Use Schema Registry for Contract Validation

    Episode 129 of The Developer Tools Podcast explores why API teams should adopt a schema registry for managing and validating contracts between services. Lucas and Luna discuss how platforms like Confluent's Schema Registry and open-source alternatives enable backward-compatible changes, prevent silent data corruption, and make it easier to evolve APIs without breaking consumers. They walk through a real example of a fintech startup that caught a breaking schema change in staging before it reached production, saving hours of debugging. The conversation covers trade-offs like added operational complexity and the need for strong CI/CD integration. If your team manages multiple services or event streams, this episode explains why a schema registry might be the missing piece in your API strategy. #SchemaRegistry #APIContracts #Confluent #Avro #Protobuf #JsonSchema #BackwardCompatibility #EventDriven #Microservices #Fintech #DeveloperTools #Business #Technology #FexingoBusiness #BusinessPodcast #APIDesign #ContractTesting #DataGovernance Keep every episode free: buymeacoffee.com/fexingo

  3. 1d ago

    Why Your API Should Use Event Sourcing for Audit Trails

    Episode 128 of The Developer Tools Podcast explores why event sourcing—storing every state change as an immutable event log—is becoming the gold standard for auditability in modern APIs. Lucas and Luna break down how companies like Stripe and GitHub use event sourcing to generate complete, tamper-evident audit trails without the performance nightmares of traditional database triggers. They walk through a concrete example: a fintech startup that replaced a chaotic MySQL audit table with a Kafka-based event store, cutting audit query time from 90 seconds to under 200 milliseconds. The episode also covers the operational cost—storage grows fast, replaying events can be slow—and when you should just use append-only tables instead. If you're building APIs where compliance, debugging, or replay matters, this is the pattern to know. #EventSourcing #APIDesign #AuditTrail #Fintech #SoftwareEngineering #Kafka #Stripe #GitHub #Compliance #EventStore #APISecurity #DeveloperTools #FexingoBusiness #BusinessPodcast #TechPodcast #DevToolsPodcast #Infrastructure #SOXCompliance Keep every episode free: buymeacoffee.com/fexingo

  4. 2d ago

    How API Audits Prevent Compliance Disasters

    Episode 127 of The Developer Tools Podcast explores why your API needs a robust audit log for compliance, security, and debugging. Lucas and Luna dive into the difference between logging and auditing, real-world failures like the 2021 Capital One breach investigation, and how structured audit trails with immutable, tamper-evident records saved a fintech startup from regulatory fines. They cover practical implementation patterns: append-only databases, hash chains for integrity, and the trade-offs between centralized and distributed audit systems. Listeners learn how to design APIs that not only serve data but also defend it, with concrete advice on metadata fields, retention policies, and integrating audit into existing middleware. Plus, a discussion on GDPR, SOX, and PCI-DSS requirements that make auditing non-negotiable for modern APIs. #API #AuditLog #Compliance #Security #DeveloperTools #Backend #Fintech #GDPR #SOX #PCIDSS #Logging #ImmutableLog #HashChain #FexingoBusiness #BusinessPodcast #BusinessAndTechnology #APIDesign #Infrastructure Keep every episode free: buymeacoffee.com/fexingo

  5. 2d ago

    Why Your API Should Use Idempotency Keys for Payment Retries

    In this episode, Lucas and Luna dive into the practical reasons why your API should treat retries as a first-class design concern, using idempotency keys. They walk through a real-world scenario from Stripe, where the failure to deduplicate a payment charge during a network timeout led to a customer being billed twice. Lucas explains how idempotency keys work under the hood—how the server stores the key, the response, and returns the same result for duplicate requests—and why this pattern goes beyond payments to any mutable operation like order creation or email sends. Luna pushes back on the implementation complexity, and Lucas shares a concrete example: a ride-hailing API that avoided double-booking rides by requiring an idempotency key on the 'request ride' endpoint. They also touch on the gotcha of key expiration and idempotency scope. The episode includes a light, integrated mention of listener support via buy me a coffee dot com slash fexingo. #API #Idempotency #PaymentRetries #Stripe #RideHailing #DistributedSystems #ErrorHandling #NetworkTimeouts #WebDev #SoftwareEngineering #Backend #FailureModes #DesignPatterns #BusinessAndTechnology #FexingoBusiness #BusinessPodcast #DeveloperTools #Engineering Keep every episode free: buymeacoffee.com/fexingo

  6. 3d ago

    Why Your API Should Use Consumer-Driven Contract Testing

    Episode 125 of The Developer Tools Podcast dives into consumer-driven contract testing (CDCT) — a pattern that flips traditional API testing on its head. Instead of providers dictating contracts, consumers write expectations first. Lucas and Luna explore how companies like Spotify and Netflix use CDCT to prevent breaking changes in microservices. They walk through a real example: a payment API that broke its billing service because the provider changed a field type without notifying consumers. The hosts discuss tools like Pact and Spring Cloud Contract, how CDCT fits into CI/CD pipelines, and why it reduces integration hell. If you manage or build APIs in a polyglot microservices environment, this episode gives you a concrete strategy to ship faster with fewer surprises. No fluff, just developer-focused tactics. #ConsumerDrivenContractTesting #CDCT #APITesting #ContractTesting #Pact #SpringCloudContract #Microservices #APIProvider #APIConsumer #IntegrationTesting #DevTools #CI/CD #BreakingChanges #PolyglotServices #Spotify #Netflix #BusinessAndTechnology #FexingoBusiness Keep every episode free: buymeacoffee.com/fexingo

  7. 3d ago

    Why Your API Needs a Dead Letter Queue Pattern

    Episode 124 of The Developer Tools Podcast explores a critical pattern for API reliability: the dead letter queue. Lucas and Luna walk through a real-world case at a major payment processor where a transient upstream failure caused a cascade of lost data—because the API had no fallback for messages that couldn't be processed. They explain how a dead letter queue acts as a safety net, capturing failed requests for manual or automated retry without blocking the main pipeline. The hosts discuss implementation trade-offs, including alerting strategies, retention policies, and replay mechanics. They also touch on when a DLQ is overkill versus essential, drawing on examples from event-driven architectures and webhook delivery systems. By the end, listeners understand how to design APIs that fail gracefully and never lose data silently. #API #DeadLetterQueue #Reliability #Resilience #MessageQueues #Webhooks #ErrorHandling #EventDriven #Backend #Infrastructure #DevTools #SoftwareEngineering #SystemDesign #FailureRecovery #Business #Technology #FexingoBusiness #BusinessPodcast Keep every episode free: buymeacoffee.com/fexingo

  8. 4d ago

    Why Your API Should Handle Rate Limit Errors Gracefully

    Episode 123 of The Developer Tools Podcast dives into the often-overlooked art of handling API rate limit errors gracefully. Lucas and Luna dissect real-world examples from GitHub and Stripe, exploring how clear headers, retry-after timestamps, and user-friendly error messages can turn a frustrating '429 Too Many Requests' into a smoother developer experience. They discuss the trade-offs between strict and lenient rate limiting, the importance of documenting limits transparently, and how good error design builds trust with your API consumers. No clickbait—just actionable insights for engineers building or maintaining APIs. #RateLimiting #APIErrorHandling #DeveloperExperience #GitHub #Stripe #HTTP429 #RetryAfter #APIDesign #Backend #Engineering #DevTools #Business #Technology #FexingoBusiness #BusinessPodcast #DeveloperToolsPodcast #API #SoftwareEngineering Keep every episode free: buymeacoffee.com/fexingo

See All (130)

About

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

Information