DEV Community: Brian Marsaw

Ask HN: What process should I use to find SMB prospects for a B2B SaaS product?

Brian Marsaw — Thu, 16 Jul 2026 23:31:26 +0000

{
  "title": "Finding SMB Prospects for Your B2B SaaS Product: A Practical Process That Actually Works",
  "slug": "finding-smb-prospects-b2b-saas-product-process",
  "meta_description": "Learn battle-tested processes to find and qualify SMB prospects for your B2B SaaS product. Includes automation scripts, targeting strategies, and outreach tactics.",
  "tags": ["B2B SaaS", "lead generation", "SMB sales", "automation", "prospecting"],
  "body": "# Finding SMB Prospects for Your B2B SaaS Product: A Practical Process That Actually Works\n\nFinding the right SMB (Small and Medium Business) prospects for your B2B SaaS product is fundamentally different from enterprise sales. SMBs move faster, have smaller budgets, and need solutions that work immediately—but they're also harder to reach at scale. After years of building developer tools and productivity SaaS products, I've learned that success comes from combining targeted research, ruthless qualification, and smart automation.\n\nLet's skip the theory and dive into a process that actually works.\n\n## Start With Your Ideal Customer Profile (ICP), Not Your Product\n\nMost founders start by listing their product features and then searching for companies that might need them. This is backwards.\n\nInstead, analyze your best existing customers (or, if you're pre-launch, your target segment). Document:\n\n- **Company size**: Number of employees (10-50? 50-200?)\n- **Industry verticals**: Which specific industries get the most value?\n- **Technology stack**: What tools are they already using?\n- **Pain points**: What problem were they solving when they found you?\n- **Budget indicators**: Revenue range, funding status, growth signals\n\nFor developer tools, this might look like: \"Series A startups with 20-100 employees, using React and TypeScript, experiencing scaling issues with their CI/CD pipeline.\"\n\nBe specific. \"SMBs that need productivity tools\" is useless. \"Marketing agencies with 15-50 employees struggling with client reporting\" gives you something to work with.\n\n## Build Your Prospecting Data Pipeline\n\nOnce you know who you're looking for, you need to find them systematically. Here's the tech stack I recommend:\n\n### Primary Data Sources\n\n1. **LinkedIn Sales Navigator** - Still the best for B2B prospecting. Filter by company size, industry, technology, and growth signals.\n2. **Crunchbase** - Essential for tech companies. Filter by funding stage, employee count, and technology tags.\n3. **BuiltWith or Wappalyzer** - Identify companies using specific technology stacks.\n4. **Industry-specific directories** - Many verticals have specialized directories that aggregate companies.\n\n### Automate the Grunt Work\n\nDon't manually copy-paste data. Build a simple scraping and enrichment pipeline:\n\n```

python\nimport requests\nimport pandas as pd\nfrom typing import List, Dict\n\nclass ProspectEnricher:\n    def __init__(self, clearbit_api_key: str):\n        self.clearbit_key = clearbit_api_key\n        self.base_url = \"https://company.clearbit.com/v2/companies/find\"\n    \n    def enrich_domain(self, domain: str) -> Dict:\n        \"\"\"Enrich company data using Clearbit API\"\"\"\n        params = {'domain': domain}\n        headers = {'Authorization': f'Bearer {self.clearbit_key}'}\n        \n        try:\n            response = requests.get(self.base_url, params=params, headers=headers)\n            if response.status_code == 200:\n                data = response.json()\n                return {\n                    'name': data.get('name'),\n                    'domain': domain,\n                    'employees': data.get('metrics', {}).get('employees'),\n                    'industry': data.get('category', {}).get('industry'),\n                    'tech_stack': data.get('tech', []),\n                    'linkedin_url': data.get('linkedin', {}).get('handle')\n                }\n        except Exception as e:\n            print(f\"Error enriching {domain}: {e}\")\n        \n        return None\n    \n    def batch_enrich(self, domains: List[str]) -> pd.DataFrame:\n        \"\"\"Enrich a list of domains and return DataFrame\"\"\"\n        enriched_data = []\n        \n        for domain in domains:\n            data = self.enrich_domain(domain)\n            if data:\n                enriched_data.append(data)\n        \n        return pd.DataFrame(enriched_data)\n\n# Usage\nenricher = ProspectEnricher(api_key='your_clearbit_key')\ndomains = ['example.com', 'anothercompany.com']\nprospects_df = enricher.batch_enrich(domains)\n\n# Filter by your ICP criteria\nqualified = prospects_df[\n    (prospects_df['employees'] >= 20) & \n    (prospects_df['employees'] <= 100) &\n    (prospects_df['tech_stack'].str.contains('React', na=False))\n]\n\nqualified.to_csv('qualified_prospects.csv', index=False)\n

```\n\nThis script uses Clearbit (you can substitute with Apollo.io, Hunter.io, or similar) to enrich company data and automatically filter by your ICP criteria. Run this weekly to keep your pipeline fresh.\n\n## Qualify Before You Reach Out\n\nNot every company that matches your ICP is ready to buy. Add a qualification layer:\n\n### Trigger Events\n\nLook for signals that indicate buying intent:\n\n- **Recent funding** - Fresh capital means budget for new tools\n- **Job postings** - Hiring specific roles suggests they're scaling that function\n- **Product launches** - New products often require new infrastructure\n- **Technology changes** - Switching stack components creates opportunity\n- **Leadership changes** - New executives bring new priorities\n\nYou can automate trigger detection:\n\n```

typescript\nimport axios from 'axios';\n\ninterface TriggerEvent {\n  company: string;\n  eventType: 'funding' | 'hiring' | 'product_launch' | 'tech_change';\n  date: Date;\n  relevanceScore: number;\n}\n\nclass TriggerEventDetector {\n  private crunchbaseKey: string;\n\n  constructor(crunchbaseKey: string) {\n    this.crunchbaseKey = crunchbaseKey;\n  }\n\n  async detectFundingEvents(companies: string[]): Promise<TriggerEvent[]> {\n    const events: TriggerEvent[] = [];\n    \n    for (const company of companies) {\n      try {\n        const response = await axios.get(\n          `https://api.crunchbase.com/v4/entities/organizations/${company}`,\n          {\n            headers: { 'X-cb-user-key': this.crunchbaseKey },\n            params: { card_ids: 'funding_rounds' }\n          }\n        );\n\n        const latestRound = response.data.cards.funding_rounds[0];\n        const daysSinceFunding = this.daysSince(new Date(latestRound.announced_on));\n\n        if (daysSinceFunding < 90) {\n          events.push({\n            company,\n            eventType: 'funding',\n            date: new Date(latestRound.announced_on),\n            relevanceScore: 10 - (daysSinceFunding / 9) // Higher score for recent events\n          });\n        }\n      } catch (error) {\n        console.error(`Error checking funding for ${company}:`, error);\n      }\n    }\n\n    return events.sort((a, b) => b.relevanceScore - a.relevanceScore);\n  }\n\n  private daysSince(date: Date): number {\n    return Math.floor((Date.now() - date.getTime()) / (1000 * 60 * 60 * 24));\n  }\n}\n

```\n\n## The Outreach Process That Doesn't Suck\n\nHere's the controversial part: cold email still works for SMBs, but only if you do it right.\n\n### The Formula\n\n1. **Personalized subject lines**: Reference something specific about their company\n2. **Lead with their problem**: Not your solution\n3. **One clear value proposition**: How you solve that specific problem\n4. **Soft CTA**: Ask a question, don't push a demo\n5. **Follow up strategically**: 3-4 touches over 2 weeks, then move on\n\n**Example for a CI/CD tool:**\n\n*Subject: Your React deploys at [Company]*\n\n*Hi [Name],*\n\n*I noticed [Company] is hiring frontend engineers and saw you're using React + TypeScript (nice choice). As your team grows, CI/CD pipeline time becomes a real bottleneck.*\n\n*We built [Tool] specifically for React/TS teams scaling from 20-100 engineers. Most teams see 40% faster builds within a week.*\n\n*Curious if slow deploys are on your radar right now?*\n\n*[Your Name]*\n\n### Automation vs. Personalization\n\nUse tools like Lemlist, Reply.io, or build your own with:\n\n- **Automated sequences** for follow-ups\n- **Merge tags** for basic personalization\n- **Manual research** for the first line of each email\n\nAutomate the process, not the message.\n\n## Track, Measure, Iterate\n\nYour prospecting process should be data-driven. Track:\n\n- **Conversion rates** at each stage (identified → qualified → contacted → responded → demo → customer)\n- **Time to response** (are you reaching out too early/late?)\n- **Channel effectiveness** (LinkedIn vs. email vs. other)\n- **ICP accuracy** (do converted customers match your profile?)\n\nUse a simple spreadsheet or build a dashboard:\n\n```

python\n# Simple pipeline analytics\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\ndf = pd.read_csv('prospects.csv')\n\n# Conversion funnel\nfunnel = {\n    'Identified': len(df),\n    'Qualified': len(df[df['qualified'] == True]),\n    'Contacted': len(df[df['contacted'] == True]),\n    'Responded': len(df[df['responded'] == True]),\n    'Demo': len(df[df['demo_scheduled'] == True]),\n    'Customer': len(df[df['converted'] == True])\n}\n\n# Calculate conversion rates\nfor i, (stage, count) in enumerate(list(funnel.items())[1:], 1):\n    prev_stage = list(funnel.values())[i-1]\n    conversion = (count / prev_stage * 100) if prev_stage > 0 else 0\n    print(f\"{stage}: {conversion:.1f}% conversion\")\n

\n\nReview these metrics weekly and adjust your ICP, messaging, or channels accordingly.\n\n## The Bottom Line\n\nFinding SMB prospects isn't about blasting thousands of companies with generic messages. It's about:\n\n1. Defining a tight ICP based on real customer data\n2. Building automated systems to identify and qualify prospects\n3. Detecting trigger events that signal buying intent\n4. Personalizing outreach that speaks to specific problems\n5. Iterating based on data, not hunches\n\nThe companies that succeed at SMB prospecting treat it like product development: ship fast, measure everything, and improve continuously. Your first ICP will be wrong. Your first email template will convert poorly. That's fine. The goal is to build a system that gets better every week.\n\nStart

Simple Email SaaS? Here's What Actually Works in 2024

Brian Marsaw — Thu, 16 Jul 2026 23:29:27 +0000

Simple Email SaaS? Here's What Actually Works in 2024

The "Ask HN: Simple email SaaS?" question has been asked repeatedly on Hacker News because email remains one of the most critical—and frustrating—parts of building a SaaS product. You need transactional emails, marketing campaigns, and reliable delivery, but most solutions are either overpriced, overcomplicated, or both.

Let's cut through the noise and examine what actually works for developers building SaaS products in 2024.

The Real Problem With Email SaaS Solutions

Most email services fall into two camps:

Marketing-focused platforms (Mailchimp, ConvertKit) that are overkill if you just need to send password resets and receipts
Transactional email APIs (SendGrid, Postmark) that become expensive fast and lack basic marketing features

What developers actually need is something in between: a service that handles transactional emails reliably, allows occasional broadcasts, doesn't break the bank, and provides a simple API without forcing you through a maze of enterprise features.

Best Simple Email SaaS Options Right Now

For Pure Transactional Email

Resend has emerged as the developer-first choice. Founded by ex-Vercel engineers, it offers:

Clean API designed for developers
React Email template support
Generous free tier (3,000 emails/month)
$20/month for 50,000 emails
Excellent deliverability

Postmark remains the gold standard for transactional reliability:

Laser-focused on transactional email only
Industry-leading deliverability rates
100 emails/month free, then $15/month for 10,000
Detailed analytics and bounce handling

Here's how simple Resend is to integrate:

typescript
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

export async function sendWelcomeEmail(userEmail: string, userName: string) {
try {
const data = await resend.emails.send({
from: 'onboarding@yoursaas.com',
to: userEmail,
subject: 'Welcome to Our Platform',
html: <h1>Hi ${userName}!</h1><p>Thanks for signing up...</p>
});

return { success: true, id: data.id };

} catch (error) {
console.error('Email failed:', error);
return { success: false, error };
}
}

For Transactional + Light Marketing

Loops is the new kid on the block, purpose-built for SaaS:

Transactional emails AND marketing campaigns
Event-triggered sequences
$30/month for 10,000 contacts
Visual email builder plus API

Buttondown for email newsletters with API access:

Markdown-based emails
Simple API for programmatic sending
$9/month for 1,000 subscribers
Perfect for product updates and changelog notifications

For Budget-Conscious Startups

Amazon SES remains unbeatable on price:

$0.10 per 1,000 emails
Requires more setup and management
Works perfectly with libraries like Nodemailer

Here's a production-ready Python example using SES:

python
import boto3
from botocore.exceptions import ClientError

class EmailService:
def init(self):
self.ses_client = boto3.client('ses', region_name='us-east-1')

def send_email(self, recipient: str, subject: str, html_body: str, 

               text_body: str = None):

    try:

        response = self.ses_client.send_email(

            Source='noreply@yoursaas.com',

            Destination={'ToAddresses': [recipient]},

            Message={

                'Subject': {'Data': subject, 'Charset': 'UTF-8'},

                'Body': {

                    'Html': {'Data': html_body, 'Charset': 'UTF-8'},

                    'Text': {'Data': text_body or '', 'Charset': 'UTF-8'}

                }

            }

        )

        return response['MessageId']

    except ClientError as e:

        print(f"Email send failed: {e.response['Error']['Message']}")

        raise

Usage

email_service = EmailService()
email_service.send_email(
recipient='user@example.com',
subject='Your Receipt',
html_body='

Thanks for your purchase!

',
text_body='Thanks for your purchase!'
)

Should You Build Your Own Email Service?

Short answer: No. But let me explain when you might consider it.

Email deliverability is hard. You need:

Proper SPF, DKIM, and DMARC records
IP reputation management
Bounce and complaint handling
Spam filter avoidance
Retry logic and queue management

Unless you're sending millions of emails and can justify a dedicated email engineer, use a service.

The exception: If you're already using SES for transactional emails and want to add a simple marketing layer, building a thin wrapper for campaigns can work. But start with existing services first.

The Decision Framework

Choose based on your actual needs:

Choose Resend or Postmark if:

You only need transactional emails
Developer experience matters to you
You value reliability over features

Choose Loops or Buttondown if:

You need occasional marketing emails
You want event-triggered sequences
You prefer an all-in-one solution

Choose Amazon SES if:

You're on a tight budget
You're comfortable with AWS
You can handle the setup complexity

Avoid SendGrid/Mailchimp if:

You're a solo developer or small team
You don't need their enterprise features
You want predictable pricing

Getting Started Today

Here's my recommended approach:

Start with Resend for transactional emails (it's free to 3,000 emails)
Add Buttondown later if you need newsletters ($9/month)
Migrate to SES only if costs become significant (>100k emails/month)

Don't overthink it. Email is infrastructure—it should be boring and reliable, not a project in itself.

Conclusion

The best simple email SaaS in 2024 isn't the one with the most features—it's the one you can integrate in 30 minutes and forget about. For most developers building SaaS products, that means Resend for transactional emails, possibly combined with Buttondown for newsletters.

Stop shopping for email providers and start shipping features your users actually care about. The emails will get delivered either way.

Why There's No Example Code for B2B SaaS Apps (And What to Do About It)

Brian Marsaw — Thu, 16 Jul 2026 23:23:17 +0000

Why There's No Example Code for B2B SaaS Apps (And What to Do About It)

If you've ever searched for "B2B SaaS starter code" or "complete SaaS application example," you've probably come up empty-handed. While GitHub overflows with todo apps, blog platforms, and e-commerce demos, comprehensive examples of actual B2B SaaS applications are frustratingly rare.

This isn't an accident. There are legitimate reasons why battle-tested B2B SaaS code remains locked away in private repositories. But more importantly, you don't need a complete example—you need the right patterns. Let's break down why examples are scarce and, more usefully, what architectural patterns you should implement instead.

Why B2B SaaS Examples Are Rare

Competitive Advantage: Unlike a todo app, a well-architected B2B SaaS application represents thousands of hours of refined engineering decisions. Companies rightfully view their codebase as intellectual property. The multi-tenancy strategy, billing integration, and permission system that took months to perfect aren't going to be open-sourced.

Complexity: B2B SaaS applications are complex beasts. They involve authentication, authorization at multiple levels, billing, subscription management, team management, audit logs, webhooks, API rate limiting, and data isolation. A truly representative example would be tens of thousands of lines of code—too large to be useful as a learning resource.

Context-Dependency: What works for a project management tool differs drastically from what works for a CRM or analytics platform. There's no one-size-fits-all B2B SaaS architecture, which makes creating a "canonical" example nearly impossible.

Liability Concerns: Publishing production-grade code for handling payments, user data, and multi-tenant isolation opens companies to scrutiny. If someone finds a security vulnerability in your open-source example, it reflects poorly on your brand.

The Critical Patterns You Actually Need

Instead of waiting for a mythical complete example, focus on implementing these core patterns correctly. Master these, and you'll be 80% of the way there.

1. Multi-Tenancy with Row-Level Security

The foundation of any B2B SaaS is proper data isolation. Here's a battle-tested PostgreSQL approach using row-level security:

typescript
// schema.prisma (using Prisma)
model Organization {
id String @id @default(cuid())
name String
slug String @unique
users User[]
projects Project[]
createdAt DateTime @default(now())
}

model Project {
id String @id @default(cuid())
name String
organizationId String
organization Organization @relation(fields: [organizationId], references: [id])
createdBy String

@@index([organizationId])
}

// Middleware to enforce tenant isolation
import { PrismaClient } from '@prisma/client'

export function createTenantClient(organizationId: string) {
const prisma = new PrismaClient()

return prisma.$extends({
query: {
$allModels: {
async $allOperations({ args, query, model }) {
// Skip for Organization model
if (model === 'Organization') return query(args)

      // Inject organizationId filter for all operations
      if (args.where) {
        args.where = { ...args.where, organizationId }
      } else {
        args.where = { organizationId }
      }

      // Inject organizationId for creates
      if (args.data && model !== 'User') {
        args.data = { ...args.data, organizationId }
      }

      return query(args)
    }
  }
}

})
}

This pattern ensures you can never accidentally query across tenant boundaries. It's saved me from data leakage bugs more times than I can count.

2. Role-Based Access Control (RBAC) That Scales

Skip the simple isAdmin boolean. You'll regret it. Here's a flexible RBAC system:

python

models.py (using SQLAlchemy)

from enum import Enum
from sqlalchemy import Table, Column, String, ForeignKey
from sqlalchemy.orm import relationship

class Permission(Enum):
PROJECT_CREATE = "project:create"
PROJECT_READ = "project:read"
PROJECT_UPDATE = "project:update"
PROJECT_DELETE = "project:delete"
BILLING_MANAGE = "billing:manage"
USERS_INVITE = "users:invite"

user_roles = Table('user_roles', Base.metadata,
Column('user_id', String, ForeignKey('users.id')),
Column('role_id', String, ForeignKey('roles.id'))
)

role_permissions = Table('role_permissions', Base.metadata,
Column('role_id', String, ForeignKey('roles.id')),
Column('permission', String)
)

class Role(Base):
tablename = 'roles'
id = Column(String, primary_key=True)
name = Column(String, nullable=False)
organization_id = Column(String, ForeignKey('organizations.id'))
permissions = Column(ARRAY(String)) # Store as array for simplicity

class User(Base):
tablename = 'users'
id = Column(String, primary_key=True)
email = Column(String, unique=True, nullable=False)
organization_id = Column(String, ForeignKey('organizations.id'))
roles = relationship('Role', secondary=user_roles)

Authorization decorator

from functools import wraps
from flask import g, abort

def require_permission(permission: Permission):
def decorator(f):
@wraps(f)
def decorated_function(*args, **kwargs):
user = g.current_user
user_permissions = set()
for role in user.roles:
user_permissions.update(role.permissions)

        if permission.value not in user_permissions:
            abort(403, "Insufficient permissions")

        return f(*args, **kwargs)
    return decorated_function
return decorator

Usage

@app.route('/api/projects', methods=['POST'])
@require_permission(Permission.PROJECT_CREATE)
def create_project():
# Your logic here
pass

3. Subscription and Usage Tracking

You need to track usage limits and gate features based on subscription tiers:

typescript
// subscriptionService.ts
import Stripe from 'stripe'

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)

export enum PlanTier {
FREE = 'free',
PRO = 'pro',
ENTERPRISE = 'enterprise'
}

interface PlanLimits {
maxProjects: number
maxUsers: number
apiCallsPerMonth: number
}

const PLAN_LIMITS: Record = {
[PlanTier.FREE]: { maxProjects: 3, maxUsers: 5, apiCallsPerMonth: 1000 },
[PlanTier.PRO]: { maxProjects: 50, maxUsers: 50, apiCallsPerMonth: 100000 },
[PlanTier.ENTERPRISE]: { maxProjects: -1, maxUsers: -1, apiCallsPerMonth: -1 }
}

export class SubscriptionService {
async canPerformAction(
organizationId: string,
action: keyof PlanLimits
): Promise {
const org = await prisma.organization.findUnique({
where: { id: organizationId },
include: { subscription: true }
})

if (!org?.subscription) return false

const limits = PLAN_LIMITS[org.subscription.tier as PlanTier]
const limit = limits[action]

// -1 means unlimited
if (limit === -1) return true

const currentUsage = await this.getCurrentUsage(organizationId, action)
return currentUsage < limit

}

private async getCurrentUsage(
organizationId: string,
metric: keyof PlanLimits
): Promise {
switch (metric) {
case 'maxProjects':
return await prisma.project.count({ where: { organizationId } })
case 'maxUsers':
return await prisma.user.count({ where: { organizationId } })
case 'apiCallsPerMonth':
return await this.getAPICallsThisMonth(organizationId)
default:
return 0
}
}
}

Building Your Own Reference Architecture

Rather than searching for a complete example, build your own reference implementation incrementally:

Start with authentication: Use Auth0, Clerk, or Supabase Auth. Don't roll your own.
Add multi-tenancy: Implement the row-level security pattern above.
Implement RBAC: Start simple, but use a structure that can grow.
Integrate billing: Stripe is the standard. Use their webhooks religiously.
Add audit logging: Track every important action from day one.
Build API rate limiting: Use Redis and the token bucket algorithm.

Each of these deserves its own deep dive, but this foundation will serve you better than any todo-app-style example ever could.

Conclusion: Patterns Over Examples

The lack of complete B2B SaaS examples isn't a problem to solve—it's a reality to accept. The real value isn't in seeing someone else's monolithic codebase; it's in understanding the patterns that make B2B SaaS applications work at scale.

Focus on multi-tenancy, authorization, subscription management, and audit logging. Get these right from the start, and you'll avoid the painful rewrites that plague SaaS startups.

The code you write today, informed by these patterns, will become your own reference architecture. And it'll be better than any generic example because it'll be tailored to your specific domain and requirements.

Now stop searching for the perfect example and start building. The patterns above are your blueprint.