Do Things That Don't Scale: A Practical Guide

Paul Graham wrote "Do Things That Don't Scale" in 2013, and it remains the single most important piece of startup advice ever published. The core insight: the things that get you from 0 to 100 users are fundamentally different from the things that get you from 100 to 10,000. And most founders skip the first phase because it feels inefficient, awkward, and beneath them.

But here's what's changed since 2013: the advice has been repeated so many times that it's become a platitude. Founders nod along — "yes, yes, unscalable things" — and then go back to building features and waiting for organic growth. They agree with the principle but don't know what to do with it on Monday morning.

This guide is the Monday morning version. It takes the philosophy of "do things that don't scale" and turns it into a specific, actionable playbook with concrete tactics you can execute this week. No theory. Just the uncomfortable, manual, deeply effective work that early-stage founders need to do.

Why Unscalable Things Work Better Than Scalable Things (At First)

The logic seems backward: why would you do things manually when you could automate? Why talk to users one by one when you could broadcast to thousands?

Three reasons:

1. Learning Speed

Every manual interaction teaches you something. When you personally onboard a user, you see exactly where they get confused, what excites them, and what almost makes them leave. Automated onboarding tells you none of that — you just see a completion rate.

At the 0-100 stage, learning speed is your primary competitive advantage. The faster you learn, the faster you build the right product.

2. Quality of Relationship

Users you personally recruit and support become evangelists. They feel invested in your success because you invested in theirs. They'll give you testimonials, refer friends, forgive bugs, and provide feedback that shapes your product.

Users who find you through ads feel no such obligation. They'll churn at the first inconvenience.

3. Signal Over Noise

Scalable channels are noisy. You're competing with every other startup running the same playbook — Facebook ads, SEO content, email campaigns. Unscalable channels are quiet. When you send a personalized DM to someone who just complained about the problem you solve, you're the only one showing up with a solution.

The Seven Unscalable Tactics (And How to Execute Each One)

Tactic 1: Manual User Recruitment

The principle: Find potential users one by one and personally convince them to try your product.

The practice:

Spend the first hour of every workday on manual recruitment. Here's the routine:

1. Search for signals (15 minutes): Scan Twitter, Reddit, LinkedIn, and relevant forums for people expressing the problem you solve.

2. Qualify prospects (10 minutes): Check their profiles. Are they in your target audience? Do they seem like early adopters? Would your product genuinely help them?

3. Reach out (35 minutes): Send 5-10 personalized messages. Reference their specific situation. Offer to help, not to sell.

The numbers: 10 messages/day at a 15% response rate = 1-2 conversations/day = 5-10 new users/week.

For templates and tactics, read our guide on cold DMs that get replies.

Tactic 2: Concierge Onboarding

The principle: Personally walk every new user through your product during their first session.

The practice:

When someone signs up, email them within an hour:

Hey [name],

Saw you just signed up for [product] — welcome!

I'm [your name], the founder. I'd love to make sure you get the most
out of it. Would you be open to a 15-minute call where I walk you
through the best setup for your use case?

If calls aren't your thing, I can also set things up for you and
send a quick video walkthrough.

Either way, I'm here if you need anything.

What you learn: Where users get stuck, what they expect, which features they care about, what language they use to describe their problems.

The time investment: 15-20 minutes per user. At 5 users/day, that's ~90 minutes. Worth every second for the first 50 users.

The scaling transition: Once you've done 30-50 concierge onboarding sessions, you'll have enough data to build an automated onboarding flow that addresses the common sticking points. But not before.

Tactic 3: Manual Service Delivery

The principle: Do manually what your product will eventually do automatically.

The practice:

This is the Wizard of Oz approach. Your product promises to automate X. Before you build the automation:

1. Deliver the result manually for your first users
2. Validate that the result is valuable
3. Build the automation based on what you learned

Real examples:

• A content optimization tool: Manually analyze the first 20 users' content and deliver reports by hand before building the automated analysis
• An AI scheduling assistant: Manually schedule meetings for the first 10 users before building the AI
• A data integration platform: Manually connect data sources for early users before building the automated connectors

Why this works: You learn what "good output" looks like from the user's perspective. You discover edge cases. You understand which parts of the process are truly valuable and which are just engineering exercises.

Tactic 4: Hand-Written Follow-Ups

The principle: Send personal, non-automated messages to every user at key moments.

The practice:

Set up a simple system (even just calendar reminders) to follow up with each user:

• Day 1: Welcome message (mentioned above)
• Day 3: "How's it going? Any questions?"
• Day 7: "I noticed you [specific usage data]. Here's a tip to get more value: [specific suggestion]"
• Day 14: "You've been using [product] for two weeks. What's your honest assessment? What would make it better?"
• Day 30: "Would you be comfortable sharing your experience? A quick quote would really help us."

The key: These need to be genuinely personal. Reference their specific usage. Mention their company or project by name. Users can smell automation.

The time investment: 5 minutes per user per touchpoint. With 50 active users and 5 touchpoints, that's about 20 hours spread over a month.

Tactic 5: Direct Customer Support (From the Founder)

The principle: Handle all support personally. Don't delegate. Don't automate. Not yet.

The practice:

• Put your personal email as the support contact
• Respond to every support request within 2 hours during business hours
• Fix bugs the same day they're reported (or explain why you can't)
• Follow up after resolution to make sure it's actually resolved

What this gives you:

• A real-time view of what's broken and what's confusing
• Users who feel heard and valued (they'll forgive a lot of rough edges)
• Stories and quotes you can use in marketing ("the founder personally helped me fix this in 20 minutes")

When to stop: When support volume exceeds 2 hours/day consistently, you need to start building self-serve support (docs, FAQ, chatbot). But not before.

Tactic 6: In-Person (or Video) User Meetings

The principle: Have real conversations with users. Not surveys. Not NPS. Conversations.

The practice:

Book 3-5 user calls per week. Keep them to 20-30 minutes. Use this structure:

1. Context (3 min): "Tell me about your workflow before [product]."
2. Usage (5 min): "Walk me through how you use [product] in a typical week."
3. Value (5 min): "What would you miss most if [product] disappeared?"
4. Friction (5 min): "What's the most annoying thing about [product]?"
5. Wishes (5 min): "If you could change one thing, what would it be?"
6. Network (2 min): "Do you know anyone else who might benefit from this?"

Record every call (with permission). Transcribe them. Review them weekly. The patterns that emerge from 20 user calls are worth more than any market research.

Tactic 7: Custom Features for Early Users

The principle: Build features that specific users ask for — even if they're not on your roadmap.

The practice:

When an early user says "I wish [product] could do X," consider building it — especially if:

• It aligns with your general direction
• It would help other users too
• It deepens the user's integration with your product

What this signals to users: "This team listens. This team ships fast. This product is being built for people like me."

The boundary: Only do this for features that serve your broader vision. Don't build a completely unrelated feature just to keep one user. But bending your roadmap for early users is almost always worth it.

The Unscalable Mindset

Beyond specific tactics, "do things that don't scale" is a mindset. It means:

Choosing depth over breadth. Ten users who love your product are worth more than 1,000 who kind of like it. Go deep with a small number of users before going wide.

Choosing discomfort over efficiency. Sending 10 personalized DMs feels slow compared to running ads. It's also 10x more effective at this stage.

Choosing learning over metrics. At the 0-100 stage, "what did I learn from this user interaction?" matters more than "what's my conversion rate?"

Choosing relationships over transactions. Every early user is a potential co-creator, evangelist, and advisor. Treat them that way.

When to Stop Doing Things That Don't Scale

This is the question everyone asks, and the answer is simpler than you'd think: stop when you've found a pattern.

Unscalable things teach you patterns:

• Which users convert fastest → your ideal customer profile
• Which onboarding steps matter → your automated onboarding flow
• Which support issues recur → your self-serve documentation
• Which messages get replies → your marketing copy

Once you've identified these patterns through manual work, you can build systems to replicate them. That's when you graduate from unscalable to scalable.

The typical transition points:

| Unscalable Activity | Transition Point | Scalable Replacement | |---------------------|-----------------|---------------------| | Manual recruitment | 50-100 users | Content marketing, paid acquisition | | Concierge onboarding | 30-50 onboarding sessions | Automated onboarding flow | | Founder support | 2+ hours/day consistently | Support docs, chatbot, hire | | Personal follow-ups | 100+ active users | Email automation sequences | | Custom features | Requests start repeating | Standardized roadmap |

Common Mistakes in the "Unscalable" Phase

Mistake 1: Doing unscalable things halfheartedly. Sending "personalized" DMs from a template without actually personalizing them. Offering "concierge" onboarding but sending everyone the same Loom video. If you're going to do things that don't scale, commit fully.

Mistake 2: Doing them for too long. Some founders get comfortable with the manual phase and never build systems. If you're still personally onboarding every user at user #500, you've overcorrected. For a reality check on timing, read our first 100 users timeline.

Mistake 3: Doing them for too short. Switching to automation at user #20 because manual work "doesn't scale." You haven't learned enough yet. Stay manual until the patterns are unmistakable.

Mistake 4: Confusing "unscalable" with "busy." Attending conferences, redesigning your landing page, and optimizing your CI/CD pipeline feel productive but aren't the unscalable user-facing work that matters at this stage.

The Transition to Scale

Once you've found your patterns through unscalable work, the transition to scalable growth is actually easier than most founders expect.

You know your ideal customer profile (from manual recruitment). You know your core messaging (from conversations). You know your onboarding flow (from concierge sessions). You know your product's strengths and weaknesses (from support and feedback).

That's the foundation for every scalable growth channel: content marketing, paid acquisition, partnerships, and more. And it's the foundation that AI-powered GTM tools need to be effective. Platforms like Any can automate your outreach, content, and campaigns — but they need the playbook that unscalable work creates. The AI amplifies what works. Your job is to figure out what works.

For more strategies on finding your first users, see our complete guide to getting your first 100 users and the companion article on solo founder GTM mistakes to avoid.

---

Do things that don't scale. Not because they're efficient, but because they're effective. The manual work teaches you things that no automation, no analytics tool, and no advisor can teach. Start today. Talk to one user. Send one personalized message. Fix one bug within an hour of it being reported. The compound effect of doing unscalable things consistently is the fastest path to scalable growth.