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

In this episode, Lucas and Luna dig into the story of a logistics startup that replaced its core Python backend with Rust. They walk through why the team decided to rewrite, how they justified the months of engineering time to the board, and the surprising performance gains that followed. The hosts also discuss the hidden costs of a language migration — onboarding friction, ecosystem gaps, and the...

In this episode of The Technical Co-Founder Podcast, Lucas and Luna explore the counterintuitive choice one startup made: saying no to venture capital in favor of bootstrapping to profitability. They focus on the story of a B2B SaaS company that grew to $2 million in annual recurring revenue without taking a dollar from VCs, instead relying on revenue-based financing and customer prepayments. The...

Lucas and Luna dig into the story of a twenty-person startup that operated fully asynchronously for eighteen months — no standups, no meetings, just written docs and recorded decisions. They walk through the specific tools the company used, how on-call rotations worked without real-time handoffs, and why the CTO eventually reintroduced a single weekly synchronous hour. This episode covers the real...

In this episode, Lucas and Luna explore how feature flags — also known as feature toggles — allowed a small engineering team at a fast-growing B2B SaaS startup called SyncFlow to deploy code to production multiple times a day without breaking anything for users. They walk through the specific case of SyncFlow's migration from a monolithic monthly release cycle to a continuous deployment model powe...

In this episode of The Technical Co-Founder Podcast, Lucas and Luna dive into a single, focused engineering decision: how a five-person startup migrated its production database from MongoDB to PostgreSQL in a single weekend — without downtime or data loss. They unpack the specific technical choices behind the migration: why the team chose pgloader for schema conversion, how they handled document e...

What happens when your startup's shared monorepo becomes a bottleneck? Lucas and Luna examine the story of a 12-engineer startup that deleted 50,000 lines of shared code — not because the code was bad, but because the coupling was slowing every team's deployment velocity. They walk through the three-month transition: how the engineering lead mapped dependency graphs, why they chose a domain-based...

In this episode of The Technical Co-Founder Podcast, Lucas and Luna explore how early-stage startups can adopt RFCs (Request for Comments) to make better engineering decisions. They dive into a specific case: a seed-stage startup that avoided a costly six-month rewrite by writing a one-page RFC first. They discuss the minimal format that works for a three-person team, when to escalate an RFC to th...

Lucas and Luna explore how Amazon's long-internal practice of writing proposals-as-documents — the 'narrative memo' — has been adapted by high-performing startups as a lightweight RFC (Request for Comments) process. They walk through a specific case: a 20-person fintech startup that used RFCs to avoid a costly six-month architecture rebuild, saving an estimated $300k in wasted engineering time. Lu...

Lucas and Luna dive into the practice of writing Request for Comments (RFC) documents as a decision-making tool for engineering teams. They explore how a five-person startup used lightweight RFCs to align on architectural choices, reduce bikeshedding, and speed up delivery — without the overhead of big-company processes. The episode walks through a concrete example: a team deciding between a monol...

When your startup's biggest rival goes under, do you buy the wreckage? This episode walks through the story of a small B2B SaaS company that acquired a bankrupt competitor and had to merge two completely different codebases without losing customers or engineering momentum. Lucas and Luna break down the acquisition price, the six-week integration timeline, the decision to keep both authentication s...

Most engineers think open source is about code. But according to Sarah Chen, a former CTO who has hired at three Y Combinator startups, the first open source library you publish is actually a job interview — and most technical founders get it wrong. In this episode, Lucas and Luna break down Sarah's framework: how a well-crafted library signals communication skills, taste, and resilience to senior...

Episode 18 of The Technical Co-Founder Podcast with Fexingo dives into bug bounty programs and vulnerability disclosure. Lucas and Luna explore why even early-stage startups should set up a structured way for security researchers to report flaws, using the case of a fintech startup that avoided a major breach by listening to a white-hat hacker. They discuss the difference between bug bounties and...

When you're raising money, investors often ask for a code review — but what if your code is a mess? In this episode, Lucas and Luna unpack the story of a startup that literally hid its GitHub repository from VCs during Series A diligence. They explore the ethical tightrope between 'we're building fast' and 'we're hiding our technical debt,' and how the founding engineer managed the anxiety of show...

In episode 16 of The Technical Co-Founder Podcast, Lucas and Luna explore how a startup called Atmo — a weather intelligence platform — adopted an internal open-source model to speed up development without sacrificing quality. When co-founder and CTO Jenna Kline realized her six-person engineering team was duplicating work across microservices, she introduced internal open-source repositories with...

When your co-founder wants to change direction, the technical lead is often the one who has to rebuild everything — or kill the idea before it drains the runway. In this episode, Lucas and Luna break down the decision framework that one early-stage startup used to pivot from a B2B scheduling tool to a consumer wellness app without losing their core engineering team or burning cash on a rewrite. Th...

In this episode of The Technical Co-Founder Podcast, Lucas and Luna explore the ideal engineering team structure for early-stage startups. They break down the Spotify model, examine when to hire specialists versus generalists, and discuss how one real startup restructured from a flat team of five to a squad-based system with leads. They cover the trade-offs between functional and cross-functional...

In this episode, Lucas and Luna explore the art of sunsetting features — when and how to kill a product or feature that no longer serves the business. They anchor on the story of Basecamp's decision to remove their message board feature in 2024, a move that initially sparked user backlash but ultimately streamlined the product. Lucas breaks down the technical and cultural challenges: sunk cost fal...

Episode 12 of The Technical Co-Founder Podcast tackles the hardest word in engineering leadership: no. Lucas and Luna dissect a real case from a mid-stage SaaS startup where the CTO turned down a $2 million customer’s feature request. They explore the framework behind the decision—opportunity cost, architectural debt, and team focus—and why saying no actually saved the company. Drawing on lessons...

Lucas and Luna challenge the conventional wisdom that startups should only hire senior engineers. Using the case of a fast-growing B2B SaaS company that deliberately built a team of 60% junior developers, they explore the surprising advantages: lower burn rate, stronger internal mentoring culture, and engineers who grow into the exact stack you need. They also address the risks — slower initial ve...

In this episode, Lucas and Luna dive into a counterintuitive idea: not all technical debt is bad. They examine how companies like Etsy, Shopify, and even early Amazon deliberately carried technical debt to move faster, capture market share, and survive. Lucas explains the difference between reckless debt and strategic debt, using the example of a startup that chose to build a monolith over microse...

When do you commit to a full rewrite? Most engineers know the hesitation — it's the biggest technical gamble you can take. In this episode, Lucas and Luna break down the calculus behind the rewrite decision through the lens of one engineer who actually went through it: a senior developer at a mid-stage SaaS company who inherited a tangled codebase built by five different founders over seven years....

Lucas and Luna dive into why so many early-stage startups hire junior engineers first and why that's often a mistake. They break down the trade-offs using the example of a real fintech startup that hired a senior infrastructure engineer as employee number four — and how that decision saved them six months of rewrites. The episode covers the hidden costs of mentorship, the 'learning vs. leverage' r...

In this episode of The Technical Co-Founder Podcast with Fexingo, Lucas and Luna dig into the real-world story of a CTO at a mid-stage SaaS company who slashed their AWS bill by 40 percent—without sacrificing performance or developer velocity. They walk through the specific tactics: right-sizing instances, committing to reserved instances, eliminating zombie resources, and using spot instances for...

In this episode of The Technical Co-Founder Podcast, Lucas and Luna dive into the engineering strategy behind scaling a product from zero to 100,000 active users with only two engineers. They break down the real-world case of a SaaS startup that hit this milestone in 18 months without VC funding, using a single PostgreSQL database, a queue-based architecture, and ruthless feature triage. Lucas exp...

Episode 5 of The Technical Co-Founder Podcast dives into a concrete cloud-cost optimization case study. Lucas and Luna walk through how a real startup's engineering team reduced their AWS bill by 40 percent — not by turning off servers, but by rethinking architecture patterns, choosing the right instance families, and negotiating reserved-instance pricing. They break down the specific decisions: m...