The Technical Co-Founder Podcast with Fexingo: Engineering Founders, CTOs, and Building from Code

Episode 104 dives into the engineering trade-off between gRPC and Cap'n Proto, a zero-copy serialization format that one startup used to cut inter-service latency by 60 percent. Lucas walks through how the company swapped protobuf-generated gRPC stubs for raw Cap'n Proto messages over TCP, eliminating serialization overhead in their data pipeline. Luna presses on the costs: loss of HTTP/2 streamin...

In this episode of The Technical Co-Founder Podcast, Lucas and Luna dive into a single, sharp engineering practice: how one startup, a fast-growing fintech called Veridian, sets tail latency targets at the 99.9th percentile — aiming for under 10 milliseconds — on every critical microservice. They explain why traditional average latency metrics hide customer-impacting slowdowns, how Veridian uses a...

Lucas and Luna explore how a DeFi startup called VeriFi uses formal verification—mathematical proof—to guarantee smart contract correctness, avoiding exploits that cost billions in crypto. They discuss the trade-offs of proof-based development vs testing, how VeriFi caught a critical bug before launch, and why formal methods are trickling into traditional finance. With VeriFi's CTO as a case study...

Most teams run unit tests and think they're covered. But unit tests only check examples you think of. Property-based testing flips the model: you define invariants and let the computer generate thousands of random inputs to try to break them. Lucas and Luna examine how one startup — a fintech payments platform called PaySignals — adopted property-based testing after a production bug caused silent...

In this milestone 100th episode, Lucas and Luna explore how a startup called Prisma-like-but-not-Prisma is using WebAssembly to run database migrations directly in the browser. They break down why traditional migration tooling is painful, how WASM eliminates the dependency on local runtime environments, and what this means for developer onboarding and CI/CD pipelines. Lucas walks through the speci...

In Episode 99, Lucas and Luna dive into OpenTelemetry, the open-source observability framework that is rapidly replacing proprietary APM tools like DataDog and New Relic. They explore how one startup—a fintech processing billions in transactions—switched from a costly APM vendor to OpenTelemetry to unify metrics, traces, and logs. Lucas explains the technical architecture: how OpenTelemetry's coll...

In this episode of The Technical Co-Founder Podcast, Lucas and Luna explore how one startup leverages eBPF (extended Berkeley Packet Filter) to build a zero-latency database cache that runs inside the Linux kernel. They break down how eBPF allows the cache to intercept read requests at the system call level, bypassing the database entirely for hot data. The discussion covers the startup's architec...

Episode 97 of The Technical Co-Founder Podcast explores how a healthcare analytics startup called Synthos uses differential privacy to share sensitive patient data with researchers without violating HIPAA or GDPR. Lucas and Luna break down the epsilon parameter, the trade-off between privacy and accuracy, and how Synthos adds calibrated noise to aggregated queries to prevent re-identification atta...

Episode 96 of The Technical Co-Founder Podcast. Lucas and Luna explore how a logistics startup replaced a tangled mess of cron jobs and Bash scripts with a Directed Acyclic Graph (DAG) workflow engine built on Prefect. They break down the architecture: from dependency resolution and retry logic to real-time monitoring and cost savings. Discover why DAGs are becoming the standard for modern data pi...

In this episode, we explore how a startup called Edgeseek uses eBPF to run SQL queries directly in the Linux kernel, bypassing traditional database layers for ultra-low-latency packet filtering and observability. We break down the technical architecture — how they compile SQL to BPF bytecode, attach it to kernel hooks, and stream results back to user space at line rate — and discuss the trade-offs...

In this episode, Lucas and Luna explore how a fast-growing fintech startup, PayFlow, uses Falco — an open-source runtime security tool originally built by Sysdig — to detect and block container-level threats in real time. They walk through a specific incident where Falco's default rules caught a cryptominer deployment within seconds, saving the company from a potential six-figure cloud bill. The c...

On today's episode, Lucas and Luna explore how a startup called PromptLab uses feature flags to A-B test different AI prompt templates in production — without redeploying code. They break down the technical architecture: a custom prompt router that checks a LaunchDarkly-style flag, serves variant A or B, logs token usage and output quality, then feeds results into a feedback loop for prompt engine...

Episode 92 of The Technical Co-Founder Podcast dives into the concept of the 'paved road' — a pre-configured, opinionated platform that lets developers ship features without reinventing infrastructure. Lucas and Luna examine how a mid-stage B2B SaaS startup called Flowtile reduced its onboarding-to-first-deploy time from two weeks to under four hours by building an internal developer platform arou...

Lucas and Luna dig into why a growing number of engineering teams are rewriting performance-critical Python services in Rust. They break down the specific case of a real-time analytics startup that cut processing time from 12 seconds to under 200 milliseconds by porting its core data pipeline to Rust. The hosts discuss the trade-offs: Rust's steep learning curve and slower initial development vs....

Lucas and Luna dive into the story of a logistics startup that replaced nightly batch ETL jobs with serverless SQL queries against their data lake. The founders were struggling with a 24-hour delay in shipment tracking data. By switching to Athena and Presto on S3, they cut query latency from hours to seconds and reduced their data infrastructure bill by 60%. Lucas explains the technical architect...

This episode explores how a small AI startup replaced cloud-based GPU inference with WebGPU, running neural networks directly in the browser. Lucas and Luna break down the technical details: how WebGPU maps to modern GPUs, the performance trade-offs compared to server-side inference, and why latency-sensitive applications like real-time video filters benefit from client-side compute. They walk thr...

In this episode, Lucas and Luna explore how a growing fintech startup replaced polling-based dashboard refreshes with ASP.NET Core SignalR, cutting server load by 70% and delivering sub-200ms updates to 50,000 concurrent users. They walk through the startup's migration from WebSocket raw sockets to SignalR's automatic transport fallback, the hub architecture that avoided memory leaks, and the one...

In episode 87 of The Technical Co-Founder Podcast, Lucas and Luna dive into how one startup replaced WebSocket with WebTransport for real-time data streaming. They trace the journey of a live-video analytics startup that switched from WebSocket to WebTransport to cut latency from 150 milliseconds to under 10. Lucas explains the protocol differences — WebTransport runs on QUIC over UDP instead of T...

Episode 86 dives into how a small logistics startup, RoutePilot, moved from polling REST endpoints to building a real-time synchronization layer using WebRTC data channels. Co-founder and CTO Maya Chen explains why they chose peer-to-peer data channels over WebSockets for their delivery-driver app, how they handled NAT traversal with a simple STUN server, and the unexpected latency improvements th...

Episode 85 of The Technical Co-Founder Podcast explores how a seed-stage startup called EdgeBase replaced their entire client-side compute layer by compiling Go directly to WebAssembly. Lucas and Luna unpack why they chose Go over JavaScript for a browser-based WebAssembly module, how they handled memory management and cross-language function calls, and the surprising performance results — near-na...

Lucas and Luna dive into how one startup uses semantic versioning (SemVer) to manage dependencies across 150 microservices without breaking production. They walk through the specific strategy: MAJOR.MINOR.PATCH tags on every npm package, automated pre-release validation, and a bot that blocks incompatible upgrades. The episode centers on the real numbers: before SemVer, the team faced 12 productio...

In this episode, Lucas and Luna explore how a fintech startup called PayShield implemented rate limiting to prevent API abuse after a credential-stuffing attack compromised 2,000 accounts in one weekend. They break down the technical architecture — token bucket vs. sliding window, per-user vs. per-endpoint limits — and the business tradeoff: too aggressive and you block legitimate users, too loose...

Lucas and Luna dive into event sourcing, a data architecture pattern that stores every state change as an immutable event. They explore how one B2B SaaS startup used event sourcing to build a full audit trail, recover from data corruption in minutes, and enable time-travel debugging for customer support. The episode walks through the trade-offs: why the team chose PostgreSQL as their event store,...

In Episode 81 of The Technical Co-Founder Podcast, Lucas and Luna explore how a fast-growing fintech startup uses chaos engineering to test its production systems without breaking customer trust. They break down the specific tools the team deploys — including LitmusChaos and Gremlin — and explain how the startup runs weekly 'chaos hours' where it deliberately injects latency, kills pods, and simul...

Episode 80 of The Technical Co-Founder Podcast — Lucas and Luna explore how a 25-person B2B SaaS startup called LayerVault replaced traditional security tooling with developer-led practices. They walk through LayerVault's adoption of Sigstore for software supply chain signing, OpenSSF Scorecards for open-source dependency hygiene, and a lightweight threat modeling ritual that engineers run as part...