SaaStr Podcast #153: Spenser Skates, Founder/CEO @ Amplitude Discusses How To Build and Scale Sales Teams As A Technical Founder

If you’re a technical founder, you’ve probably experienced this emotional roller coaster:
you ship something brilliant, your GitHub commits look like a heartbeat monitor, and then… the market politely yawns.
In SaaStr Podcast #153, Spenser Skates (Founder/CEO of Amplitude) digs into the part that turns “cool product” into “real company”:
building and scaling a sales team when you didn’t start life as a salesperson.

The conversation hits the awkward-but-essential stuff founders wrestle with: accelerating the sales learning curve, deciding when to hire,
using discounting without torching your pricing, and designing compensation that motivates the right behavior (instead of training your team to do weird stuff like “discount-first, ask-questions-never”).
Also, it tackles the tough-love truth that every founder needs at least once: no one cares about your product… until they care about the outcome it creates.

What This Episode Is Really About

The headline says “sales teams,” but the subtext is bigger: how technical founders build a go-to-market engine without losing their soul.
Spenser’s core theme is practical: sales isn’t “being pushy,” it’s building a repeatable systema system you can measure, improve, and scale.
If engineering is about reducing uncertainty in code, sales is about reducing uncertainty in buying.
(Same sport, different stadium, more handshakes.)

Think of this as a founder’s field guide:
from founder-led sales → first reps → scalable sales org,
with the sharp edges sanded down by real-world lessons.

Why Technical Founders Often Struggle With Sales (and Why That’s Normal)

Technical founders are trained to win by being right. Sales rewards being relevant.
That’s not a moral differenceit’s a feedback loop difference.
Engineering feedback is immediate (tests fail, builds break). Sales feedback is human (budgets, priorities, fear of change, procurement doing procurement things).

The trap is believing the product will speak for itself. Sometimes it doeseventually. But early on, the market needs translation.
In practice, technical founders must learn to “debug” the buyer journey:
where deals stall, what objections repeat, and what outcomes make people open their wallets.

Stage 1: Founder-Led SalesThe Unfair Advantage You Don’t Want to Waste

Founder-led sales isn’t a rite of passage because investors enjoy watching founders sweat.
It matters because it creates the tightest possible loop between:
customer pain → product decisions → positioning → pricing.
When you outsource that too early, you lose signal.

Do the “Unscalable” Things (Yes, Even If It Feels Weird)

In early-stage SaaS, doing things that don’t scale is often the fastest way to discover what does.
For technical founders, this can feel like a betrayal of your identitylike you’re supposed to build robust systems, not chase individual customers one-by-one.
But those early customers aren’t just revenue. They’re your product roadmap wearing a trench coat.

Run Discovery Like an Experiment

If you’re technical, lean into your strengths: treat discovery as structured research.
Instead of pitching features, test hypotheses:

• Hypothesis: “Teams struggle to understand why activation drops after onboarding.”
• Test: “Tell me about the last time new users signed up but didn’t stick.”
• Signal: Do they describe a real cost (missed revenue, churn, wasted time), or just mild annoyance?

Your goal isn’t to “win the call.” Your goal is to identify repeatable pain and the language buyers use to describe it.
You’ll reuse that exact language later in your pitch, your website copy, and your sales enablement docs.
Congratulations: you just turned small talk into an asset.

The “No One Cares” Reality Check (and Why It’s Actually Good News)

The phrase sounds harsh, but it’s liberating: buyers don’t care about your product the way you do.
They care about their job, their KPIs, their risk, and their calendar.
So you win by making your product feel like a shortcut to a better outcomefaster reporting, higher retention, fewer churn surprises, smoother onboarding, cleaner data, whatever your customer truly values.

Stage 2: Pricing, Willingness to Pay, and the Founder’s First Negotiation Scars

Early pricing is hard because you don’t have enough data, and your brain keeps whispering:
“If we price too high, they’ll say no, and then I’ll have to feel feelings.”
Meanwhile, many founders learn the classic lesson: the customer might have paid more.

One practical approach is to use your sales motion as a gut-check.
If your process realistically supports only a certain number of deals per month, your average contract value needs to match the math.
Pricing isn’t just about “value” in the abstractit’s about whether a sales model can sustainably exist.

Discounting: Not EvilJust Dangerous When You Don’t Control It

Discounts can shorten sales cycles and help close dealsbut unmanaged discounting creates long-term pain:
it trains buyers to wait, it compresses margins, and it can turn every renewal into a new negotiation sport.
The healthier pattern is “discounts for something”:
multi-year commitments, upfront payment, a case study, faster implementation, reference calls, or reduced scope.

A founder-friendly rule: if you’re going to give something up (price), get something back (time, commitment, proof, or leverage).
Discounts aren’t “bad.” Discounts with no strategy are bad.

Stage 3: When to Hire Your First Salespeople (and What Role to Hire First)

Hiring sales too early is like deploying a service before you know what it’s supposed to do.
Hiring too late is like being the only on-call engineer forever.
The trick is timing, and timing has signals.

Signals It’s Time to Add a Sales Hire

• You can reliably explain who the product is for (your ICP) without using 14 adjectives.
• You know your top 3–5 objections and how to answer them without improvising a TED Talk.
• Deals follow a pattern: similar stakeholders, similar steps, similar blockers.
• You can forecast with at least “weather-app accuracy” (not perfect, but not pure fiction).
• You’re spending so much time selling that product progress is slowing.

First hire: SDR or AE?

Early on, most technical founders benefit from hiring a closer (an AE who can run full-cycle deals)
before building a specialized SDR layerbecause you still need to learn what “good” looks like end-to-end.
SDRs amplify a working motion; they don’t create one from scratch.

A simple sequence that often works:
Founder closes → first AE closes with founder support → then add SDRs once conversion is predictable.
If you do it in reverse, you risk generating activity without learning, which is how startups end up celebrating meetings that never turn into revenue.
(A calendar full of “great conversations” is not a P&L strategy.)

Stage 4: Scaling the Sales Learning Curve

“Sales learning curve” sounds soft, but it’s incredibly measurable:
time-to-first-meeting, time-to-first-qualified-opportunity, time-to-first-close, win rate, and average sales cycle length.
Your job as a founder is to shorten the time from “new rep” to “productive rep” without turning your team into robots.

Build a 30–60–90 Day Onboarding Plan

Onboarding is where most early sales orgs accidentally leak money.
A practical 30–60–90 approach might look like:

• First 30 days: product immersion, ICP, competitive landscape, call shadowing, and messaging.
• Days 31–60: run discovery with support, start building pipeline, refine objection handling.
• Days 61–90: own deals, forecast with discipline, close with confidence.

The hidden superpower: record calls, annotate them, and turn “tribal knowledge” into assets.
This is sales enablement before you can afford a sales enablement person.

Instrument the Sales Funnel Like a Product Funnel

This is where a technical founder can dominate.
Treat your sales pipeline like an analytics funnel:
lead → qualified → demo → proposal → procurement → closed-won.
Track conversion rates and time-in-stage. Then do what engineers do best: remove bottlenecks.

Example:
if deals keep dying after “demo,” you might have a “value moment” problem, not a “product” problem.
If deals stall in procurement, you might need pricing guardrails, security documentation, and a tighter legal process.
The point is: sales can be managed with the same rigor as engineeringwithout making it miserable.

How Amplitude’s “Product Analytics Mindset” Helps Sales Scale

Amplitude’s world is product analytics: understanding behavior, conversion, retention, and “what actions lead to outcomes.”
That mindset translates cleanly into scaling a sales team.
Great sales orgs don’t just “sell harder.” They learn what behaviors predict wins:
which segments expand, which onboarding paths retain, which industries churn, and which use cases create stickiness.

For technical founders, a big unlock is using product usage signals in the sales motion:
activation milestones, feature adoption, and engagement trends can guide prioritization and messaging.
Done well, your GTM becomes less guesswork and more guided decision-making.

Discounting Without Regret

Most founders hate discounting because it feels like losing.
In reality, discounting is a tooluseful, but sharp.
The goal isn’t “never discount.” The goal is discount governance:
clear rules, clear approvals, and clear reasons.

• Set a small “rep-controlled” band: tiny discounts they can use without drama.
• Make bigger discounts earned: longer term, prepay, references, or reduced scope.
• Expect procurement dynamics: enterprise buyers often treat discounts as standard process, not personal insult.
• Protect list price: anchor with a credible value narrative so discounts don’t become your entire pitch.

The founder move is to remove emotion from negotiating.
If discounts happen, make them systematic and trade-based. Your future self will thank you.
Your finance person will also thank you. Loudly. Possibly with snacks.

Compensation Design: Pay for the Behavior You Want

Compensation is strategy in spreadsheet form.
If your comp plan rewards the wrong things, your team will do the wrong thingsenthusiastically.
Start simple: define on-target earnings (OTE), choose a pay mix, and align quotas to what’s achievable and motivating.

Quick, Founder-Friendly Definitions

• Quota: the target a rep is expected to hit in a period (month/quarter/year).
• OTE: total expected earnings when the rep hits quota (base + variable).
• Pay mix: how much is base vs variable (e.g., 50/50, 60/40, 70/30).
• Accelerators: higher commission rates after surpassing quota to reward overperformance.
• Clawbacks: rules that reclaim commissions if deals cancel or reverse (use carefully and clearly).

The startup version of “good comp” is:
simple enough to explain in one minute,
aligned to your growth goals, and resistant to gaming.
For SDRs, you can split incentives between activity (meetings booked) and outcomes (pipeline or influenced revenue),
so they don’t optimize for spam.

A Simple Blueprint to Build and Scale Sales as a Technical Founder

Here’s a practical sequence that keeps you out of both extremes (no sales forever vs. hiring an army before PMF):

1. Founder-led sales first: run discovery, close early deals, learn pain language, define ICP.
2. Codify the motion: write the talk track, build a demo path, collect objections and responses.
3. Hire a closer: first AE who can run full-cycle deals with your support.
4. Measure ramp: define time-to-firsts and build a 30–60–90 onboarding plan.
5. Add SDRs when predictable: once conversion rates and messaging are stable enough to scale.
6. Introduce governance: pricing/discount rules, approval paths, and clean handoffs to CS.
7. Scale enablement: call library, playbooks, battlecards, and regular deal reviews.

If you do nothing else: turn what works into something repeatable.
That’s the difference between “a founder who can sell” and “a company that can sell.”

of Founder Experiences and Lessons From the Trenches

Founders who learn sales late often describe the same early mistake: they tried to “win” by building more.
One technical founder put it perfectly: they treated the product like a persuasive essaysurely if it was polished enough, customers would agree.
Instead, the market treated it like a tab left open. Interesting, but not urgent.
The turning point came when they stopped demoing features and started mapping pain.
Their best-performing discovery question became: “What breaks if this doesn’t get fixed in the next 90 days?”
If the answer was vague, the lead wasn’t ready. If the answer included dollars, deadlines, or a boss’s name, the deal got real fast.

Another common experience shows up around the first sales hire.
Many founders assume hiring an SDR will “take sales off my plate.”
What actually happens: the SDR books meetings… and the founder still has to close them.
A founder who did it successfully described it as “amplifying chaos” until the pitch was stable.
Once they had a repeatable motion, SDRs became rocket fuel. Before that, SDRs were basically a meeting factory feeding an unfinished machine.
The lesson: don’t scale activity until you know which activity creates revenue.

Pricing and discounting stories are even more consistent (and a little painful).
Early founders often discount because they’re afraid to lose the dealthen they discover the discount became the baseline expectation.
Several founders report their first “adult negotiation moment” as the time they calmly traded a discount for a multi-year agreement and a public case study.
Not only did the deal still close, but the relationship improved because expectations were clear.
The founder stopped feeling like they were begging, and started feeling like they were making a professional trade.

Then there’s the “sales learning curve” problem: how to ramp new reps without burning months.
The best founder-led teams treat sales training like product training: structured, measurable, and iterative.
They build a call library, tag great examples, and run weekly “objection drills” the same way engineers run incident reviewswithout shame, focused on learning.
One technical founder said their biggest unlock was treating the pipeline like a funnel: conversion rates, time-in-stage, and drop-off reasons.
When they saw deals dying after demos, they didn’t blame repsthey redesigned the demo to reach the “value moment” earlier.
Close rates rose, ramp time fell, and nobody had to become a different personality.

The most encouraging pattern across these experiences is that technical founders don’t need to become stereotypical salespeople.
They need to become system builders:
people who can translate customer pain into a repeatable motion, then hire and enable others to run it.
That’s the real “scale” story behind SaaStr Podcast #153: sales is a craft, and technical founders can learn itone experiment at a time.

Conclusion

SaaStr Podcast #153 is a reminder that scaling sales isn’t about magic scripts or aggressive tactics.
It’s about building a system: founder-led learning, clear ICP and messaging, pricing discipline, discount governance,
and compensation that aligns incentives with healthy growth.
For technical founders, the advantage is real: you already know how to iterate, measure, and improve.
Apply that mindset to sales, and you can build a revenue engine that feels intentionalwithout turning your company into a commission-themed reality show.

SEO Tags