Startup Fundraising Complete Guide: From Seed to Series A and Beyond

class FundableStartup:
    """Checklist for a fundable startup."""
    
    def __init__(self):
        self.requirements = {
            'founder_qualifications': {
                'experience': 'Relevant industry experience',
                'commitment': 'Full-time dedication',
                'capability': 'Technical + business skills'
            },
            'traction_metrics': {
                'users': '1000+ active users',
                'revenue': '$10K+ MRR (B2B)',
                'growth': '10%+ month-over-month'
            },
            'product_milestones': {
                'mvp': 'Working product launched',
                'retention': 'Strong user retention',
                'feedback': 'Clear customer feedback loop'
            },
            'market_opportunity': {
                'tam': 'Large total addressable market',
                'growth': 'Growing market',
                'timing': 'Right time for solution'
            }
        }
    
    def assess_fundability(self, company_data: dict) -> dict:
        """Assess if company is ready for fundraising."""
        
        score = 0
        max_score = 100
        feedback = []
        
        # Check founders (30 points)
        if company_data.get('founder_experience'):
            score += 15
        if company_data.get('technical_founder'):
            score += 15
        
        # Check traction (40 points)
        if company_data.get('users', 0) > 1000:
            score += 20
        if company_data.get('revenue', 0) > 10000:
            score += 20
        
        # Check product (20 points)
        if company_data.get('mvp_launched'):
            score += 10
        if company_data.get('users_love_product'):
            score += 10
        
        # Check market (10 points)
        if company_data.get('large_market'):
            score += 10
        
        readiness = 'High' if score >= 80 else 'Medium' if score >= 50 else 'Low'
        
        return {
            'score': score,
            'max_score': max_score,
            'readiness': readiness,
            'feedback': feedback
        }


# Example assessment
company = {
    'founder_experience': True,
    'technical_founder': True,
    'users': 5000,
    'revenue': 25000,
    'mvp_launched': True,
    'users_love_product': True,
    'large_market': True
}

startup = FundableStartup()
result = startup.assess_fundability(company)
print(f"Fundability Score: {result['score']}/{result['max_score']}")
print(f"Readiness: {result['readiness']}")

class PitchDeck:
    """Structure for a compelling pitch deck."""
    
    slides = [
        {
            'slide': 1,
            'title': 'Problem',
            'content': 'The pain point you solve',
            'tips': 'Use data, tell a story'
        },
        {
            'slide': 2,
            'title': 'Solution',
            'content': 'Your product/service',
            'tips': 'Demo, before/after'
        },
        {
            'slide': 3,
            'title': 'Market Opportunity',
            'content': 'TAM, SAM, SOM',
            'tips': 'Bottom-up analysis'
        },
        {
            'slide': 4,
            'title': 'Business Model',
            'content': 'How you make money',
            'tips': 'Pricing, unit economics'
        },
        {
            'slide': 5,
            'title': 'Traction',
            'content': 'Growth metrics',
            'tips': 'Graphs, customer quotes'
        },
        {
            'slide': 6,
            'title': 'Team',
            'content': 'Why you?',
            'tips': 'Relevant experience'
        },
        {
            'slide': 7,
            'title': 'Financials',
            'content': 'Projections',
            'tips': '3-year forecast'
        },
        {
            'slide': 8,
            'title': 'The Ask',
            'content': 'How much and why',
            'tips': 'Clear use of funds'
        }
    ]
    
    def generate_outline(self) -> str:
        """Generate pitch deck outline."""
        return "\n\n".join(
            f"Slide {s['slide']}: {s['title']}\n{s['content']}"
            for s in self.slides
        )

# SAFE (Simple Agreement for Future Equity)

## Investment Details:
- Company: [Company Name]
- Investor: [Investor Name]
- Investment Amount: $[Amount]

## Key Terms:

### 1. Valuation Cap: $[Amount]
   - Maximum valuation at which SAFE converts to equity
   - Protects early investors from excessive dilution

### 2. Discount: [X]%
   - Discount on Series A price
   - Rewards early risk-taking

### 3. MFN Provision
   - Most Favored Nation
   - Match better terms if offered in future

### 4. Pro-Rata Rights
   - Right to participate in future rounds
   - Maintain ownership percentage

### 5. Liquidation Preference
   - Non-participating (standard 1x)
   - or Participating

## When SAFE Converts:
- Upon priced round (Series A or later)
- At maturity (typically 2 years)
- Upon change of control

def compare_investment_instruments():
    """Compare SAFE and Convertible Note."""
    
    comparison = {
        'SAFE': {
            'debt_or_equity': 'Not debt, future equity',
            'interest': 'None',
            'maturity': 'No set maturity date',
            'complexity': 'Simple, one-page document',
            'legal_costs': 'Lower',
            'investor_protection': 'Limited'
        },
        'Convertible Note': {
            'debt_or_equity': 'Debt instrument',
            'interest': 'Typically 5-8%',
            'maturity': '18-24 months',
            'complexity': 'More complex',
            'legal_costs': 'Higher',
            'investor_protection': 'Stronger (debt seniority)'
        }
    }
    
    return comparison


# Example comparison table
print("SAFE vs Convertible Note:")
print("-" * 50)
print(f"{'Feature':<20} {'SAFE':<15} {'Note':<15}")
print("-" * 50)
for feature, values in compare_investment_instruments().items():
    print(f"{feature:<20} {values['debt_or_equity']:<15}")

# Term Sheet Summary

## Company: [Name]
## Investor: [VC Name]
## Investment: $[Amount] for [X]% ownership

## Valuation:
- Pre-money: $[Amount]
- Post-money: $[Amount]
- Option pool: [X]% (post-money)

## Liquidation Preference:
- 1x Non-Participating Preferred

## Dividends:
- 6% Cumulative, Preferred

## Board Composition:
- 2 Directors (Investors)
- 2 Directors (Founders)
- 1 Independent

## Protective Provisions:
- Requires investor approval for:
  - Issuing new shares
  - Selling company
  - Incurring debt > $[Amount]
  - Changing board size

## Pro-Rata Rights:
- Full pro-rata rights for all rounds

## Vesting:
- 4-year vesting with 1-year cliff
- Acceleration on acquisition (50%)

## Founder Restrictions:
- 2-year lockup post-IPO
- Non-compete provisions

class FundraisingPipeline:
    """Manage your fundraising process."""
    
    def __init__(self, target_amount: int):
        self.target_amount = target_amount
        self.investors = []
        self.stage = 'research'
    
    def add_investor(self, name: str, type: str, priority: str):
        """Add investor to pipeline."""
        self.investors.append({
            'name': name,
            'type': type,  # 'angel', 'vc', 'corporate'
            'priority': priority,  # 'high', 'medium', 'low'
            'status': 'researching',
            'commitment': 0,
            'notes': ''
        })
    
    def prioritize_investors(self):
        """Sort investors by priority."""
        priority_order = {'high': 0, 'medium': 1, 'low': 2}
        self.investors.sort(
            key=lambda x: (priority_order[x['priority']], -x.get('commitment', 0))
        )
    
    def track_outreach(self):
        """Track outreach progress."""
        total = len(self.investors)
        committed = sum(1 for i in self.investors if i.get('commitment', 0) > 0)
        in_conversation = sum(
            1 for i in self.investors 
            if i['status'] in ['meeting', 'discussing', 'due_diligence']
        )
        
        return {
            'total_investors': total,
            'committed': committed,
            'committed_amount': sum(i.get('commitment', 0) for i in self.investors),
            'in_conversation': in_conversation,
            'remaining': self.target_amount - committed
        }


# Example pipeline
pipeline = FundraisingPipeline(1000000)

# Add potential investors
pipeline.add_investor('Sequoia', 'vc', 'high')
pipeline.add_investor('a16z', 'vc', 'high')
pipeline.add_investor('John Angel', 'angel', 'medium')
pipeline.add_investor('Jane Smith', 'angel', 'medium')

# Track progress
status = pipeline.track_outreach()
print(f"Investors: {status['total_investors']}")
print(f"Committed: ${status['committed_amount']:,} / ${status['remaining']:,} needed")

def fundraising_timeline():
    """Typical fundraising timeline."""
    
    phases = {
        'Preparation (4-8 weeks)': [
            'Refine pitch deck',
            'Build data room',
            'Practice pitch',
            'Identify target investors'
        ],
        'Outreach (2-4 weeks)': [
            'Warm introductions preferred',
            'Follow up persistently',
            'Schedule meetings'
        ],
        'Meetings (4-6 weeks)': [
            'First meetings (intro)',
            'Second meetings (deep dive)',
            'Partner meetings'
        ],
        'Due Diligence (2-4 weeks)': [
            'Data room review',
            'Customer references',
            'Legal review'
        ],
        'Term Sheet (1-2 weeks)': [
            'Receive term sheet',
            'Negotiate terms',
            'Compare multiple term sheets'
        ],
        'Close (1-2 weeks)': [
            'Legal documentation',
            'Wire transfers',
            'Announce round'
        ]
    }
    
    return phases

def term_negotiation_guide():
    """Key terms and negotiation strategies."""
    
    return {
        'valuation': {
            'typical_range': '$2M - $15M (Seed)',
            'leverage': 'Multiple term sheets',
            'tips': 'Don't optimize for valuation'
        },
        'option_pool': {
            'typical_range': '10-20%',
            'leverage': 'Pre-money vs post-money',
            'tips': 'Negotiate for post-money'
        },
        'board_seats': {
            'typical_range': '1-2 seats',
            'leverage': 'Total board composition',
            'tips': 'Maintain founder control'
        },
        'liquidation_preference': {
            'typical_range': '1x non-participating',
            'leverage': 'Market standard',
            'tips': 'Avoid >1x participating'
        },
        'pro_rata': {
            'typical_range': 'Full pro-rata',
            'leverage': 'Must-haves for VCs',
            'tips': 'Fight for it'
        },
        'vesting': {
            'typical_range': '4yr + 1yr cliff',
            'leverage': 'Credit for time served',
            'tips': 'Negotiate founder friendly terms'
        }
    }

def close_round_steps():
    """Steps to close a funding round."""
    
    return [
        {
            'step': 1,
            'title': 'Verify Commitments',
            'description': 'Confirm all investors can close on time'
        },
        {
            'step': 2,
            'title': 'Legal Documentation',
            'description': 'Execute SAFE/Stock Purchase Agreements'
        },
        {
            'step': 3,
            'title': 'Due Diligence',
            'description': 'Complete legal and financial DD'
        },
        {
            'step': 4,
            'title': 'Corporate Filings',
            'description': 'File amended bylaws, board resolutions'
        },
        {
            'step': 5,
            'title': 'Funds Transfer',
            'description': 'Receive wire transfers from investors'
        },
        {
            'step': 6,
            'title': 'Update Cap Table',
            'description': 'Track new ownership percentages'
        },
        {
            'step': 7,
            'title': 'Announce',
            'description': 'Press release, social media, emails'
        }
    ]