Show content
Listen to the audio, watch the video, or check out the Show Notes for a summary, key takeaways, and links to people, content, and tools we mention.
Audio
Listen on Spotify:
Listen on Apple Podcasts:
Video
Summary
Summary
John is live at Snowflake Summit, surrounded by hundreds of software vendors, and the scene sets the episode’s central question: how do you evaluate software purchases when AI has changed so many of the underlying assumptions?
Eric and John work through this modern challenge with a timeless three-part framework: fit, cost, and risk. Each one looks different now. Fit is harder to assess when you could theoretically build custom software that matches exactly what you need. Cost requires honest accounting for maintenance and AI token spend that didn’t exist before. And risk cuts in two directions: the risk of building something only one person can maintain, and the risk of buying from a startup that can’t match enterprise-grade security. Eric shares two real examples from Vercel where building paid off: a custom AI customer support agent handling over 80% of tickets, and a lead agent that reduced a nine-person outbound SDR team to one or two people.
The episode then turns to architecture. Salesforce’s move to headless is the signal that every serious enterprise provider is heading the same direction: separating the data layer from the UI so agents can interact with systems directly. Eric and John treat headless capability, or at least a credible roadmap toward it, as a new non-negotiable when evaluating vendors. They close on startup vs. enterprise: startups are more likely to have agentic interfaces already, but enterprise providers carry decades of security and domain knowledge that is genuinely hard to replace.
Key takeaways
Fit, cost, and risk still govern the decision, but AI changes all three: The framework for evaluating software hasn’t changed, but AI has shifted what each variable means. Fit is easier to customize through building, cost now includes maintenance and token pricing, and risk runs in both directions.
Prototype before you buy: Using AI to build a rough version of what you need is now the best way to clarify your actual requirements before committing to a vendor, whether you ultimately build or buy.
The hidden cost of building is the last 10%: Getting an AI-built prototype to 85% is fast and cheap. Getting it to production-grade and maintaining it indefinitely is where most teams underestimate the real cost of building.
Headless architecture is now a purchase requirement: The separation of data layer from UI so that agents can interact with systems directly is where all serious enterprise software is headed. If a vendor has no plan for it, that is a serious red flag.
Enterprise software earns its cost through accumulated expertise: Decades of security investment, compliance work, and edge-case handling are real value that a startup cannot replicate quickly. Not knowing what you don’t need yet is itself a reason to go enterprise.
Switching cost is the key variable in startup vs. enterprise: A technical team can afford to bet on a startup and migrate if needed. A company with 50 non-technical field reps faces a training and disruption cost that can dwarf any savings from a cheaper tool.
Personal software is an underrated third option: Giving individuals the ability to build lightweight local tools for their own workflows, without IT involvement or enterprise rollout, can produce productivity gains that no off-the-shelf purchase delivers.
Notable mentions and links
Snowflake Summit is the annual conference for Snowflake, one of the leading data warehousing and analytics platforms, and it serves as the physical backdrop for the episode’s opening observation about the density and confusion of the modern software vendor landscape.
Snowflake is the data platform John is attending the summit for, notable for having had the largest tech IPO in history at the time of its listing.
The build vs. buy decision is the central framework of the episode, a timeless question about whether a company should develop software internally or purchase it from a vendor, which AI has made newly complex by dramatically lowering the cost of building.
Total cost of ownership (TCO) comes up as the lens for evaluating software cost honestly, going beyond the sticker price to include maintenance, training, migration, and ongoing operations.
Vercel is Eric’s employer and provides two concrete examples of successful build decisions: an AI customer support agent handling over 80% of tickets, and an outbound lead agent that reduced a 9-10 person SDR team to 1-2 people.
Salesforce is the CRM giant used throughout the episode as the canonical enterprise software example, and its announcement of a headless architecture strategy is the jumping-off point for the architectural discussion.
Headless architecture is the design pattern in which the data layer of a software system is separated from its user interface, allowing agents and external applications to interact with the underlying data directly via APIs or command-line interfaces, without going through the product’s own UI.
Notion is mentioned as an example of an existing tool that has added strong AI functionality, illustrating the “third option” between building from scratch and buying a legacy product.
Linear is John’s own choice for project management over Jira, selected specifically for its AI and agentic features, and it appears as an example of a startup product worth betting on when you have a clear vision of your requirements.
Jira is the Atlassian project management tool that Linear and Asana are compared against throughout the episode.
Slack is mentioned both as the interface through which Vercel’s headless Salesforce integration surfaces to human approvers, and as John’s enterprise-tier choice for team communication over more startup-oriented tools like Discord.
SOC 2 is the security compliance standard Eric and John recommend asking startups about when evaluating their security posture.
Claude Desktop is the tool Eric uses to run personal local utilities for team planning and project tracking, as an example of the personal software approach.
MCP (Model Context Protocol) comes up as one of the interfaces through which agents can connect directly to headless systems, alongside command-line interfaces.