Postgres and Open Source Experts

In this episode, JD sits down with Amanda Nystrom, CEO of Command Prompt and National Board Certified Health & Wellbeing Coach, to talk about wellness for people in tech and why most advice misses the point.Rather than focusing on quick fixes, discipline, or one-size-fits-all tools, Amanda explains why awareness has to come first. They explore how environment, nervous system load, work culture, and internal narratives all shape health outcomes, often more than diet or exercise alone.

Welcome back to More Than a Refresh Presents: T3D Sessions.In this episode, Joshua “JD” Drake talks with Lev Kokotov, creator of PGDog, about one of the hardest problems in PostgreSQL: horizontal scaling in real production systems.Lev shares lessons learned from scaling Postgres at Instacart during periods of extreme growth, and why existing approaches often fail when applied to large, established applications. They explore what happens when rewriting millions of lines of code simply isn’t an option—and why tooling needs to adapt to applications, not the other way around.

Welcome to Episode 54 of More Than a Refresh, where JD sits down with Kevin Jernigan to talk about AI hype versus reality, the real limits of scaling large language models, and why more data centers don’t necessarily mean smarter systems.They explore the economic and technical constraints behind today’s AI boom, what current models get fundamentally wrong, and what it would take to move beyond pattern matching toward something more meaningful.

In this episode, JD sits down with Brian Fehrle to unpack a deceptively simple PostgreSQL operation that can trigger serious performance issues: adding a new column with a default value.Brian explains how PostgreSQL’s optimization—introduced to avoid table rewrites and long locks—can leave data “virtual” rather than physically written to disk. While this makes schema changes faster, it can quietly confuse the query planner, skew statistics, and turn previously fast queries into production problems, especially when the new column is used in WHERE clauses.This episode is a must-listen for DBAs, Postgres operators, and engineers managing large PostgreSQL workloads—especially in cloud environments—who want to avoid subtle changes that can cascade into days of degraded performance.

In this episode, JD is joined by Alan Lazaros for a conversation about systems, consistency, and the long game behind meaningful progress. While most people focus on big breakthroughs, this discussion explores how small, intentional actions—repeated daily—compound into exponential results over time.Drawing from personal experience and years of coaching, Alan reflects on health, wealth, relationships, and fulfillment as interconnected systems. Rather than chasing intensity or quick wins, the episode reframes growth as something built gradually, through steady effort and long-term thinking.

In this AWS-focused episode, Command Prompt Founder Joshua “JD” Drake talks with James Campbell about one of the most common (and most expensive) sources of cloud surprises: storage choices. James breaks down how AWS offers an overwhelming number of options across EBS, S3, and Glacier tiers, and why “flexibility” often translates into misconfiguration, avoidable spend, and hidden performance bottlenecks.They also dig into a frequent pain point: backups and snapshots. JD and James explain what people misunderstand about AWS snapshots, why “snapshot completion time” can be deceptive, and how resilience assumptions can fall apart if you don’t plan for availability zone / region boundaries and the time it takes to copy data across them. If your AWS bill feels unpredictable—or your retention and DR plan is more hope than strategy—this episode reframes storage as a first-class architecture decision, not an afterthought.

In this episode, Command Prompt Founder Joshua “JD” Drake talks with Glauber Costa about AgentFS, a virtual file system designed to solve one of the hardest problems in modern AI infrastructure: managing state and data isolation for fast-moving, sandboxed AI agents. Glauber explains how AgentFS treats the data layer as part of the sandbox itself, enabling agents to snapshot, move, and resume execution in milliseconds without relying on heavy infrastructure.They explore why traditional systems become too slow and complex as agent-based workloads scale, how representing an agent’s state as a lightweight, SQLite-backed file system enables rapid mobility, and why rewriting SQLite in Rust was necessary to address concurrency and performance limitations. The conversation offers a practical look at how AI is pushing infrastructure toward lighter, faster, and more state-aware designs.

JD welcomes back Andrew Sullivan, former Chair of the Internet Architecture Board and former President & CEO of the Internet Society. Listen in as they continue their conversation on the “enshittification” of the internet, how consolidation and regulation are reshaping a network built on open standards, and why we may be closer than we think to losing the internet as we once knew it.

JD sits down with Amanda Nystrom to explore an often-overlooked reality in the tech industry: wellness is not a personal side concern—it’s a performance issue.Drawing parallels between system audits, Postgres health checks, and human behavior, Amanda explains why teams can’t expect long-term reliability, scalability, or high performance if they ignore the health of the people behind the systems. Just as neglected infrastructure leads to outages and technical debt, ignored habits and burnout eventually undermine human performance.This conversation reframes wellness in terms engineers understand: sustainability, performance, and future readiness. If you care about building resilient systems, this episode makes the case for building resilient people, too.

In this episode, Command Prompt Founder Joshua “JD” Drake talks with Andrew Smith, Senior Developer/DBA, about a foundational concept in software engineering that quietly powers modern systems: code generation and single sources of truth.Andrew walks through the evolution of code generation—from early macros and assembly language to modern model-driven architectures—and explains why generating code from a centralized definition is one of the most effective ways to build scalable, maintainable systems. Using practical examples from C, PostgreSQL, and modern frameworks, he breaks down how code generation reduces duplication, prevents drift, and keeps complex systems aligned over time.