Jen Abel is the co-founder of JJellyfish and GM of enterprise sales at State Affairs. She is widely regarded as one of the sharpest practitioners in enterprise sales, and for that reason, this is her third visit to the podcast. In our first conversation we went deep on founder-led sales; in our second we mapped the $1M–$10M playbook. This time we do something I’ve never seen on another podcast: walk step by step through the full enterprise sales cycle. Most people think it’s five steps. Jen shows it’s closer to 15.

In our in-depth conversation, we discuss:

1. Why the standard five-stage CRM pipeline is a forecasting tool, not a sales process, and what the real 15-step cycle looks like

2. The “pincer model” for landing the first meeting at the executive and N-minus-one level simultaneously

3. How to craft a two-to-three-sentence message around giving them “alpha”

4. How to run an intro call that extracts maximum intelligence before you ever show a demo

5. The two-to-three-day pilot structure, how to define success jointly, and when to charge for a longer pilot versus giving it away

6. Navigating pricing, procurement, redline negotiations, and the final signature without losing momentum

—

Brought to you by:

WorkOS—Make your app enterprise-ready, with SSO, SCIM, RBAC, and more

Mercury—Radically different banking, now with Command

—

Where to find Jen Abel:

• X: https://x.com/jjen_abel

• LinkedIn: https://www.linkedin.com/in/earlystagesales

• Website: https://www.jjellyfish.com

—

Where to find Lenny:

• Newsletter: https://www.lennysnewsletter.com

• X: https://twitter.com/lennysan

• LinkedIn: https://www.linkedin.com/in/lennyrachitsky/

—

In this episode, we cover:

(00:00) Introduction

(02:49) Why Jen is giving away her enterprise sales playbook

(05:54) Example: selling AI legal tech to SpaceX

(09:11) Step 1: Landing the meeting

(18:44) Step 2: Running the intro call

(30:00) Step 3: Running a follow-up call

(36:30) Step 4: Prepping the pitch/frame for demo

(38:36) Step 5: Running the demo

(46:45) Step 6: Post-demo debrief

(48:59) Step 7 through 9: Preparing for and running the pilot

(01:03:44) Why the standard five-stage CRM pipeline doesn’t work

(01:04:49) Step 10: Post-pilot session

(01:07:48) What a healthy enterprise win rate looks like

(01:11:45) Steps 11 through 14: Navigating procurement and getting the signature

(01:18:01) How to think about expansion

(01:19:18) How buyers can say no without wasting everyone’s time

(01:21:53) Why enterprise sales is a lot like product management

(01:22:27) Closing thoughts

—

Referenced:

• State Affairs: https://stateaffairs.com

• The ultimate guide to founder-led sales | Jen Abel (co-founder of JJELLYFISH): https://www.lennysnewsletter.com/p/master-founder-led-sales-jen-abel

• “Sell the alpha, not the feature”: The enterprise sales playbook for $1M to $10M ARR | Jen Abel: https://www.lennysnewsletter.com/p/the-enterprise-sales-playbook-1m-to-10m-arr

• SpaceX: https://www.spacex.com

• Lemlist: https://www.lemlist.com

• Palantir: https://www.palantir.com

• Jason Lemkin on X: https://x.com/jasonlk

• We replaced our sales team with 20 AI agents—here’s what happened | Jason Lemkin (SaaStr): https://www.lennysnewsletter.com/p/we-replaced-our-sales-team-with-20-ai-agents

• Building a world-class sales org | Jason Lemkin (SaaStr): https://www.lennysnewsletter.com/p/building-a-world-class-sales-org

• Careers at State Affairs: https://stateaffairs.com/careers

—

Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email podcast@lennyrachitsky.com.

—

Lenny may be an investor in the companies discussed.

To hear more, visit www.lennysnewsletter.com



Download audio: https://pscrb.fm/rss/p/api.substack.com/feed/podcast/211488420/7df0a97cc37a6e391091a046a0020be4.mp3

Starting August 25, we're running a free three-part live series on Microsoft Reactor that takes you from "what is a hosted agent?" to a deployed, orchestrated multi-agent application, all built in VS Code with the Microsoft Foundry Toolkit.

 

👉 Register for the series

Building agents, without leaving your IDE.

Building an AI agent usually means context-switching between a portal, a terminal, a notebook, and three browser tabs of documentation. You write some instructions, deploy, wait, test in a playground, discover the agent hallucinated a policy that doesn't exist, and start over. The feedback loop is measured in minutes, not seconds.

The Microsoft Foundry Toolkit for VS Code collapses that loop. You generate an agent from extension using the Command Palette, configure the model and instructions, debug it locally against Agent Inspector, and deploy to Microsoft Foundry Agent Service.

What you will Build

Explain like I am an Executive agent

We've all written the perfect post-mortem, root cause, timeline, remediation, only to get back: "So… is the website down or not?"

Session 2 builds a single-purpose agent that takes this:

"The API latency increased due to thread pool exhaustion caused by synchronous calls introduced in v3.2."

…and returns this:

Executive Summary:

- What happened: After the latest release, the system slowed down.

- Business impact: Some users experienced delays while using the service.

- Next step: The change has been rolled back and a fix is being prepared before redeployment.

The Resume → Job Fit Evaluator

Session 3 steps up to a multi-agent workflow: four agents that collaborate to parse a résumé and a job description, extract the real requirements, score alignment, identify gaps, and generate a personalized learning roadmap backed by Microsoft Learn resources.

This is where you see orchestration patterns, agent-to-agent handoffs, and how to keep a multi-agent system debuggable .

The sessions

Follow along on GitHub....

Every session maps to our workshop in the companion repo with 50+ languages supported, so you can build alongside us or catch up afterward:

👉 Check out the repo

Save your seat and see you there

Sessions run on August 25, September 1, and September 3. Register once for the series and you're in for all three, and you'll get the recordings even if you can't make it live.

👉 Register for the full series

Bring your questions and see you there. 🚀

Articles & Tutorials

Sponsored

Mobile debugging: full context, no sampling Debugging mobile apps is weird: intermittent connections, mid-onboarding drop-offs, edge cases on devices you've never tested. bitdrift captures 100% of data, unsampled and in real time, so it’s immediately queryable by engineers and agents. Try bitdrift: mobile observability for the real world.

Android observability with Hilt: Kotzilla SDK and MCP Server on Google's Now in Android app Miguel Valdes Faura walks through adding Kotzilla SDK observability to Google's Hilt-based Now in Android app

The Great Android Stack Reset: Mobile System Design History Rotem Meidan traces Android's repeated architecture resets, from Activity-era God Objects to today's declarative stack

Fun Animations with Mesh Gradients: Jetpack Compose 1.12 Kevin Desai builds an animated water mesh gradient in Compose 1.12, optimizing the wave math for performance

Lights Out: Automatic Skeleton Loading in Compose Multiplatform KMP Bits builds a Compose Multiplatform skeleton modifier with one shared shimmer clock instead of many

Signatures, be true: domain errors and functional handling in Kotlin Viliam Sedliak shows how sealed interfaces and Either model domain errors directly in Kotlin function signatures

Place a sponsored post

Advertise to more than 80k Android developers! We reach out to more than 80k Android developers around the world, every week, through our email newsletter and social media channels. Advertise your Android development related service or product!

Libraries & Code

kwery A Kotlin library that manages server state for Android, handling caching, dedup, and offline write replay

droidgauge A local-first CLI tool that captures Android performance and power regressions via adb into shareable reports

kmprofiler A Gradle plugin that profiles Kotlin Multiplatform iOS export surfaces to find dead Objective-C adapters and leaked symbols

News

Klibs.io Grows to 4,200+ KMP Projects With Smarter Discovery and New AI Integrations JetBrains grows klibs.io past 4,200 KMP projects, adding an MCP server and AI-agent integrations for library discovery

Tinder cuts app cold starts by 47% with new R8 Configuration Analyzer Google details how Tinder used the new R8 Configuration Analyzer to cut cold starts 47% and shrink app size

Jetpack XR SDK core libraries reach beta: The next milestone for Android XR Google announces Jetpack SceneCore, ARCore for Jetpack XR, and XR Runtime reaching beta for Android XR development

Preparing your app for broader memory limits Google details expanding per-app memory limits across all RAM classes and how to profile and optimize memory footprint

Videos & Podcasts

Let's see how you code when nobody's watching! Stevdza-San reviews viewer-submitted Android app projects, offering live code feedback and suggestions

All platforms are unique but some platforms are more unique than others Konstantin Tskhovrebov covers the unique challenges of supporting Compose Multiplatform's web target

New Performance Challenges in the Agentic Era for Android Builds - Inaki Villar - droidcon USA 2026 Inaki Villar explores emerging performance pressures on Android build systems from agentic AI-driven development workflows

Vertical vs. Horizontal Slicing - The ONLY Right Way to Split Down Your App Philipp Lackner compares vertical and horizontal slicing strategies for structuring large Android app projects

KMP at Scale in Kuaishou Super App for over 700M users Omico Wang shows how Kuaishou scaled Kotlin Multiplatform across live streaming, messaging, and social features

The Backend Immune System - Rich Errors, Ktor Observability and Safe Local Remediation Meike Hammer presents a Kotlin-native resilience pattern using rich errors, Ktor observability, and local automated remediation

The Multi-Agent Code Review Workflow For My Production Android Apps Philipp Lackner demonstrates his multi-agent AI code review workflow for production Android apps

PUBG MOBILE connects players with Level Up Android Developers shows how PUBG Mobile integrated Google Play Games' Level Up program to boost player engagement

Building a cooking assistant with Firebase AI Logic Marina demonstrates building a real-time cooking assistant using Firebase AI Logic's Gemini Live API and function calling

SwiftPM support for Kotlin Multiplatform Timofey Solonin demonstrates importing SwiftPM dependencies like Firebase and Google Maps into Kotlin Multiplatform

Teaching Kotlin for the AI Era: Tips, Tools, and Practical Insights Daniil Karol discusses how AI is reshaping the way Kotlin programming should be taught today

Advanced Kotlin Native Integration - Tadeas Kriz Tadeas Kriz examines the challenges of linking multiple Kotlin Native binaries within a single project

Jurassic Park (1993) has about 60 visual effects shots containing computer-generated elements.

In 1993, photorealistic, cinema-quality CGI video took much longer and cost much more to produce than it would today. The high-end Silicon Graphics computers used by Industrial Light & Magic took 10-12 hours to render each frame. A lower-end smartphone could do it in 2-3 seconds today.

As the technology got faster – and the software got better and easier to use (think of what kids can do on laptops today) – the cost of CGI shots plummeted.

This was great news, because now studios needed far fewer CGI artists and technicians to make their movies. And that’s totally what happened. All the visual effects for Avengers: End Game were done by one guy called Barry working Tuesdays part-time.

Jurassic World has 1,000 computer-generated shots – 16x as many – and each frame contains about 1,000x as many polygons being animated and rendered.

But, bafflingly, Jurassic World only has a 6.9 rating on IMDB, compared to Jurassic Park’s 8.2 rating – even though Jurassic World is obviously 16,000x as good.

Could it be, perhaps, that more CGI with more polygons produced by more computing power isn’t necessarily what excites audiences? I remember every CGI shot in Jurassic Park. I struggle to remember any specific shots in Jurassic World, CGI or otherwise.

Maybe the creators of that sequel were so preoccupied with whether or not they could do more CGI shots with more elements and more detail, they didn’t stop to think if they should.

During my career, the computing power available has similarly exploded. The laptop I use day-to-day is easily 10,000x as powerful as the 486 I started on, and the tools I use are far more advanced. Compiles that used to take 15-20 minutes now finish in 15-20 seconds. I can run 10,000 unit tests in 2-3 minutes, whereas in the 90s I’d run a suite that big overnight.

But, like with CGI in movies, this has not produced a proportional increase in productivity or in value created. It could be argued that the very low cost of computation today has made little difference at all. Sure, there are way more developers now, creating way more software. But is it software anybody really wants or needs? Can society absorb that much software that fast?

The high cost of CGI in Jurassic Park meant that the filmmakers had to make every shot count. Just a couple of years earlier, the makers of Terminator 2: Judgement Day (IMDB rating: 8.6) had to make even more with even less.

Recently-published research found that the more elements in a shot, the less viewers paid attention. The brain only has so much visual bandwidth, and modern CGI-heavy action movies tend to overload viewers with visual information – making the overall experience more “Meh” than “Wow” (thanks to Rob Bowley for the inspiration).

And FX budgets haven’t shrunk with the cost of compute, either. They’ve ballooned. The average Marvel fare now has the equivalent of a whole town working on dozens of elements in thousands of shots. Jevons paradox in action.

So all this extra compute was for naught, Jason? Not quite.

There are some shining examples where the power was used not to create More Stuff^TM, but to create better stuff, and to create it cheaper.

Monsters (2010) cost famously little to produce, and the 200-or-so CGI effects shots really were done by one guy (called Gareth, working full-time) on consumer hardware. The whole movie cost about £300,000 to make. Here’s the thing, though – Gareth Edwards knew what he was doing.

He knew how to use the technology, having busked as a VFX artist in television. But, more importantly, he knew about directing, and about cinematography, and about editing, and about story. It might not be the greatest sci-fi movie of all time, but for the price of a semi-detached house, it’s pretty miraculous.

James Cameron is another director who started his career doing a heck of a lot with not very much for famously frugal producer Roger Corman, and is equally well-versed in key technical disciplines as well as the creative ones. Ever wondered why the Avatar films – being almost entirely CGI – look so much better than most modern FX-packed movies?

The evidence seems to suggest that the most valuable way we can leverage all this extra computing power is not necessarily to create more, but to iterate and refine faster to bigger impacts. What’s come down – should we choose to use it – is the cost of getting it wrong and trying again (and again).

Compiling and running tests faster doesn’t mean I can ship more features. It means I can iterate features more times and learn more from that for the same cost.

And what matters more than ever are human skill, judgement and taste. That will always be in short supply.

Otherwise, we’re just shipping Jurassic Worlds faster than the audience can absorb them.

Wanna see the receipt?

Originally posted in Obics.io Observability vendors have been billing companies per data volume or per node count for many years. Both of those have exploded in the last decade and the vendors have been enjoying a rapid rise in income. But that also created frustration from the customers. The issue of cost is on everyone’s mind when it comes to observability and the #1 reason for switching vendors, even if you are perfectly happy with everything else.

The organizations that work with AI will not be those that replace people the fastest. They will be the ones that use AI to multiply their teams' judgment, experience, and capabilities, without sacrificing quality or accountability. AI accelerates what we can do, but if we don't keep all the other things we do day-to-day in mind, we can suffer extreme hardship from rash decisions or suddenly lose key oversight/control. Let's dig in!