What does Jason M. Lemkin think is the ideal team structure for a SaaS company to get the first 10 unaffiliated customers?

“Unaffiliated customers” is a polite way of saying: not your mom, not your former roommate, not your investor doing you a favor,
and not the buddy who promised to “definitely roll this out next quarter” (a quarter that exists only in mythical timelines).
These are real customers who pay because your SaaS is valuablenot because you’re lovable.

Jason M. Lemkin’s take on earning those first 10 “cold” wins is blunt in the best way: the early team structure is simple,
a little unglamorous, and wildly effective when you embrace it. It’s not an org chart. It’s a strike team.

Why Jason Lemkin’s opinion carries weight in early SaaS

Lemkin has spent years dissecting what actually works in SaaSfrom scrappy pre-product-market-fit chaos to the “we should’ve hired
this role six months ago” stage. His recurring theme: early-stage SaaS doesn’t need more titles. It needs more truth.
Especially the truth you only learn by trying to sell a product that’s still a little weird.

That’s why his guidance around the first 10 customers focuses less on “Who’s our VP of Everything?” and more on
“Who can close, ship, onboard, and keep customers happythis week?”

The core Lemkin thesis: you can’t outsource the first 10 customers

Lemkin’s answer to “What team do I need for my first 10 unaffiliated customers?” is essentially:
you. Founders often assume a “magical sales rep” can sell a new, feature-light product with zero brand and no budget.
Lemkin argues that almost no one canbecause the product isn’t mature yet, the pitch isn’t fully baked, and the buyer objections are still evolving.

Translation: before you can delegate sales, you need to discover sales. Your first 10 deals are where you earn the right
to hire, train, and scale a go-to-market motion. Until then, hiring a salesperson is like hiring a pilot while you’re still building the plane.
Sure, they can sit in the cockpit. But nobody should be allowed to take off.

The ideal team structure to win the first 10 unaffiliated customers

Think “minimum effective team,” not “minimum viable org chart.” Lemkin’s worldview implies a tight setup where the founder remains the
primary closer and feedback sponge, while a small crew makes the product real, the onboarding smooth, and the customer outcomes obvious.

1) CEO/Founder: Head of Sales (and Head of Learning)

For the first 10 unaffiliated customers, the CEO is the revenue engine. Not because founders are naturally good at sales,
but because founders are uniquely positioned to:

• Tell the origin story with credibility (buyers can smell “I’m reading a script” from orbit).
• Translate objections into roadmap decisions in real time.
• Change pricing, packaging, and positioning fast without waiting for three meetings and a calendar invite.

Your early “sales process” is really a set of notes: what buyers asked, what they feared, what they needed to see,
and what finally made them say yes. The founder owns that notebook.

2) Technical Co-Founder / Lead Engineer: Ship the value, not just features

The second pillar is a builder who can ship quickly and safely. Early customers are buying outcomes, not sprint points.
The job here is to shorten time-to-value:

• Make setup simple (or at least survivable).
• Instrument the product enough to know what “success” looks like.
• Fix the handful of issues that kill trust (bugs that lose data, break logins, or make people feel foolish).

If your SaaS is technical or integrations-heavy, this role often doubles as “solutions engineer” in early calls:
answering hard questions, building confidence, and occasionally saving the deal with a calm “Yep, we can do that.”

3) Product/Design Generalist (optional, but powerful): Make the product explain itself

If you can add one non-engineering role early, a product/design generalist can be surprisingly leverage-y.
The first 10 customers are your best usability test lab. This person helps you:

• Turn confusing workflows into obvious ones.
• Build onboarding that feels like a helpful tour guide, not a maze.
• Create a small set of sales assets: a crisp deck, a one-page, a demo environment that doesn’t explode.

No, you don’t need Pixar-level animations. You just need the user to reach an “aha” moment before they reach the “unsubscribe” button.

4) Customer Success / Onboarding “Builder” (part-time at first): Protect the first 10 like they’re rare artifacts

Lemkin consistently emphasizes that customer success matters earlybecause retention, expansion, and referrals are the compounding engine in SaaS.
For the first 10 customers, this can be:

• The founder wearing the hat,
• an early hire who’s “smart, cares deeply, and lives to make customers happy,”
• or a hybrid: someone technical enough to unblock onboarding and obsessed enough to ensure adoption.

The first 10 customers are not “accounts.” They’re collaborators. If they struggle, your roadmap gets distorted, your churn rises,
and your future pipeline becomes allergic to you.

5) The “Glue” role (optional): Operations/admin so the founder can sell

When founder time becomes the bottleneck, a lightweight operations helper can unlock progress:
scheduling, CRM hygiene, invoices, basic support triage, and keeping the trains on the tracks.
This isn’t about building bureaucracy. It’s about protecting the only irreplaceable resource you have: founder hours.

How this team actually gets the first 10 unaffiliated customers

Team structure matters because it determines your weekly output: outreach, demos, product improvements, onboarding, and retention.
Here’s a practical playbook that matches Lemkin’s “founder must do it first” philosophywithout turning you into a sleep-deprived raccoon.

Step 1: Choose an ICP narrow enough to stalk (professionally)

Your ideal customer profile (ICP) is not “companies with computers.” Start with a tight buyer + pain combination:
job title, industry, trigger event, and the ugly spreadsheet they’re currently married to.

If you can’t list 50 specific people who might buy, your ICP is too broad. The goal is to make outreach personal,
not to spray “Hey {{FirstName}}” across the internet and hope destiny does the rest.

Step 2: Do unscalable things on purpose

Early customer acquisition is manual. That’s not a failure; it’s the job. Make it weirdly high-touch:
personal emails, hand-built demos, concierge onboarding, even “I made a loom video showing how this would work for your team.”

This is how you beat bigger competitors: not with budget, but with attention. Your first users should feel like signing up was one of the
smartest decisions they made this month.

Step 3: Run “objection-driven development”

In early SaaS, objections are product requirements wearing a trench coat. Track every “No because…” and sort them into:

• Must-fix (deal-blockers: security, integration, core workflow gaps)
• Nice-to-have (comfort features: exports, minor UI polish)
• Not-now (requests that would derail you into building a second product)

Your team structure should enable fast iteration: founder learns in calls, builder ships, CS validates with customers,
and the loop tightens.

Step 4: Make onboarding a revenue function

For the first 10 customers, onboarding is not “support.” It’s the second half of the sale.
Build a simple success path:

1. One primary outcome (what does “value” look like in 7 days?)
2. Three milestones (setup, first win, repeat usage)
3. One owner (someone responsible for the customer’s first win)

If customers need you to succeed, give them you. Not foreverjust long enough to learn what “forever” should look like.

Step 5: Convert each customer into proof

The first 10 unaffiliated customers should generate 10 assets:
a testimonial, a quote, a small case study, a referral intro, or permission to use their logo.
Even if it’s “We saved two hours a week,” that’s a wedge.

Social proof reduces future sales friction. It’s the difference between “Trust me” and “Here’s what happened for someone like you.”

When to hire sales (and who), according to Lemkin

Lemkin repeatedly argues for a clear threshold: close at least 10–20 customers yourself before hiring your first AE or salesperson.
Not because hiring is bad, but because you can’t train what you haven’t learned.

Once you’ve proven you can close deals repeatedly, you can hire helpoften a scrappy AE who can demo, learn fast,
and thrive without a famous brand name doing the heavy lifting.

Two additional Lemkin-flavored nuances:

• Stay involved even after hiring. Especially with your first sales leader, the founder often still needs to do a meaningful share of selling.
• Be careful with “process-first” leaders too early. Early-stage needs learning and growth more than bureaucracy.

The biggest mistakes that kill the first-10 journey

Hiring the “magical sales rep” before product-market fit

This is the classic trap: you’re tired, selling feels awkward, and a charismatic candidate promises to “build the whole revenue engine.”
But without a proven pitch, a clear ICP, and a product that reliably delivers value, that hire becomes a very expensive experiment.

Confusing activity with progress

Posting constantly, running ads, and building a thousand-page website can feel productivewhile producing exactly zero customers.
For the first 10, the scoreboard is simple: conversations, trials that activate, and paid conversions that stick.

Ignoring customer success until “later”

Early churn isn’t just lost revenueit’s lost learning. If your first customers fail, you lose the chance to understand why they bought
and what makes them stay. Customer success (even if founder-led) is part of the first-10 team structure.

Example team structures for different SaaS motions

Product-led (PLG) / self-serve SaaS

• Founder: positioning, partnerships, some sales, and user interviews
• Engineer: onboarding, activation, reliability
• Product/design generalist: UX, landing pages, lifecycle emails
• Part-time CS/support: fast response and preventing churn

Your first 10 “unaffiliated” customers here are often found through communities, direct outreach, and high-touch help after signup.
You win by reducing time-to-aha.

Mid-market SaaS (sales-assisted)

• Founder: primary closer
• Engineer: integrations + “can we do this?” credibility
• CS/onboarding builder: implementation + adoption
• Optional SDR/ops support: scheduling + list building + CRM hygiene

Here, the first 10 are usually earned by direct outreach and sharp demos, followed by white-glove onboarding.
The team must make implementation feel safe.

Enterprise SaaS (longer cycles)

• Founder: executive relationships and relentless follow-up
• Engineer/solutions: security, architecture, integrations
• Customer success: onboarding plans, QBR-style early wins
• Advisor network: credibility boosts (industry experts, not random “mentors”)

Enterprise “first 10” might mean fewer logos but deeper commitments. Your team structure must handle trust, not just features.

A simple week-by-week plan to earn the first 10 unaffiliated customers

Weeks 1–2: Build the list and the message

• Pick one ICP slice and write a one-sentence value proposition.
• Create a list of 100–200 targets (yes, manually if needed).
• Write outreach that sounds like a human wrote it (because… you did).

Weeks 3–6: Run the learning loop

• Book discovery calls and track objections.
• Ship at least one improvement per week driven by real conversations.
• Offer concierge onboarding for early adopters.

Weeks 7–10: Turn early wins into repeatability

• Standardize your demo flow and onboarding checklist.
• Ask every happy customer for a quote or intro.
• Document your “why we win” and “why we lose” patterns.

If you follow this cadence, the first 10 customers become less like “lottery winners” and more like “the result of a repeatable process.”
That’s the moment Lemkin would say you’re finally ready to scale beyond founder-only selling.

Closing thought

Lemkin’s ideal team structure for the first 10 unaffiliated customers is refreshingly non-corporate:
the founder sells, a small team ships and onboards, and everyone obsesses over customer outcomes.
Once you’ve personally closed enough deals to understand what worksthen you hire sales to multiply it.

If this sounds hard… it is. But it’s also the fairest trade in startups:
do the uncomfortable work early, and you earn the privilege of scaling later.

Field Notes: Real-world “experience” patterns founders run into chasing the first 10

I don’t have personal lived experience, but I can share the most common “war story patterns” that show up again and again
in founder accounts, interviews, and early-stage postmortems. If you’re trying to get your first 10 unaffiliated customers,
these are the moments that tend to separate “promising” from “actually working.”

1) Your first message will be bad. Not “imperfect.” Bad. It will be vague, feature-heavy, and somehow mention
“streamlining” (a word that has launched a thousand ignored emails). The founders who win the first 10 are the ones who treat outreach
like a product: test, measure replies, rewrite, repeat. The breakthrough usually happens when the message becomes painfully specific:
“We cut month-end reconciliation time from 6 hours to 2” beats “AI-powered finance optimization” every day of the week.

2) The first customers don’t buy the product. They buy the founder’s responsiveness.
Early on, customers are making a bet. They’re betting you’ll fix things, answer quickly, and not disappear when something breaks.
This is why founder-led sales and founder-involved onboarding work so well: customers feel the accountability.
A tiny team can look “small” on paper and still feel “safe” to buyers if the feedback loop is tight.

3) Onboarding will expose the lie in your positioning. You can say “setup takes 10 minutes,”
but your first 10 customers will fact-check you with zero mercy. When onboarding takes two days and three screen shares,
it’s not just a product issueit’s a go-to-market issue. Smart founders react by tightening the definition of success:
fewer features, clearer milestones, and an onboarding path that drives one concrete outcome fast. The best early teams
turn onboarding into a script, then into a checklist, then into product.

4) You’ll meet “almost customers.” They love the idea, they want to “circle back,” and they are always
“in the middle of a re-org.” Founders who reach the first 10 learn to qualify quickly:
Do they have the problem painfully? Do they own the budget? Do they have urgency? If not, you can still learn from them,
but you stop emotionally adopting them like a stray puppy.

5) One customer will try to turn you into a services company.
They’ll request custom features, bespoke workflows, and maybe a small moon landing. This is where the “ideal team structure”
matters: if the founder is selling and the builder is shipping, somebody must protect focus. A useful rule founders often cite:
“We’ll do one or two custom things that teach us a reusable product insight. After that, it’s paid discoveryor it’s no.”

6) The first 10 customers create your second 10. The founders who compound faster do two things:
(a) they collect proof (quotes, results, mini case studies), and (b) they ask for intros at the moment of success,
not months later when everyone forgot why they were excited. It feels awkward the first time. Then you realize it’s the
cleanest growth channel on Earth: happy customers who introduce you to similar customers.

7) Your “team” includes tools. Even a tiny team can operate like a bigger one by using lightweight automation:
scheduling, a simple CRM, email sequences that still sound human, a help center, and basic in-app guidance.
The winning pattern isn’t “replace humans,” it’s “protect humans.” Protect founder time for selling and learning,
protect engineering time for high-leverage fixes, and protect customers from waiting three days for a reply.

If you’re building toward those first 10 unaffiliated customers, the emotional punchline is this:
you’ll feel underqualified, then you’ll feel overcommitted, thensuddenlyyou’ll have a repeatable motion.
That’s when the org chart finally earns the right to exist.

SEO Tags