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

Episode 54 of The Technical Co-Founder Podcast explores how a fintech startup called Proton Finance uses AI pair programming tools to onboard junior developers in half the usual time. Lucas and Luna discuss the specific tool they chose — GitHub Copilot with custom context — and how they pair it with structured code review. The episode covers the startup's onboarding metrics before and after, the p...

Episode 53 of The Technical Co-Founder Podcast dives into the counter-trend of monolith-first architecture with a case study from a real startup. Lucas and Luna explore how one company reversed its microservices migration after hitting complexity walls, cutting deployment time by 80 percent and reducing infrastructure costs by half. They walk through the specific triggers: a team of eight managing...

Episode 52 of The Technical Co-Founder Podcast dives into event sourcing—a data architecture that treats every state change as an immutable event. Lucas and Luna explore how a real startup, order-management platform Riverbend, adopted event sourcing not for auditing but to rebuild a critical feature without a database migration. They walk through the concrete trade-offs: the append-only log that d...

In this episode of The Technical Co-Founder Podcast, Lucas and Luna dive into how one startup—a fintech processing millions of transactions—uses TypeScript's type system to catch bugs before they ever reach production. They explore the specific types and patterns that prevent entire categories of runtime errors, from discriminated unions to branded types. The hosts walk through a real example: how...

Episode 50 of The Technical Co-Founder Podcast. Lucas and Luna explore how a growing fintech startup reduced production incidents by 40 percent by modeling their entire microservice architecture as a dependency graph. They walk through the specific tooling — an open-source graph database called DGraph — and the cultural shift of making every team own their upstream and downstream services. They di...

Startups often fall into the trap of planning a full system rewrite — a multi-month bet that can sink the company. In this episode, Lucas and Luna examine how one startup avoided that trap by using incremental rewrites, replacing their monolithic e-commerce backend piece by piece over eighteen months without freezing feature development. They break down the strategy: strangler fig pattern, interna...

Episode 48 of The Technical Co-Founder Podcast. Lucas and Luna explore how a startup called Kodex cut new engineer onboarding from six weeks to five days by redesigning their developer experience (DX). They break down the specific changes: a one-command setup script, a self-service sandbox environment, and a living documentation system that stays synced with the codebase. Lucas explains how Kodex...

On this episode, Lucas and Luna explore how a fast-growing SaaS company uses feature flags to decouple deployment from release, enabling daily deploys with zero downtime. They walk through the specific implementation: a phased rollout system with automatic rollback triggers and a kill-switch dashboard. The hosts discuss the engineering trade-offs—flag debt, testing complexity, and team discipline—...

In Episode 46 of The Technical Co-Founder Podcast, Lucas and Luna dive into how one startup, a mid-stage SaaS company called FormLens, automated its code review process to reduce cycle time from 2.5 days to under 8 hours. They break down the specific tooling choices — GitHub Actions with custom workflows, auto-assigning reviewers based on file ownership, and merging pull requests with passing chec...

In episode 45 of The Technical Co-Founder Podcast, Lucas and Luna break down how a growing B2B SaaS startup turned its on-call rotation from a dreaded engineering chore into a structured product feedback loop. The company, a mid-market analytics platform with about 40 engineers, noticed that repeated alerts for the same customer-facing issues were being ignored by the on-call team. Instead of puni...

In episode 44 of The Technical Co-Founder Podcast, Lucas and Luna explore how a small startup replaced its stale internal documentation with literate programming — a technique where code and explanation live in the same file. They walk through the team's transition from a scattered Notion wiki to a documentation-as-code pipeline using a custom tool built on top of Jupyter Notebooks. The discussion...

Most startups hire engineers by coding tests and whiteboard interviews. But one early-stage B2B SaaS company found that traditional technical interviews were screening for performance anxiety, not engineering skill. In this episode, Lucas and Luna break down how a 12-person startup replaced live coding with a paid writing exercise: candidates wrote a technical RFC for a real problem the team faced...

Episode 42 of The Technical Co-Founder Podcast explores how a 15-person startup used workflow automation to eliminate three headcount requests without laying anyone off. Lucas and Luna break down the specific tools (n8n, Make, custom Slack bots), the engineering trade-offs, and why this approach beats hiring for certain repetitive tasks. They discuss the upfront investment in automation vs. ongoin...

In this episode of The Technical Co-Founder Podcast, Lucas and Luna explore how a mid-stage SaaS startup uses error budgets to align engineering velocity with product goals. They break down the concept—inspired by Google's SRE model—and walk through a specific case where a company set a 99.9% availability target, tracked a monthly error budget of 43 minutes of downtime, and used that budget to dec...

Episode 40 of The Technical Co-Founder Podcast dives into how a real startup replaced lines of code and story points with a single metric: 'deployed value per developer-day.' Lucas and Luna unpack the story of a 40-person B2B SaaS company that publicly vowed to cut its feature-development cycle from 14 days to 3 days. They walk through the three specific signals the team tracked—cycle time, revert...

Episode 39 of The Technical Co-Founder Podcast digs into how a growing startup decides which tech debt to fix and which to leave alone. Lucas and Luna walk through the story of a 50-person SaaS company that used a weighted scoring system — balancing customer impact, developer velocity, and maintenance cost — to build a tech debt backlog that actually got done. They break down the specific criteria...

Most startups build monolithic codebases. Then they hit the wall at around ten engineers. In this episode, Lucas and Luna look at how a real startup — a B2B SaaS company called Station — broke its backend into internal APIs before it hit twenty employees. They walk through how Station defined API contracts upfront, used those contracts to parallelize work between frontend and backend teams, and cu...

In this episode of The Technical Co-Founder Podcast, Lucas and Luna explore how a five-person startup turned its own debugging logs into a structured technical interview process. They break down the specific case of CargoVerify, a logistics API company that recorded every blocker its engineers hit during onboarding and then reverse-engineered those logs into a repeatable interview rubric. Lucas ex...

Episode 36 of The Technical Co-Founder Podcast dives into the practice of writing Request for Comments (RFCs) before writing code. Lucas and Luna explore how this approach fosters alignment, catches design flaws early, and scales decision-making across engineering teams. They discuss a real-world example from a startup that decreased rework by 30% after adopting RFCs, and contrast it with the 'jus...

Episode 35 of The Technical Co-Founder Podcast. Lucas and Luna dive into the story of a bootstrapped B2B SaaS startup called StitchFlow that slashed its AWS bill by 70 percent using spot instances and a custom spot-termination handler. They walk through the architecture: a Kubernetes cluster with priority classes, a Python script that listens for the two-minute AWS termination notice and gracefull...

In this episode of The Technical Co-Founder Podcast, Lucas and Luna explore the practice of chaos engineering — deliberately injecting failures into production systems to uncover weaknesses before they cause outages. They look at how one startup, a real-time payments platform, used controlled experiments like shutting down servers and corrupting data to test its infrastructure. Lucas breaks down t...

Episode 33 of The Technical Co-Founder Podcast dives into property-based testing, a technique that flips traditional unit testing on its head. Lucas and Luna explore how one startup—a fintech handling real-time transaction reconciliation—used property-based testing to uncover edge cases their hand-written tests missed. They break down the difference between example-based and property-based approac...

In episode 32, Lucas and Luna explore how a small infrastructure startup called Formal Inc. uses formal methods—mathematical proofs embedded in the development process—to guarantee their core networking library has zero runtime errors. They walk through the specific tool (Dafny), the trade-offs in developer velocity, and why the startup believes the upfront cost saves millions in post-deployment d...

In Episode 31 of The Technical Co-Founder Podcast, Lucas and Luna explore how one startup uses cryptographic code signing to ensure every line of code shipped comes from a trusted developer. They walk through the story of a small fintech company that implemented mandatory GPG signing after a supply-chain scare, the technical choices between GPG and Sigstore, and why this practice matters more than...

Episode 30 of The Technical Co-Founder Podcast explores how a small SaaS startup called NightOwl used a seemingly trivial UX feature—a dark mode toggle—as a data collection and growth experiment that transformed their product roadmap. Lucas and Luna break down the specific metrics NightOwl tracked, the A/B test that doubled free-trial conversion, and the engineering decisions behind building a low...