Elixir Mentor

Epizódy

• Francesco Ciulla on Winning Developer Adoption 27.06.2026 1h 37min

  In this episode of the Elixir Mentor Podcast, I step a little outside the BEAM to talk with Francesco Ciulla, Head of DevRel at Zerops. Francesco came up as a Rust developer and content creator with a 300,000-subscriber YouTube channel, and we get into the problem every builder runs into: getting developers to actually adopt what you ship.Francesco shares how he went from a corporate developer role at the European Space Agency to going independent, building an audience, and publishing his own Rust book. We talk about why distribution matters as much as the work itself, how public speaking changed him, and what being a developer looks like in 2026 with AI in the mix.From there we get into developer relations directly. Francesco explains what the job actually is, why you can't advocate for a product you don't believe in, and how he builds credibility for something he didn't write. He breaks down what Zerops does as a platform, how it compares to running things on GCP, and where developers fall off between signing up and getting real value.We also cover building a brand by declaring it and not stopping, why negative comments are a sign your audience is growing, language tribalism in tech, the risks of shipping vibe-coded projects without thinking about security, and what it takes to run Elixir on Zerops. A useful conversation for anyone trying to get a tool, a project, or themselves in front of developers.Resources Mentioned:- Zerops:https://zerops.ioConnect with Francesco:- X/Twitter:https://x.com/FrancescoCiull4- Website:https://francescociulla.comSponsors:- BEAMOps:https://beamops.co.uk- Paraxial.io:https://paraxial.ioSUPPORT ELIXIR MENTOR- Elixir Mentor:https://elixirmentor.com
• Jason Allum on Beadwork 20.06.2026 1h 33min

  Jason Allum returns to the Elixir Mentor Podcast to talk about Beadwork, his filesystem-native, git-synced issue tracker built for AI coding agents. With 40 years of building software and cleaning up other people's messes, Jason has a sharp read on where agentic coding falls apart.The conversation starts with Beads, the ticketing tool that inspired Beadwork, and why it eventually devolved into slop as it grew. Jason explains how coding agents lose the thread on long tasks through compaction and drift, and how a clean queue of tickets keeps an agent moving toward the right outcome instead of stitching back together the very thing it was told to tear out.From there we get into how Beadwork is built: a git-synced design backed by an orphan branch that sidesteps the merge conflicts that made earlier tools painful for teams and work trees. Jason walks through breaking large changes into epics and issues, pausing the agent to catch drift, and the parts of the job an agent still can't do, like architecture decisions, taste, and judgment.We also cover raising the quality bar on agent output, the efficiency argument around tokens, multi-project and team workflows, and the prompts Jason reaches for to get better plans. If you write code alongside an agent every day, this one is full of practical, common-sense workflow advice you can put to use right away.Resources Mentioned:- Beadwork:https://github.com/jallum/beadwork- Bedrock (from last time):https://github.com/bedrock-kv/bedrockConnect with Jason:- X/Twitter:https://x.com/mullaj- GitHub:https://github.com/jallumSponsors:- BEAMOps:https://beamops.co.uk- Paraxial.io:https://paraxial.ioSUPPORT ELIXIR MENTOR- Elixir Mentor:https://elixirmentor.com
• Tjaco Oostdijk on Drums to Elixir 07.06.2026 1h 31min

  In this episode of the Elixir Mentor Podcast, I talk with Tjaco Oostdijk, a drummer turned Elixir developer now working at DPG Media, one of the largest media companies in the Netherlands. Tjaco played drums professionally from the age of seven and has taught for 22 years, before landing in software through a music distribution company writing Ruby and eventually moving to Elixir nearly a decade ago.We get into what it takes to keep Elixir running inside a large enterprise. DPG adopted Elixir after a high-traffic Ruby service fell over at scale, and Tjaco describes the reality of working in a locked-down environment standardized on Kotlin, using Copilot with Anthropic models while waiting for Claude Code to be approved. He also talks about the colleagues who stay skeptical of AI tooling and why that skepticism can be healthy.The heart of the conversation is muziekles.app, the application Tjaco built for Dutch music teachers to run their entire teaching practice, from year-long scheduling and student accounts to homework and assignments. He explains why he deliberately keeps payments out of the product, how he thinks about onboarding teachers, and the build process using Phoenix, Ash, Claude Code, and Tidewave. We also compare notes on shipping side projects fast, multi-tenancy in Ash, and the differences between hardware and software work.If you are building with Elixir inside a company that hasn't standardized on it, or shipping a side project with AI tooling, this conversation is full of practical, hard-won lessons from someone doing both at once.Connect with Tjaco:- Website:https://drumusician.com- X / Twitter:https://x.com/drumusician- GitHub:https://github.com/drumusician- LinkedIn:https://www.linkedin.com/in/tjaco-oostdijkResources Mentioned:- muziekles.app:https://muziekles.app- Tidewave:https://tidewave.ai- Vocablo:https://vocabloapp.com- Kabisa:https://kabisa.nlSponsors:- BEAMOps:https://beamops.co.uk- Paraxial.io:https://paraxial.ioSUPPORT ELIXIR MENTOR- Elixir Mentor:https://elixirmentor.com
• Peter Ullrich on Hunting CVEs 30.05.2026 1h 50min

  Peter Ullrich returns to talk about a CVE hunt across the most-downloaded Hex packages, run with Claude Code on Opus 4.7. After ElixirConf EU pulled him into AI security, he started pointing Opus at popular libraries day and night, and within half an hour of his first serious attempt he found the Decimal vulnerability, where raising 10 to a huge power can blow up an application's memory.We get into what separates a real CVE from noise, how CVSS scoring works, and why reachability matters so much, since a flaw in Phoenix's default configuration is far more serious than a crash in a function nobody can call. Peter also walks through the process he runs with the EEF: verifying each issue, getting a second pair of eyes, coordinating a fix, and getting a number issued through a CNA, all while avoiding slop reports to maintainers. There's also a candid stretch on regulation and breach reporting.From there it widens out, including how Opus compares to Mythos, why Peter keeps coming back to Claude, his first impressions of Opus 4.8, and the economics, with a simple scan costing about $10 in API tokens. He also shares his Session Watcher plugin, an update on Killswitch and its browser-side encryption, thoughts on AEO, and how he uses dev containers to sandbox coding agents.Resources Mentioned:- The blog post that started this:https://peterullrich.com/what-the-cve- Peter's prompts:gist- Scrutineer:github.com/alpha-omega-security/scrutineer- Decimal advisory:GHSA-rhv4-8758-jx7v- EEF CNA published CVEs:cna.erlef.org/cves- EEF CNA security policy:cna.erlef.org/security-policy- Responsible disclosure guidelines:security.erlef.org- Anthropic article (the basis):red.anthropic.comConnect with Peter:- Website:peterullrich.com- GitHub:github.com/pjullrich- LinkedIn:linkedin.com/in/pjullrich- Bluesky:@peterullrich.comThanks to our sponsors:- BEAMOps:beamops.co.uk- Paraxial.io:paraxial.ioSUPPORT ELIXIR MENTOR- Elixir Mentor:elixirmentor.com
• Jason Allum on Bedrock 24.05.2026 1h 35min

  In this episode of the Elixir Mentor Podcast, I sit down with Jason Allum, creator of Bedrock and Beadwork and a 40-year veteran of computing, to talk about Bedrock: an embedded, distributed key-value store for Elixir with guarantees that go beyond ACID.Jason walks through the problem Bedrock solves, keeping distributed state consistent when the same data is read and written across many nodes. We get into why the BEAM's decades-old ideas map cleanly onto today's AI and agent workloads, how Bedrock borrows its architecture from FoundationDB, and what serializable transactions actually buy you over plain ACID.From there we dig into the machinery: log servers versus storage servers, the five-second version window and MVCC, letting it crash with supervision-tree thinking across a cluster, and how rows can live as values while indexes become keys. Jason also covers running distributed jobs with leases and what it takes to swap Postgres out for Bedrock.Along the way Jason makes the case that none of this is magic, that the real wins come from understanding your machine and the shape of your data. We finish on Beadwork, his lightweight system for managing agent tickets directly in git. If you build with Elixir or care about distributed databases, there's a lot here to chew on.Connect with Jason:- X/Twitter:https://x.com/mullaj- GitHub:https://github.com/jallumProjects:- Bedrock:https://github.com/bedrock-kv/bedrock- Beadwork:https://github.com/jallum/beadworkResources Mentioned:- Notes on the FoundationDB paper:https://uvdn7.github.io/notes-on-the-foundationdb-paper/- FoundationDB architecture:https://apple.github.io/foundationdb/architecture.html- Raft consensus algorithm (GeeksforGeeks):https://www.geeksforgeeks.org/system-design/raft-consensus-algorithm/- The Raft Consensus Algorithm:https://raft.github.io/Sponsors:- BEAMOps:https://beamops.co.uk- Paraxial.io:https://paraxial.io- Jido (Elixir AI Collective Discord):https://agentjido.xyz/discordSUPPORT ELIXIR MENTOR- Elixir Mentor:https://elixirmentor.com
• Michael Lubas on AI, Attack, and Defense 16.05.2026 1h 31min

  Michael Lubas, CEO of Paraxial.io, returns to the Elixir Mentor Podcast to talk about AI's dual role in cybersecurity: finding the vulnerabilities and writing the code that creates them. Michael was my first-ever guest, and a lot has changed since his last appearance — most of it driven by the inflection point of the past six months.We open with the Hex package manager penetration test that Paraxial conducted as part of the Aegis initiative under the Erlang Ecosystem Foundation, funded through Alpha Omega and its donors. Michael caught a remote code execution vulnerability before it shipped, and the public report gives Elixir a strong story to tell about the security of its package ecosystem. From there we get into GitHub Actions supply chain attacks, why zizmor is the tool every maintainer should be running, and the recent campaigns where malicious code targets release pipelines rather than application source.The conversation turns to the AI inflection point. The Erlang Ecosystem Foundation's CNA issued nine CVEs in all of 2025 and is on track for well over a hundred in 2026, driven by researchers like Peter Ullrich using AI to find vulnerabilities that already existed in source code. Firefox went from an average of 20 valid bug reports a month to over 400 in April 2026. Michael argues that Anthropic and OpenAI have been responsible stewards of these capabilities, and that defenders without access to state-of-the-art models are at a structural disadvantage. We also talk about why bug bounty programs are collapsing under AI-generated noise — something I experienced firsthand running Killswitch's program earlier this year.In the second half we get practical. Michael walks through what a real penetration test costs, when Claude Code is actually useful for solo developers, and the common Elixir-specific gotchas: binary term deserialization, server-side request forgery, dynamic atom creation, and the importance of staying inside Ecto's default query syntax. We also touch on Erik Stenman's BEAM Book, the difference between Paraxial and Sobelow, and what SOC 2 compliance does and does not cover.Resources Mentioned:- Securing Hex, the Backbone of the Elixir Ecosystem (Paraxial blog): https://paraxial.io/blog/hex-pentest- Hex Package Manager security audit report: https://hex.pm/reports/2026/paraxial.pdf- Erlang Ecosystem Foundation CNA: https://cna.erlef.org/- Behind the Scenes Hardening Firefox with Claude (Mozilla Hacks): https://hacks.mozilla.org/2026/05/behind-the-scenes-hardening-firefox/- Project Glasswing (Anthropic): https://www.anthropic.com/project/glasswing- The First CVE Wave (VulnCheck): https://www.vulncheck.com/blog/ai-assisted-vulnerability-discovery- Third major Linux kernel flaw in two weeks found by AI (ZDNet): https://www.zdnet.com/article/third-major-linux-kernel-flaw-in-two-weeks-found-by-ai/- What the CVE? — Peter Ullrich: https://peterullrich.com/what-the-cve- Nicholas Carlini, "Black Hat LLMs" (unprompted 2026): https://www.youtube.com/watch?v=1sd26pWhfmgConnect with Michael:- Website: https://paraxial.io- X/Twitter: https://x.com/paraxialio- LinkedIn: https://www.linkedin.com/in/michaellubas/- GitHub: https://github.com/paraxialioSponsors:- BEAMOps: https://beamops.co.uk- Paraxial.io: https://paraxial.io- Jido — Elixir AI Collective Discord: https://agentjido.xyz/discord- Support Elixir Mentor: https://elixirmentor.com
• Vasilis Spilka on LLMs & Ash 21.04.2026 1h 36min

  In this episode of the Elixir Mentor Podcast, I chat with Vasilis Spilka, Head of Software Development at Teacherspace, about building agentic software as a solo developer, the pairing of Ash and LLMs, and what it takes to ship a startup side project alongside a day job.Vasilis shares his path from Ruby on Rails in 2014 to nearly a decade of Elixir work across fintech, supply chain, and ad tech. We talk through Teacherspace's recent acquisition, the challenges of integrating with legacy Danish education contractors, and the three pivots it took to land on a working product.We spend a good chunk of the episode on Ash: why its unique DSL and introspection make it unusually strong with LLMs, how Spark lets you build your own DSLs, and why usage rules plus Igniter are a game-changer for library authors. Vasilis walks through his Claude Code workflow, the sculpting approach he uses for prototypes, and where he still won't let the LLM near — system design and API keys.The conversation also covers Communities, his local-first social platform; the paperclip-style autonomous company idea he's exploring with ash_typescript; whether LLMs actually understand anything; and the unglamorous reality of getting a consumer product off the ground through networking and volunteering. We close with practical tips on prompt phrasing and skill-file tweaks that meaningfully change output quality.Resources Mentioned:- Ash Framework: https://ash-hq.org- Tidewave: https://tidewave.ai- Igniter: https://hexdocs.pm/igniter- ash_typescript: https://github.com/ash-project/ash_typescriptConnect with Vasilis:- X/Twitter: https://x.com/vasspilka- GitHub: https://github.com/vasspilkaSponsors:- BEAMOps: https://beamops.co.uk- Paraxial.io: https://paraxial.io- Jido (Elixir AI Collective Discord): https://agentjido.xyz/discordSUPPORT ELIXIR MENTOR- Elixir Mentor: https://elixirmentor.com
• Luca Corti on Bringing Elixir to Fintech 12.04.2026 1h 40min

  In this episode of the Elixir Mentor Podcast, I sit down with Luca Corti, CTO at Sibill, a Milano-based fintech startup building cash flow management software for Italian small and medium businesses. Luca walks through his path from the early days of the internet at a small ISP in Milano to discovering functional programming at a major Italian telco—and why Elixir clicked for him immediately after years of fighting mutable state in OOP.Luca shares how he joined Sibill with an existing Python and TypeScript MVP, made the case for Elixir as the stack to rebuild on, and navigated integration with open banking APIs and Italy's national electronic invoicing system (SDI). We cover bank sync scheduling with Broadway and message queues, scaling a venture-backed engineering team to 40, and how fintech requirements around data privacy shape day-to-day engineering decisions.The conversation goes deep on the BEAM's real superpower—fault tolerance and resilience over raw concurrency—and Luca's hands-on approach to learning by building: an HTTP/2 server in Elixir a decade ago, and more recently using AI to help implement an HTTP/3 library. We also discuss hiring into an Elixir codebase, the challenges of selling SaaS to Italian SMBs accustomed to on-premises software, and a grounded take on AI tooling—useful, with clear limits, and nowhere close to replacing experienced engineers.Resources Mentioned:- Sibill: https://sibill.com- ankh (HTTP/2 library): https://github.com/lucacorti/ankh- lapin (AMQP client): https://github.com/lucacorti/lapinConnect with Luca:- X/Twitter: https://x.com/lucacorti- LinkedIn: https://www.linkedin.com/in/lucacorti- GitHub: https://github.com/lucacortiSponsors:- Paraxial.io: https://paraxial.io- Jido (Elixir AI Collective Discord): https://agentjido.xyz/discordSUPPORT ELIXIR MENTOR- Elixir Mentor: https://elixirmentor.com
• Steve Domino on Starting a Fintech 04.04.2026 1h 35min

  Steve Domino is the co-founder and CTO of Crew, a fintech startup building what he calls the most powerful checking account in the world — one with programmable automation rules, a family-scoped AI financial assistant, and zero of the fees that make traditional banking frustrating. He came up through startups, spent time at Divvy before its Bill.com acquisition, and brought his Elixir experience directly into Crew's foundation.We cover a lot of ground on the product side: how Crew's "Autopilot" rules engine lets users program their money (and the recursion checks it took to make that safe), why Crew consolidated savings and checking into a single account, how the team handles high-value deposits without physical branches, and what's coming — business accounts, wills and trusts, family investing, and a credit card designed to work like a debit card. Steve also talks through the challenge of projecting bills years into the future to keep balance reservations accurate, and how building and using your own product surfaces problems fast.On the Elixir side, Steve talks about why fintech is a natural fit for the BEAM — Crew decisions on card transactions in under 250 milliseconds — and how Oban became central to their reliability story when partner services go down. He shares what drew him to Elixir personally (pattern matching, the pipe operator, the with block), reflects on the Utah Elixir ecosystem that Divvy and Podium helped build, and explains how Penny, their AI financial assistant, is scoped per family so it can never reach outside a user's own data.We also spend time on career and engineering culture: Steve's take on the "Extreme Ownership" mindset that shaped how he grew into a leadership role, why he asks candidates to design something they'd actually build at Crew instead of solving puzzles, and his honest concern that developers leaning entirely on AI may lose the ability to think critically about architecture. Good conversation throughout.Resources Mentioned:- Extreme Ownership (book): Amazon- Oban: oban.proConnect with Steve:- Crew: trycrew.com- LinkedIn: linkedin.com/in/steve-dominoSUPPORT ELIXIR MENTOR- Elixir Mentor: elixirmentor.comSPONSORS- Paraxial.io — Elixir-first app security: paraxial.io- BEAMOps — Scalable Elixir infrastructure: beamops.co.uk- Jido — Elixir AI Collective Discord: agentjido.xyz/discord
• Mark Cotner on Scaling Telecom 29.03.2026 1h 32min

  Mark Cotner is a DBA managing around a thousand databases by day and a telecom CTO by night — building hospitality cable networks for RV parks, nursing homes, and apartment complexes at 100% annual growth. In this episode, he walks through the infrastructure, the business, and the two-year project that just landed on Hex: Timeless, an embedded observability suite for Elixir built on Rust NIFs, hitting 3 million metric inserts per second with 14:1 compression.We get into what a hospitality network actually looks like — branded cable hardware, DOCSIS provisioning, and mesh Wi-Fi across dispersed sites — and how Mark's team handles monitoring across thousands of cable modems using a full Elixir stack (DHCP, TFTP, NTP, and Ash). He also shares how a frustrating Ansible setup led him to build something he thought should exist: a lightweight, embeddable observability backend that drops into a Phoenix app in under five minutes via Igniter, with less than 5% CPU overhead.The technical core of the conversation covers the Timeless architecture in depth — PCO compression for metrics, OpenZL for logs and traces, 15 rounds of iteration before landing on a single consolidated Rust NIF, and why the Elixir-to-Rust translation layer ended up being the real bottleneck. Mark also talks benchmarking against Victoria Metrics on a 192-core AWS ARM instance, the custom C web server (Rocket) he built to cut HTTP latency 30x below Bandit, and how supervision trees let him pack an entire DOCSIS provisioning stack into one Elixir app without worrying about cascading failures.Whether you're curious about Elixir in telecom, Rust NIF development, time series database internals, or just want to hear what 30 years of observability experience looks like applied to the BEAM, this one is packed.Resources Mentioned:- Timeless on Hex: https://hex.pm/packages/timeless_phoenix- Timeless website): https://timelessmetrics.comConnect with Mark:- X/Twitter: https://x.com/awksedgreepSUPPORT ELIXIR MENTOR- Elixir Mentor: https://elixirmentor.comSponsored by BEAMOps — scalable Elixir deployments and infrastructure migrations, authors of Engineering Elixir Applications: https://beamops.co.ukElixir AI Collective Discord — your community for coding Elixir with AI: https://agentjido.xyz/discord
• George Millo on Agentic Coding 22.03.2026 1h 31min

  George Millo — creator of Learn Phoenix Live View and alumnus of the Gauntlet AI fellowship — joins me to talk through what really changes when you commit to LLM-driven development. George went through Gauntlet's intensive 10-week program built around LLM maximalism, came out the other side rethinking how he builds software, and has spent the past year working on an AI-first engineering team applying those lessons in production.We spend a lot of time on the practical realities of agentic coding: verification debt (the gap that grows between your mental model and what the AI actually built), the importance of planning before prompting, why George works in small self-contained PRs, and how he uses Codex and Claude Code in parallel tabs without losing track of what's happening. We also get into the debate around vibe coding, spec-driven development, testing pitfalls, and why deep technical knowledge matters more now — not less — when AI is writing most of the code.The conversation covers where Elixir fits in an AI-first world: the BEAM's process model as a natural fit for agent architectures, Phoenix shipping with an agent.md file, Tidewave's approach to closing the feedback loop, and why Elixir's tooling consistency puts it ahead of the JavaScript fragmentation George deals with at his day job. We also get into the security risks that come with AI-assisted development — giving LLM tools codebase access, the OpenClaw skills marketplace vulnerabilities, and the kinds of security mistakes that are now much easier to ship without noticing.George closes with practical advice for anyone hesitant to adopt agentic workflows: stay curious, ask the AI to explain the code it writes, build something outside your comfort zone, and put in the reps.Resources Mentioned:- Learn Phoenix Live View: https://learnphoenixliveview.comConnect with George:- X/Twitter: x.com/georgemillo- LinkedIn: linkedin.com/in/millogSponsors:- Paraxial.io — Elixir-first application security: paraxial.io- Jido — Elixir AI Collective Discord: agentjido.xyz/discordSUPPORT ELIXIR MENTOR- Elixir Mentor: elixirmentor.com
• Leandro Pereira on MDEx 14.03.2026 1h 35min

  Leandro Pereira is back on the Elixir Mentor Podcast — this time to dive deep into MDEx, his Rust-powered Markdown library for Elixir. MDEx is built on the Comrak Rust crate, runs 31x faster, and uses 3,500x less memory than existing Elixir alternatives. We also get into Lumis, his standalone syntax highlighting engine powered by tree-sitter and Neovim themes.Leandro walks through why he chose a Rust NIF over a pure Elixir implementation, what it took to ship Lumis as its own project, and the surprisingly hard technical challenge at the heart of MDEx: streaming Markdown for AI applications. We discuss how MDEx handles incomplete Markdown fragments in real time, what the upcoming Components feature unlocks for Phoenix/LiveView developers, and how the HEEx parser integration works under the hood.We also cover the human side of maintaining two solo open source projects: how Leandro prioritizes, uses AI to chip away at the backlog, and thinks about monetization. The conversation goes deeper into how the AI era has changed Markdown's role in the ecosystem, the pitfalls of vibe coding, and what it really takes to get an open source project noticed — including the uncomfortable truth that marketing matters more than most developers want to admit.The episode closes with a wide-ranging conversation on developer growth — the Dunning-Krueger curve, making the mental shift from OOP to functional programming, and why Elixir feels easier once it finally clicks. A great listen for anyone building libraries, wrestling with Rust NIFs, or navigating open source in the Elixir ecosystem.Resources Mentioned:- MDEx: https://mdelixir.dev- MDEx on Hex: https://hex.pm/packages/mdex- Lumis: https://lumis.sh- Lumis on Hex: https://hex.pm/packages/lumisConnect with Leandro:- X/Twitter: https://x.com/leandrocesquini- GitHub: https://github.com/leandrocp/mdexSPONSORS- Paraxial.io: https://paraxial.io- Jido (Elixir AI Collective Discord): https://agentjido.xyz/discordSUPPORT ELIXIR MENTOR- Elixir Mentor: https://elixirmentor.com
• Josh Price on Ash & Alembic 11.03.2026 1h 54min

  Josh Price, founder & CTO of Alembic and one of the core forces behind Ash Framework, joins me for a wide-ranging conversation that starts with the origin story of Alembic, winds through the history of GraphQL and Ash, and lands on Clarity — his new interactive introspection and visualization tool for understanding your Ash codebase. Josh has been writing Elixir for over ten years and building Alembic for nine, which gives him a rare perspective on how the ecosystem has matured and where it's headed in an agentic world.We trace how Josh's frustration with real-time data at a gaming company pointed him toward Elixir and Erlang, how that led to an obsession with GraphQL domain modeling, and how that obsession eventually collided with Ash — which turned out to solve exactly the problems he'd been hacking around for years. We talk about what Ash actually is beyond an API generator, why auto-generated migrations are criminally underrated, and why the developers who resist Ash most are often the ones in the middle of the experience curve. Josh also shares the inside story of how slowing Zack Daniel down was actually the best thing that ever happened to the Ash ecosystem.A big chunk of the conversation covers the AI moment we're in right now — Claude Code workflow tips (including the /insights command and how to keep session history beyond 30 days), why CLIs are beating MCPs for LLM tool use, Claude Code skills and usage rules for progressive disclosure, and how Clarity grew from Ash's built-in introspection into something far more interesting: an in-memory Erlang digraph knowledge graph of your entire Elixir application. Josh also shares his take on multi-model databases, the disappearance of the UI, and why the only limits left for software engineers are taste, judgment, and imagination.Resources mentioned in this episode:- Alembic: https://alembic.com.au- Clarity (Hex): https://hex.pm/packages/clarity- Ash Framework: https://ash-hq.org- Ash Framework book: https://pragprog.com/titles/ldash/ash-framework/- Killswitch: https://killswitch.appConnect with Josh:- Website: https://alembic.com.au- X/Twitter: https://x.com/joshprice- LinkedIn: https://www.linkedin.com/in/joshcpriceSponsors:- Paraxial.io: https://paraxial.io- Jido: https://agentjido.xyz/discordSUPPORT ELIXIR MENTOR- Elixir Mentor: https://elixirmentor.com
• Thomas Athanas on Building Without Vendor Lock-In 07.03.2026 1h 38min

  Thomas Athanas, Head of Engineering at LevelAll, joins me on the Elixir Mentor Podcast to talk through the infrastructure, architectural, and leadership decisions that come with building systems you actually own — and what happens when vendor lock-in catches up with you in production.Thomas walks through LevelAll's move away from Fly and Gigalixir toward bare metal hardware, the thundering herd problem that comes with serving 50,000 concurrent education users, and why they made the call to remove both Phoenix LiveView and Ash framework from production. We get into Ash APS premium support, JSONB query challenges, and the tradeoffs of leaning on a framework when hiring for it is hard.We talk about using AI as a development planning tool and context keeper for managers — including Thomas's "Lore Master" concept, where AI agents preserve institutional knowledge so it never walks out the door. From there we get into the Auth0 rate limiting incident that hit during a live onboarding, the FusionAuth migration that followed, enterprise auth requirements like OIDC and SAML, and the bcrypt hash conversion work that made it all possible. Thomas also shares his work on a custom Erlang-based bare metal deployment agent and his approach to Postgres configuration and backups with pgBackRest.The second half covers founder mode mentality, total ownership of problems, the player-coach leadership style, Sanity CMS vendor lock-in, building an audience vs. building a customer base, and practical advice for technical founders who keep procrastinating with features instead of making sales.Connect with Thomas:- X/Twitter: https://x.com/ThomasAthanas- LinkedIn: https://www.linkedin.com/in/thomasathanas/Sponsors:- BEAMOps: https://beamops.co.uk- Paraxial.io: https://paraxial.io- Jido: https://agentjido.xyz/discordSUPPORT ELIXIR MENTOR- Elixir Mentor: https://elixirmentor.com/?utm_source=elixir-mentor
• Amos King on sharing knowledge 21.02.2026 1h 37min

  In this episode of the Elixir Mentor Podcast, I sit down with Amos King, Senior Staff Backend Engineer at Adobe, founder of Binary Noggin, and longtime Elixir community contributor. We dig into mentorship, knowledge sharing, and the team dynamics that make software organizations actually thrive.Amos traces his non-traditional path into software — from structural engineering to manufacturing automation to Erlang on Navy submarines — and explains how that background shapes how he thinks about building reliable systems. We talk about his decade running Binary Noggin, why he ultimately made the move to Adobe, and the hard lessons learned when the consulting market shifted. From there the conversation goes deep on team composition, why diverse backgrounds matter more than uniform credentials, and the mindset shift from object-oriented to functional programming.We also get into the practical side of Elixir: when GenServers are the right tool and when they're not, why vibe coding worries him from an engineering quality standpoint, and why teaching is actually a selfish act that benefits the teacher most. We close out with what separates a real staff engineer from a senior one, a call for the Elixir community to revive local meetups, and a real-world database query optimization story that reframes how to think about performance problems.Resources Mentioned:- Binary Noggin: https://binarynoggin.comConnect with Amos:- X/Twitter: https://x.com/Adkron- LinkedIn: https://www.linkedin.com/in/amosking/SPONSORS- BEAMOps: https://beamops.co.uk- Paraxial.io: https://paraxial.io- Jido: https://agentjido.xyz/discordSUPPORT ELIXIR MENTOR- Elixir Mentor: https://elixirmentor.com
• Dave Lucia on Building TV Labs 14.02.2026 1h 29min

  In this episode of the Elixir Mentor Podcast, I chat with Dave Lucia, CTO and Co-Founder of TV Labs. Dave returns to the podcast to talk about building an AI-powered smart TV testing platform that lets media companies test streaming apps on hundreds of real physical devices through the cloud — all built primarily in Elixir.Dave walks through the founding of TV Labs, from meeting his co-founder at Bloomberg over a decade ago to building an MVP with WebRTC during the pandemic. He covers the technical challenges of managing a massive device lab — procurement, warm-up processes, security isolation, session management, and keeping hundreds of TVs, Rokus, Fire TVs, and Apple TVs healthy and available for enterprise clients. The platform uses a custom KQL query engine for real-time device matching and a licensing system built on Elixir GenServers sharded across the cluster.We get into Dave's 10-year history with Elixir in production, starting at Bloomberg and carrying through to TV Labs. He explains why Elixir was the right fit for orchestrating physical devices at scale, from its standard library minimizing dependencies to building Apple device communication libraries and even a Lua 5.3 interpreter directly in Elixir. Dave also shares how TV Labs uses OpenTelemetry for observability and runs multi-region infrastructure with session recording capabilities.The conversation shifts to AI, where Dave describes using Claude and other LLMs to accelerate development, automate operations like vendor management and support emails, and build AI agents for QA testing. We wrap up with a candid discussion on whether AI will replace developers and how these tools are fundamentally changing what's possible for small teams.Connect with Dave:- Website: https://davelucia.com- X/Twitter: https://x.com/davydog187- LinkedIn: https://www.linkedin.com/in/david-lucia-a395441b/Sponsors:- BEAMOps: https://beamops.co.uk- Paraxial.io: https://paraxial.io- Jido: https://agentjido.xyz/discordSUPPORT ELIXIR MENTOR- Elixir Mentor: https://elixirmentor.com
• Rob Walling on Building SaaS 07.02.2026 1h 28min

  In this episode of the Elixir Mentor Podcast, I chat with Rob Walling — serial entrepreneur, author of The SaaS Playbook, founder of MicroConf, co-founder of TinySeed, and the guy who bootstrapped Drip to a successful exit. With over 20 years of experience and investments in 230+ B2B SaaS companies, Rob shares the playbook for building software businesses without venture capital.Rob breaks down his stairstep method of entrepreneurship, explaining why technical founders should start with small wins on existing marketplaces before attempting a standalone SaaS product. We get into the common traps developers fall into — refusing to learn marketing, building products that "sell themselves," and bootstrapping two-sided marketplaces without an existing audience. Rob also shares the full Drip origin story, from a plateauing email tool to a marketing automation platform that took off after listening to customer feedback.We cover the four core SaaS skills every founding team needs (marketing or sales, product, and engineering), how to decide between finding a co-founder and learning to sell on your own, and where successful SaaS ideas actually come from — 72% were discovered at a day job. Rob also weighs in on how AI is reshaping the SaaS landscape, why he doesn't believe in a "SaaS apocalypse," and what really drives company valuations. His final advice for technical founders: think in years, not months, and invest in learning entrepreneurship the same way you invested in learning to code.Resources Mentioned:- The SaaS Playbook: https://saasplaybook.com- MicroConf: https://microconf.com- TinySeed: https://tinyseed.comConnect with Rob:- Website: https://robwalling.com- X/Twitter: https://x.com/robwalling- LinkedIn: https://www.linkedin.com/in/robwalling- Podcast: https://www.startupsfortherestofus.comSponsors:- Paraxial.io: https://paraxial.io- Jido: https://agentjido.xyz/discordSUPPORT ELIXIR MENTOR- Elixir Mentor: https://elixirmentor.com
• Jamil Bou Kheir on Firezone 31.01.2026 1h 37min

  In this episode of the Elixir Mentor Podcast, I chat with Jamil Bou Kheir, founder of Firezone, a YC-backed open-source zero-trust access platform. Jamil shares his journey from eight years as a Cisco security engineer to building an enterprise VPN replacement using Elixir and Rust.We explore how Firezone started as a simple WireGuard configuration tool that hit the front page of Hacker News, then evolved into a full zero-trust platform. Jamil explains the architecture decisions behind using Elixir for the control plane and Rust for the data plane, including their custom ICE implementation called Snownet for NAT traversal. The conversation covers practical insights on Phoenix PubSub for real-time signaling, Postgres WAL streaming for change data capture, and running a global Erlang cluster.Jamil also shares candid advice from the Y Combinator experience, discussing funding, product-market fit, and the challenges of rebuilding a product architecture mid-startup. We dive into the realities of open source licensing, security through transparency, and SOC 2 compliance. The episode touches on AI in development workflows, managing large refactors, and marketing strategies for technical founders.Whether you're interested in networking protocols, building with Elixir at scale, or the startup journey from side project to funded company, this conversation offers valuable perspective from someone doing it in production.Resources Mentioned:- Firezone: https://www.firezone.dev- WireGuard: https://www.wireguard.com- Github: https://github.com/firezone/firezoneConnect with Jamil:- Website: https://www.firezone.dev- X/Twitter: https://x.com/jamilbk- LinkedIn: https://www.linkedin.com/in/jamilbk/- GitHub: https://github.com/jamilbkSponsors:- Paraxial.io: https://paraxial.io- Jido: https://agentjido.xyz/discordSUPPORT ELIXIR MENTOR- Elixir Mentor: https://elixirmentor.com
• Enrique Leigh on Prende 24.01.2026 1h 31min

  In this episode of the Elixir Mentor Podcast, I chat with Enrique Leigh, founder of Prende Café in Chile. We explore how he built a specialty coffee subscription business using Phoenix LiveView, his journey from marketing and ad tech to becoming an Elixir developer, and why he chose custom e-commerce over platforms like Shopify.Enrique shares the WordPress crash during a Chile vs Brazil match that sparked his interest in Elixir, and how building his own coffee business became the perfect way to finally learn the language. We discuss UX principles from "Don't Make Me Think," marketing frameworks like Jobs to Be Done, and the counterintuitive lesson that adding more checkout steps can actually increase conversions. He also explains the specialty coffee value chain, from sourcing beans in Brazil to roasting and running a physical café alongside the e-commerce platform.Our conversation covers practical entrepreneurship topics including MVP philosophy, building subscription and coupon systems with Mercado Pago, using Oban for job scheduling, and content marketing strategies that work. Enrique shares insights on balancing Iron Man training with running a family business, productivity techniques from the Flow Research Collective, and the evolving landscape of ad tech after GDPR. We also discuss his future goals of learning Nerves to build IoT coffee machines and the growing Elixir community in Chile.The episode wraps up with advice for aspiring entrepreneurs: just launch it. Enrique emphasizes that the cost of inaction is often greater than the cost of action, and with tools like LLMs that work remarkably well with Elixir, there's never been a better time to build your own products.Resources Mentioned:- Don't Make Me Think: https://sensible.com/dont-make-me-think/- Oban: https://getoban.pro/- Jido: https://agentjido.xyz/discordConnect with Enrique:- Website: https://www.prendecafe.cl- X/Twitter: https://x.com/EnriqueLeigh- LinkedIn: https://www.linkedin.com/in/enriqueleigh/Sponsors:- Paraxial.io: https://paraxial.io- Jido: https://agentjido.xyz/discordSUPPORT ELIXIR MENTOR- Elixir Mentor: https://elixirmentor.com
• Mike Ratliff on Building an Energy Tech Startup 17.01.2026 1h 35min

  In this episode of the Elixir Mentor Podcast, I chat with Mike Ratliff, a 30-year tech veteran and CTO currently building an energy tech startup. Mike shares his path from Ruby threading nightmares to leading 20-engineer Elixir teams, and how discovering the BEAM transformed his approach to building 24/7 grid systems.We dig into the technical challenges of power grid software, including distributed energy resource management, solar intermittency, and why utilities remain cautious about new technology. Mike explains how his current startup is tackling transmission interconnection problems using Elixir, and his plans to incorporate AI agents through the Jido framework.The conversation shifts to how AI is reshaping development teams and startup economics. Mike makes a compelling case for small, elite teams over large engineering organizations, sharing his philosophy on profit per headcount and why he believes we'll see one-person unicorn companies emerge. We discuss rethinking technical interviews for the LLM era, the Ash framework in production, and why great engineers become even greater with AI tools.Mike wraps up with hard-won startup wisdom: build painkillers not vitamins, learn to tell stories that move people, and understand that nobody buys on facts alone. Whether you're building energy infrastructure or SaaS products, this conversation offers practical perspective on scaling with small teams.Connect with Mike:- LinkedIn: https://www.linkedin.com/in/mike-ratliff-3096571/Sponsors:- Paraxial.io: https://paraxial.io- Jido Discord: https://agentjido.xyz/discordSUPPORT ELIXIR MENTOR- Elixir Mentor: https://elixirmentor.com/?utm_source=elixir-mentor