---
name: marketing-for-founders-saas-growth
description: Access curated marketing strategies and channels to acquire the first 10/100/1000 users for SaaS products and startups
triggers:
  - "how do I get my first users for my startup"
  - "where can I launch my SaaS product"
  - "show me marketing strategies for early stage startups"
  - "help me create a product hunt launch plan"
  - "what are the best channels to promote my app"
  - "how do I do cold outreach for my SaaS"
  - "give me a go-to-market strategy for founders"
  - "where should I post about my new product"
---

# Marketing for Founders - SaaS Growth Skill

> Skill by [ara.so](https://ara.so) — Marketing Skills collection.

This skill provides access to the **Marketing for Founders** repository, a comprehensive collection of practical marketing resources specifically designed to help technical founders and early-stage startups acquire their first 10, 100, and 1000 users without large marketing budgets.

## What This Resource Covers

The Marketing for Founders collection provides actionable strategies across multiple marketing channels:

- **Launch Platforms**: 50+ directories and communities to announce your product
- **Product Hunt Strategy**: Complete launch playbooks and templates
- **Social Media Marketing**: Building in public and social listening tactics
- **Cold Outreach**: Sales frameworks and ICP templates
- **SEO & Content**: Organic growth strategies
- **Reddit Marketing**: Community engagement guidelines
- **Email Marketing**: List building and nurturing
- **Conversion Optimization**: Landing page and pricing strategies
- **Idea Validation**: User research frameworks

## Installation & Access

This is a curated resource list, not an installable package. Access it via:

```bash
# Clone the repository
git clone https://github.com/EdoStra/Marketing-for-Founders.git
cd Marketing-for-Founders

# View the main resource list
cat README.md
```

Or bookmark the GitHub repository: `https://github.com/EdoStra/Marketing-for-Founders`

## Key Marketing Channels & Strategies

### 1. Launch Platform Strategy

When launching a new product, target multiple platforms simultaneously:

```markdown
## Launch Checklist Template

### Pre-Launch (1 week before)
- [ ] Product Hunt: Prepare hunter, gallery images, tagline
- [ ] Hacker News: Draft Show HN post
- [ ] Reddit: Identify 3-5 relevant subreddits
- [ ] Indie Hackers: Complete product profile
- [ ] Betalist/Microlaunch: Submit application

### Launch Day
- [ ] Post to Product Hunt (12:01 AM PST)
- [ ] Share on Hacker News
- [ ] Post to Reddit communities (check rules)
- [ ] Announce on LinkedIn/Twitter
- [ ] Email existing subscribers

### Post-Launch (1 week after)
- [ ] Submit to 10+ directories (G2, Capterra, AlternativeTo)
- [ ] Respond to all comments/feedback
- [ ] Document metrics (traffic, signups, conversions)
```

**Primary Launch Platforms:**
- **Product Hunt**: Best for tech products, prepare 2 weeks in advance
- **Hacker News**: Show HN format, honest/technical approach
- **Betalist**: Early-stage products, focus on beta testers
- **Indie Hackers**: Community-first, build relationships before launching

### 2. Product Hunt Launch Framework

```javascript
// Product Hunt Launch Tracker
const productHuntLaunch = {
  preparation: {
    timeline: "2-3 weeks before launch",
    tasks: [
      "Create compelling gallery (6+ images)",
      "Write clear tagline (60 chars max)",
      "Prepare maker comment (explain problem/solution)",
      "Line up 10+ supporters for launch day",
      "Schedule launch for Tuesday-Thursday 12:01 AM PST"
    ]
  },
  
  launchDay: {
    schedule: [
      { time: "00:01 PST", action: "Go live on Product Hunt" },
      { time: "00:05 PST", action: "Post maker comment" },
      { time: "06:00 PST", action: "Tweet announcement" },
      { time: "09:00 PST", action: "LinkedIn post" },
      { time: "All day", action: "Respond to every comment within 1 hour" }
    ]
  },
  
  metrics: {
    target: {
      upvotes: 300, // Top 5 product
      comments: 50,
      clickthrough: "15%",
      signups: 200
    }
  }
};

// Example: Track launch performance
function trackLaunchMetrics(source, signups, conversions) {
  return {
    source,
    signups,
    conversions,
    conversionRate: (conversions / signups * 100).toFixed(2) + '%',
    timestamp: new Date().toISOString()
  };
}

console.log(trackLaunchMetrics('ProductHunt', 250, 38));
// { source: 'ProductHunt', signups: 250, conversions: 38, conversionRate: '15.20%', ... }
```

### 3. Building in Public on Social Media

```python
# Social Media Content Calendar Generator
from datetime import datetime, timedelta

def generate_bip_content_calendar(product_name, launch_date):
    """
    Generate a 30-day Building in Public content calendar
    """
    calendar = []
    start_date = datetime.strptime(launch_date, "%Y-%m-%d") - timedelta(days=30)
    
    content_themes = [
        "Problem Discovery", "Solution Design", "Tech Stack Choice",
        "Development Update", "Design Decisions", "Feature Showcase",
        "Challenges & Learnings", "Metrics Update", "User Feedback",
        "Launch Preparation"
    ]
    
    for i in range(30):
        post_date = start_date + timedelta(days=i)
        theme = content_themes[i % len(content_themes)]
        
        calendar.append({
            "date": post_date.strftime("%Y-%m-%d"),
            "theme": theme,
            "platforms": ["Twitter", "LinkedIn"],
            "format": "Text + Screenshot" if i % 3 == 0 else "Text only"
        })
    
    return calendar

# Example usage
launch_plan = generate_bip_content_calendar("MyStartup", "2025-06-15")
for post in launch_plan[:5]:
    print(f"{post['date']}: {post['theme']} on {', '.join(post['platforms'])}")
```

**Building in Public Best Practices:**
- Share weekly progress updates with metrics
- Post behind-the-scenes development screenshots
- Ask questions to engage your audience
- Share failures and lessons learned (builds trust)
- Use consistent posting schedule (3-5x per week)

### 4. Cold Outreach & Sales Strategy

```javascript
// Ideal Customer Profile (ICP) Framework
class IdealCustomerProfile {
  constructor(config) {
    this.firmographics = config.firmographics || {};
    this.demographics = config.demographics || {};
    this.psychographics = config.psychographics || {};
    this.behaviors = config.behaviors || {};
  }
  
  validate(prospect) {
    const scores = {
      company_size: this.matchCompanySize(prospect.employees),
      industry: this.matchIndustry(prospect.industry),
      role: this.matchRole(prospect.job_title),
      pain_point: this.matchPainPoint(prospect.challenges)
    };
    
    const totalScore = Object.values(scores).reduce((a, b) => a + b, 0);
    return totalScore / Object.keys(scores).length;
  }
  
  matchCompanySize(employees) {
    const { min, max } = this.firmographics.company_size;
    return (employees >= min && employees <= max) ? 100 : 0;
  }
  
  matchIndustry(industry) {
    return this.firmographics.industries.includes(industry) ? 100 : 0;
  }
  
  matchRole(title) {
    return this.demographics.job_titles.some(t => 
      title.toLowerCase().includes(t.toLowerCase())
    ) ? 100 : 0;
  }
  
  matchPainPoint(challenges) {
    return this.psychographics.pain_points.some(p => 
      challenges.includes(p)
    ) ? 100 : 50;
  }
}

// Example ICP for a developer tool
const devToolICP = new IdealCustomerProfile({
  firmographics: {
    company_size: { min: 10, max: 500 },
    industries: ["SaaS", "Technology", "Fintech"],
    revenue: "$1M-$50M ARR"
  },
  demographics: {
    job_titles: ["CTO", "VP Engineering", "Engineering Manager", "Lead Developer"],
    seniority: ["Manager", "Director", "VP", "C-Level"]
  },
  psychographics: {
    pain_points: [
      "slow development cycles",
      "technical debt",
      "scaling challenges",
      "developer productivity"
    ],
    goals: ["faster shipping", "better code quality", "team efficiency"]
  }
});

// Score a prospect
const prospect = {
  company: "TechStartup Inc",
  employees: 75,
  industry: "SaaS",
  job_title: "VP of Engineering",
  challenges: ["slow development cycles", "scaling challenges"]
};

console.log(`ICP Match Score: ${devToolICP.validate(prospect)}%`);
```

**Cold Email Template Structure:**

```markdown
Subject: Quick question about [specific pain point] at [Company]

Hi [First Name],

I noticed [specific trigger - recent funding/job post/company news] and 
thought you might be dealing with [pain point].

We're helping [similar companies] [specific outcome] by [brief solution].

[Social proof - "Company X reduced Y by Z%"]

Worth a 15-min chat?

[Your Name]
[Title]

P.S. [Personalized note about their company/content]
```

### 5. Social Listening & Engagement

```python
# Social Listening Keyword Tracker
import os
from datetime import datetime

class SocialListeningSetup:
    """
    Setup social listening for high-intent mentions
    """
    def __init__(self, product_name, category):
        self.product_name = product_name
        self.category = category
        self.keywords = self.generate_keywords()
    
    def generate_keywords(self):
        """Generate BOFU (Bottom of Funnel) keywords to track"""
        return {
            "problem_aware": [
                f"struggling with {self.category}",
                f"{self.category} problems",
                f"frustrated with {self.category}",
                f"{self.category} not working"
            ],
            "solution_aware": [
                f"looking for {self.category} tool",
                f"recommendations for {self.category}",
                f"best {self.category} software",
                f"{self.category} alternatives"
            ],
            "competitor_mentions": [
                f"[Competitor] vs",
                f"alternative to [Competitor]",
                f"[Competitor] review",
                f"switching from [Competitor]"
            ]
        }
    
    def f5bot_setup(self):
        """Generate F5Bot.com configuration"""
        all_keywords = []
        for category, keywords in self.keywords.items():
            all_keywords.extend(keywords)
        
        return {
            "tool": "F5Bot (https://f5bot.com)",
            "keywords": all_keywords,
            "platforms": ["Reddit", "Hacker News"],
            "email": "${NOTIFICATION_EMAIL}",
            "note": "Set up one alert per keyword for better tracking"
        }
    
    def reddit_search_urls(self):
        """Generate Reddit search URLs for manual monitoring"""
        base_url = "https://www.reddit.com/search/?q="
        urls = []
        
        for category, keywords in self.keywords.items():
            for keyword in keywords:
                search_query = keyword.replace(" ", "+")
                urls.append({
                    "category": category,
                    "keyword": keyword,
                    "url": f"{base_url}{search_query}&sort=new"
                })
        
        return urls

# Example: Set up listening for a project management tool
listener = SocialListeningSetup("MyPMTool", "project management")
f5_config = listener.f5bot_setup()

print("F5Bot Setup:")
print(f"Monitor these {len(f5_config['keywords'])} keywords:")
for kw in f5_config['keywords'][:5]:
    print(f"  - {kw}")

# Generate Reddit search URLs
reddit_urls = listener.reddit_search_urls()
print(f"\nDaily Reddit searches ({len(reddit_urls)} total):")
for url in reddit_urls[:3]:
    print(f"  {url['keyword']}: {url['url']}")
```

### 6. SEO & Content Marketing Strategy

```javascript
// SEO Content Planner for Developers
const seoContentStrategy = {
  // Target developer-focused keywords
  primaryKeywords: [
    { keyword: "[tool category] for developers", difficulty: "medium", volume: 2400 },
    { keyword: "best [tool] for [framework]", difficulty: "medium", volume: 1800 },
    { keyword: "[problem] solution", difficulty: "low", volume: 900 }
  ],
  
  // Content types that work for dev tools
  contentFormats: [
    {
      type: "Comparison Guide",
      template: "[Your Tool] vs [Competitor] vs [Competitor]",
      example: "Vite vs Webpack vs Parcel: Complete Comparison 2025",
      seoValue: "high", // Captures comparison searches
      conversionValue: "high" // High intent readers
    },
    {
      type: "Integration Tutorial",
      template: "How to integrate [Your Tool] with [Popular Framework]",
      example: "How to use Tailwind CSS with Next.js 14",
      seoValue: "medium",
      conversionValue: "medium"
    },
    {
      type: "Problem-Solution Guide",
      template: "How to solve [common problem] in [language/framework]",
      example: "How to optimize React bundle size in production",
      seoValue: "high",
      conversionValue: "low" // Educational, builds awareness
    },
    {
      type: "Alternative Page",
      template: "[Popular Tool] Alternative - [Your Tool]",
      example: "Postman Alternative for API Testing",
      seoValue: "high",
      conversionValue: "very high"
    }
  ],
  
  // Execution plan
  generateContentCalendar(monthlyBudget) {
    const postsPerMonth = Math.floor(monthlyBudget / 4); // 1 post per week minimum
    
    return {
      month1: ["Comparison Guide", "Tutorial", "Problem-Solution"],
      month2: ["Alternative Page", "Integration Tutorial", "Use Case"],
      month3: ["Advanced Tutorial", "Comparison Guide", "Migration Guide"],
      ongoing: "Update top 3 performing posts quarterly"
    };
  }
};

// Example: Generate content ideas
function generateContentIdeas(productName, category, competitors) {
  const ideas = [];
  
  // Comparison content
  competitors.forEach(competitor => {
    ideas.push({
      title: `${productName} vs ${competitor}: Which ${category} is Right for You?`,
      type: "comparison",
      priority: "high"
    });
  });
  
  // Alternative pages
  competitors.forEach(competitor => {
    ideas.push({
      title: `${competitor} Alternative: ${productName}`,
      type: "alternative",
      priority: "high"
    });
  });
  
  return ideas;
}

const contentIdeas = generateContentIdeas(
  "FastAPI Client",
  "API Testing Tool",
  ["Postman", "Insomnia", "Paw"]
);

console.log("Top Content Ideas:");
contentIdeas.slice(0, 3).forEach(idea => {
  console.log(`- ${idea.title} [${idea.type}]`);
});
```

### 7. Reddit Marketing Strategy

```python
# Reddit Marketing Tracker
class RedditMarketingStrategy:
    """
    Track Reddit marketing activities across relevant subreddits
    """
    def __init__(self):
        self.subreddits = self.get_relevant_subreddits()
    
    def get_relevant_subreddits(self):
        """
        Categorized subreddits for SaaS/startup marketing
        """
        return {
            "launch": [
                {"name": "r/SideProject", "rules": "Use Show & Tell flair", "size": "500k+"},
                {"name": "r/alphaandbetausers", "rules": "Alpha/Beta only", "size": "100k+"},
                {"name": "r/roastmystartup", "rules": "Open to feedback", "size": "50k+"},
                {"name": "r/IMadeThis", "rules": "Original work only", "size": "200k+"}
            ],
            "developer_tools": [
                {"name": "r/webdev", "rules": "Showoff Saturday only", "size": "1M+"},
                {"name": "r/selfhosted", "rules": "Use Product Announcement flair", "size": "500k+"},
                {"name": "r/opensource", "rules": "Open source only", "size": "100k+"}
            ],
            "promotion": [
                {"name": "r/indiehackers", "rules": "Use Self Promotion flair", "size": "50k+"},
                {"name": "r/Entrepreneur", "rules": "Contribute before posting", "size": "1M+"}
            ]
        }
    
    def generate_post_template(self, subreddit_name):
        """
        Generate Reddit post template based on community
        """
        if "roastmystartup" in subreddit_name.lower():
            return """
Title: [Product Name] - [One-line description] - Please roast!

Hey r/roastmystartup,

I've been working on [Product] for [timeframe] to solve [problem].

**What it does:** [2-3 sentences]

**Current stage:** [MVP/Beta/Live]

**Looking for feedback on:**
- Product-market fit
- Pricing strategy
- UI/UX
- Marketing messaging

**Link:** [URL]

I'm here to answer questions and genuinely want honest feedback, even if it's harsh.

What do you think?
"""
        elif "sideproject" in subreddit_name.lower():
            return """
Title: [Emoji] Built [Product Name] - [benefit/outcome]

After [X months] of development, I've launched [Product Name].

**The Problem:** [Describe pain point]

**The Solution:** [How your product solves it]

**Tech Stack:** [List main technologies - Redditors love this]

**What's Next:** [Roadmap items]

Would love to hear your thoughts!

Demo: [URL]
GitHub: [URL if open source]
"""
        else:
            return "Check subreddit rules for specific formatting requirements"
    
    def timing_strategy(self):
        """
        Best times to post on Reddit for maximum visibility
        """
        return {
            "best_days": ["Tuesday", "Wednesday", "Thursday"],
            "avoid_days": ["Friday evening", "Saturday", "Sunday"],
            "optimal_times": [
                "6-8 AM EST (before work)",
                "12-2 PM EST (lunch break)",
                "6-8 PM EST (after work)"
            ],
            "note": "Post early in the day for maximum comment engagement"
        }
    
    def engagement_checklist(self):
        """
        Post-submission engagement tasks
        """
        return [
            "Respond to every comment within 1 hour",
            "Upvote all comments (even critical ones)",
            "Provide additional context when asked",
            "Don't be defensive - embrace feedback",
            "Thank users for trying your product",
            "Follow up on bug reports immediately",
            "Cross-link to other platforms if asked"
        ]

# Example usage
reddit_strategy = RedditMarketingStrategy()

print("Reddit Launch Plan:")
print("\n1. Target Subreddits:")
for category, subreddits in reddit_strategy.subreddits.items():
    print(f"\n{category.upper()}:")
    for sub in subreddits:
        print(f"  - {sub['name']} ({sub['size']}) - {sub['rules']}")

print("\n2. Posting Schedule:")
timing = reddit_strategy.timing_strategy()
print(f"  Best days: {', '.join(timing['best_days'])}")
print(f"  Optimal times: {', '.join(timing['optimal_times'])}")

print("\n3. Example Post Template:")
print(reddit_strategy.generate_post_template("r/roastmystartup"))
```

### 8. Email Marketing & List Building

```javascript
// Email Marketing Framework for SaaS
class EmailMarketingCampaign {
  constructor(config) {
    this.listSize = config.listSize || 0;
    this.sequences = this.initializeSequences();
  }
  
  initializeSequences() {
    return {
      welcome: {
        name: "New User Onboarding",
        emails: [
          {
            day: 0,
            subject: "Welcome to [Product]! Here's how to get started",
            goal: "Activate user",
            cta: "Complete setup"
          },
          {
            day: 2,
            subject: "[First Name], stuck? Here's a quick tutorial",
            goal: "Drive feature adoption",
            cta: "Watch 2-min video"
          },
          {
            day: 5,
            subject: "3 ways [Product] saves you time every day",
            goal: "Show value",
            cta: "Explore features"
          },
          {
            day: 10,
            subject: "You're invited: [Product] live demo",
            goal: "Engagement",
            cta: "Register for demo"
          }
        ]
      },
      
      nurture: {
        name: "Free Trial Conversion",
        emails: [
          {
            day: 0,
            subject: "Your [Product] trial starts now",
            goal: "Set expectat