
Sign up to save your podcasts
Or


Who knew an aptitude test could recommend a career as a DBA—and get it right? In Episode 44 of Talking Postgres, PostgreSQL significant contributor Karen Jex walks Claire through her path from Oracle DBA to Postgres consultant, solution architect, and now senior software engineer at Snowflake. My favorite bits: a project switched to Postgres when nobody knew how to install it, faking it as the Postgres expert, and the culture shock of building your own HA and backups. Plus: the warm welcome at PGConf EU 2019 that pulled Karen into the Postgres community; the new Buddy Program at PGConf EU 2026; and moving to the French Alps for the love of mountain biking.
Previously on Talking Postgres:
Links mentioned in this episode:
In this episode, we covered:
00:00 Intro & music
01:55 Becoming a DBA completely by accident
05:46 "You're the database expert. You can figure it out."
12:37 Leaving Oracle, where everything comes bundled
17:23 From DBA to helping other DBAs
21:48 The PGDay France meeting that opened up the community
28:02 Why Django developers love Postgres
34:36 Stepping back to be close to home
43:54 "When I grow up, I want to be a DBA," said no one ever
51:42 How much should you delegate to AI agents?
59:22 Thirty five buddy pairings at PGConf EU
How does a fix for psql tab completion turn into 25 years of contributing to Postgres? In Episode 43 of Talking Postgres, Peter Eisentraut—PostgreSQL committer, core team member, SQL standards contributor, and Chief Architect of Database Servers at EDB—joins Claire to trace that journey. We dig into how scratch-your-own-itch development drew him in, why “the things you do, people welcome them” kept him coming back, and how Postgres changed as it grew from a small database community into a massive ecosystem where, from the Postgres mailing list perspective, “most of the user base is silent.” Plus: what it feels like when code you commit goes straight to everybody who uses Postgres, and the implications of the EU Cyber Resilience Act.
Previously on Talking Postgres:
Links mentioned in this episode:
In this episode, we covered:
00:00 Intro & music
02:14 Tinkering with the Commodore 64
07:57 The itch that became psql tab completion
15:43 Had to make opportunities
23:05 From posting at night to posting during the day
24:40 Why he stopped committing in the afternoon
28:04 On the ground floor of something that grew
30:34 What the Postgres core team actually does
31:47 Borrowing ideas from other OSS projects
36:51 Bringing Postgres into the SQL standards process
38:40 Getting to hang out with database nerds
42:01 Mentoring Postgres contributors
50:56 Making time for Postgres conferences
53:35 What the Cyber Resilience Act means for Postgres
57:36 Where are all the Postgres users?
1:07:00 Becoming a committer early on in Postgres
1:16:22 Contributing to Postgres isn't just writing code
1:19:40 Why FOSDEM is still his favorite
1:22:15 Finding familiar problems in a compiler devroom
1:26:14 Shout-out to the Planet Postgres feed
What’s your gold standard for deciding whether AI-written code is ready for production? In Episode 42 of Talking Postgres, Simon Willison—creator of Datasette, co-creator of Django, and prolific open-source developer—joins Claire to share how AI is changing the way he builds software today. We dig into why his test for shipping AI-generated code is “Could I explain this to somebody else?”, how engineering management skills can be surprisingly useful when managing AI agents, and how the bottleneck is no longer writing code but understanding it. Also: personal credibility, deep research, the Winchester Mystery House, slop proxies, and Simon’s observation that “Features are cheap. That doesn’t mean you should build them all.”
Previously on Talking Postgres:
Links mentioned in this episode:
In this episode, we covered:
00:00 Intro & music
04:00 A week of work before breakfast
09:12 Red-green TDD makes agents exercise every line
14:42 A million lines mean nothing if you don’t understand it
18:28 Finding low-hanging fruit among open PRs & issues
22:07 Getting work done while walking the dog
23:01 Gold standard: “Could I explain this to somebody else?”
28:27 Slop proxies add no value at all
30:49 Aggressive nitpicking reviews
35:01 Everything in software engineering is about trade-offs
41:16 Racoon heist game is only fun for 1 minute 15 seconds
43:46 New Year’s resolution to be more ambitious
48:11 You have to learn to throw things away
51:57 Features are cheap. That doesn’t mean you should build them all
1:00:45 Engineering management skills are so useful
1:04:44 QA specialists should be having a great time
1:07:53 Writing is thinking, don’t outsource it
1:08:23 Skill atrophy is a choice you make
1:10:07 I believe in people who are motivated
1:11:55 Systems are not set up to deal with this volume
1:18:48 Research agents stopped being absolute garbage
1:21:49 The whole point of the “human in the loop”
1:26:10 Dream: I want there to be more small businesses
What happens when a database engineer spends 13 years on SQL Server and then starts working on Postgres? In Episode 41 of Talking Postgres, Distinguished Engineer Panagiotis “Panos” Antonopoulos of Microsoft joins Claire to share what surprised him most about making that transition. We explore why Postgres felt familiar from the start—and what shocked Panos about the clean and lean Postgres codebase. We also dig into how public mailing lists and AI can help explain why design decisions were made, why more people are asking “why not Postgres?”, and the shared-storage architecture behind Azure HorizonDB.
Previously on Talking Postgres:
Links mentioned in this episode:
Intensely local user groups have been part of Jeremy Schneider's story from the start—from Linux meetups at a Michigan coffee shop to a closet server running an Oracle database nobody knew anything about. In Episode 40 of Talking Postgres, Postgres engineer and Seattle Postgres User Group co-organizer Jeremy Schneider joins Claire to share how community led him to Postgres after 15 years with Oracle—and why "it's like I was born to be here." Plus: the newly-updated Postgres Happiness Hints poster, advice for starting your own user group, and his POSETTE 2026 talk on CloudNativePG.
Previously on Talking Postgres:
Links mentioned in this episode:
What does it take to make Postgres and Azure fit together cleanly, like puzzle pieces? In Episode 39 of Talking Postgres, Adam Prout—distinguished engineer at Microsoft and a founding architect of Azure HorizonDB—joins Claire to trace his engineering journey from MemSQL to Postgres. We dig into shared-storage architecture and how HorizonDB pushes more work into the storage layer; why the team chose Rust; and what “good systems programming” looks like when being paranoid is a feature, not a bug. Along the way: startup vs big company tradeoffs, and how working on databases exposes you to so many interesting parts of computer science.
Previously on Talking Postgres:
Links mentioned in this episode:
It’s rare for developers to genuinely love their database, so why does Postgres earn that kind of loyalty? In Episode 38 of Talking Postgres, Gwen Shapira, co‑founder of Nile, joins Claire to trace her path from operating Oracle at scale, through a long NoSQL chapter, to co‑founding a Postgres company that wasn’t originally meant to be one—after discovering how much Postgres quietly gets right. Gwen shares how she spun up on Postgres after years with other databases (shout-out to the Happiness Hints and a strong sense of curiosity), and why Postgres has made her appreciate Codd. We also touch on blogging as a career catalyst, the upcoming PGConf.dev conference (where a lot of PG20 work gets discussed, and where we’ll celebrate 30 years of Postgres)—and the #1 rule of consulting: it’s always the consultant’s fault.
Previously on Talking Postgres:
Links mentioned in this episode:
Upcoming conferences & talks mentioned:
Why does SQL feel so approachable to some developers, and why do some of them end up spending their careers in the data layer? In Episode 37 of Talking Postgres, Charles Feddersen, who leads product for Postgres at Microsoft, joins Claire to talk about building Postgres services on Azure. We explore his path from classic ASP apps on Microsoft Access to distributed Postgres with Citus, the moment he installed pgAdmin and got pulled deeper into Postgres, and what it takes to build for the many different ways people rely on Postgres today—from Flexible Server and Azure HorizonDB to developer tooling—and why it’s important to support the upstream Postgres open source project.
Previously on Talking Postgres:
Links mentioned in this episode:
Upcoming conferences & talks mentioned:
Why would anyone willingly spend weeks chasing a slow query, knowing they might hit dead ends along the way? In Episode 36 of Talking Postgres, Tomas Vondra—Postgres committer and long‑time performance contributor—joins Claire to explain why hacking on Postgres performance is not just hard, but also fun. We dig into the process of investigating why queries are slow, how iteration and “wrong turns” are part of performance work, and why Tomas prefers meaningful performance puzzles over toy problems. Along the way, we talk about using benchmarks to build an understanding of a problem. Tomas also shares how even small changes in code can have outsized impact when that code is used a lot, and how the mathematics embedded in the Postgres query planner/executor makes the work especially rewarding.
Previously on Talking Postgres:
Links mentioned in this episode:
Are self-driving databases the Waymos of the future? In Episode 35 of Talking Postgres, Luigi Nardi—founder and CEO of DBtune and Stanford researcher—joins Claire Giordano to explore his journey from academic research to Level 5 autonomous database tuning. We dig into Luigi’s early days with a Commodore 64, how he began his PhD in Paris before he had learned to speak French, and how "professor privilege" in Sweden helped him bootstrap his startup. You’ll learn why the DBtune team chose database tuning and Postgres as their focus, what the Jevons paradox means for the future of developers, and how the “Level 5” vision fuels the DBtune team’s work toward a truly self-driving system.
Previously on Talking Postgres:
Links mentioned in this episode:
From the publisher's feed

289 Listeners

623 Listeners

582 Listeners

213 Listeners

987 Listeners

188 Listeners

12 Listeners

179 Listeners

140 Listeners

66 Listeners

21 Listeners

137 Listeners

102 Listeners

221 Listeners

142 Listeners