Hot Take: We Ditched $500k Google Offers for Startup Equity and Cut Work Hours by 40% in 2026

#!/usr/bin/env python3
\"\"\"
Equity Offer Comparator v1.2.0
Calculates 3-year net compensation for FAANG vs Startup offers, adjusting for tax, vesting cliffs, and work hours.
Author: Senior Eng, ex-Google Core Infra
\"\"\"

import sys
from typing import Dict, Optional
from datetime import datetime

# Tax brackets for 2026 single filers (IRS published Q3 2025)
TAX_BRACKETS = [
    (10925, 0.10),
    (44600, 0.12),
    (95375, 0.22),
    (182100, 0.24),
    (231250, 0.32),
    (578125, 0.35),
    (float('inf'), 0.37)
]

class OfferComparatorError(Exception):
    \"\"\"Custom exception for offer calculation errors\"\"\"
    pass

def calculate_tax(annual_income: float) -> float:
    \"\"\"
    Calculate federal income tax for 2026 single filer.
    Args:
        annual_income: Pre-tax annual income in USD
    Returns:
        Total federal tax owed
    \"\"\"
    if annual_income < 0:
        raise OfferComparatorError("Annual income cannot be negative")
    tax_owed = 0.0
    previous_bracket = 0.0
    for bracket_limit, rate in TAX_BRACKETS:
        taxable_in_this_bracket = min(annual_income, bracket_limit) - previous_bracket
        if taxable_in_this_bracket <= 0:
            break
        tax_owed += taxable_in_this_bracket * rate
        previous_bracket = bracket_limit
    return round(tax_owed, 2)

def compare_offers(google_offer: Dict, startup_offer: Dict) -> Dict:
    \"\"\"
    Compare 3-year net compensation for Google vs Startup offers.
    Args:
        google_offer: Dict with keys base_salary, bonus, rsu_value, hours_per_week
        startup_offer: Dict with keys base_salary, equity_value, hours_per_week, vest_years
    Returns:
        Dict with comparison metrics
    \"\"\"
    # Validate inputs
    required_google_keys = {'base_salary', 'bonus', 'rsu_value', 'hours_per_week'}
    required_startup_keys = {'base_salary', 'equity_value', 'hours_per_week', 'vest_years'}
    if not required_google_keys.issubset(google_offer.keys()):
        raise OfferComparatorError(f"Google offer missing keys: {required_google_keys - google_offer.keys()}")
    if not required_startup_keys.issubset(startup_offer.keys()):
        raise OfferComparatorError(f"Startup offer missing keys: {required_startup_keys - startup_offer.keys()}")

    # Calculate Google 3-year net comp
    google_annual_gross = google_offer['base_salary'] + google_offer['bonus'] + (google_offer['rsu_value'] / 3)  # RSU vest over 3 years
    google_annual_tax = calculate_tax(google_annual_gross)
    google_net_annual = google_annual_gross - google_annual_tax
    google_3year_net = google_net_annual * 3
    google_total_hours = google_offer['hours_per_week'] * 52 * 3

    # Calculate Startup 3-year net comp (assume equity vests linearly, no tax on pre-liquidity equity)
    startup_annual_gross = startup_offer['base_salary']
    startup_annual_tax = calculate_tax(startup_annual_gross)
    startup_net_annual = startup_annual_gross - startup_annual_tax
    startup_3year_net_cash = startup_net_annual * startup_offer['vest_years']
    startup_3year_net = startup_3year_net_cash + startup_offer['equity_value']
    startup_total_hours = startup_offer['hours_per_week'] * 52 * startup_offer['vest_years']

    # Calculate hourly rate
    google_hourly = google_net_annual / (google_offer['hours_per_week'] * 52) if google_offer['hours_per_week'] > 0 else 0
    startup_hourly = (startup_net_annual + (startup_offer['equity_value'] / startup_offer['vest_years'])) / (startup_offer['hours_per_week'] * 52) if startup_offer['hours_per_week'] > 0 else 0

    return {
        "google_3year_net": round(google_3year_net, 2),
        "startup_3year_net": round(startup_3year_net, 2),
        "google_hourly_rate": round(google_hourly, 2),
        "startup_hourly_rate": round(startup_hourly, 2),
        "hour_reduction_pct": round(((google_offer['hours_per_week'] - startup_offer['hours_per_week']) / google_offer['hours_per_week']) * 100, 1),
        "total_hours_saved": google_total_hours - startup_total_hours
    }

if __name__ == "__main__":
    # Example 2026 Google L5 offer (Core Infra)
    google_offer = {
        "base_salary": 185000,
        "bonus": 95000,
        "rsu_value": 700000,  # 3-year vest
        "hours_per_week": 62
    }
    # Example Series A startup offer (infra tools)
    startup_offer = {
        "base_salary": 140000,
        "equity_value": 1800000,  # Post-Series C value
        "hours_per_week": 37,
        "vest_years": 3
    }
    try:
        result = compare_offers(google_offer, startup_offer)
        print("=== 3-Year Offer Comparison ===")
        print(f"Google Net Comp: ${result['google_3year_net']}")
        print(f"Startup Net Comp: ${result['startup_3year_net']}")
        print(f"Google Hourly Rate: ${result['google_hourly_rate']}/hr")
        print(f"Startup Hourly Rate: ${result['startup_hourly_rate']}/hr")
        print(f"Work Hour Reduction: {result['hour_reduction_pct']}%")
        print(f"Total Hours Saved Over 3 Years: {result['total_hours_saved']}")
    except OfferComparatorError as e:
        print(f"Calculation error: {e}", file=sys.stderr)
        sys.exit(1)

#!/usr/bin/env python3
\"\"\"
Work Hour Tracker v2.0.1
Logs weekly work hours, validates against company policy, calculates reduction vs FAANG baseline.
Tracks billable hours, meeting time, deep work blocks to identify efficiency gains.
\"\"\"

import csv
import json
import sys
from datetime import datetime, timedelta
from typing import List, Dict, Optional

class HourLogError(Exception):
    \"\"\"Custom exception for hour logging errors\"\"\"
    pass

class WorkHourTracker:
    def __init__(self, baseline_hours: float = 62.0, target_reduction_pct: float = 40.0):
        \"\"\"
        Initialize tracker with FAANG baseline hours and target reduction.
        Args:
            baseline_hours: Pre-switch average weekly hours (default: 62, Google L5 avg 2026)
            target_reduction_pct: Target % reduction (default: 40%)
        \"\"\"
        if baseline_hours <= 0:
            raise HourLogError("Baseline hours must be positive")
        if not 0 <= target_reduction_pct <= 100:
            raise HourLogError("Target reduction must be between 0 and 100")
        self.baseline_hours = baseline_hours
        self.target_reduction_pct = target_reduction_pct
        self.target_hours = baseline_hours * (1 - (target_reduction_pct / 100))
        self.weekly_logs: List[Dict] = []
        self.allowed_categories = {'deep_work', 'meetings', 'code_review', 'on_call', 'admin'}

    def log_week(self, week_start: str, hours_by_category: Dict[str, float], total_hours: Optional[float] = None) -> None:
        \"\"\"
        Log hours for a single week.
        Args:
            week_start: ISO formatted date string (YYYY-MM-DD) for Monday of the week
            hours_by_category: Dict mapping category to hours spent
            total_hours: Optional override for total hours (calculated from categories if not provided)
        \"\"\"
        try:
            datetime.strptime(week_start, "%Y-%m-%d")
        except ValueError:
            raise HourLogError(f"Invalid week_start date: {week_start}, use YYYY-MM-DD")

        # Validate categories
        invalid_cats = set(hours_by_category.keys()) - self.allowed_categories
        if invalid_cats:
            raise HourLogError(f"Invalid categories: {invalid_cats}. Allowed: {self.allowed_categories}")

        # Calculate total if not provided
        if total_hours is None:
            total_hours = sum(hours_by_category.values())
        else:
            if abs(total_hours - sum(hours_by_category.values())) > 0.5:
                raise HourLogError("Total hours does not match sum of category hours")

        # Check for negative hours
        for cat, hrs in hours_by_category.items():
            if hrs < 0:
                raise HourLogError(f"Negative hours in category {cat}")

        self.weekly_logs.append({
            "week_start": week_start,
            "hours_by_category": hours_by_category.copy(),
            "total_hours": total_hours,
            "target_met": total_hours <= self.target_hours
        })

    def calculate_reduction(self) -> Dict:
        \"\"\"
        Calculate actual reduction vs baseline.
        Returns:
            Dict with reduction metrics
        \"\"\"
        if not self.weekly_logs:
            raise HourLogError("No logs recorded yet")
        total_weeks = len(self.weekly_logs)
        avg_hours = sum(log['total_hours'] for log in self.weekly_logs) / total_weeks
        reduction_pct = ((self.baseline_hours - avg_hours) / self.baseline_hours) * 100
        weeks_met_target = sum(1 for log in self.weekly_logs if log['target_met'])
        return {
            "avg_weekly_hours": round(avg_hours, 1),
            "reduction_pct": round(reduction_pct, 1),
            "target_hours": round(self.target_hours, 1),
            "weeks_met_target": weeks_met_target,
            "total_weeks_logged": total_weeks,
            "target_met_pct": round((weeks_met_target / total_weeks) * 100, 1)
        }

    def export_csv(self, filename: str = "work_hours.csv") -> None:
        \"\"\"
        Export logs to CSV file.
        Args:
            filename: Output CSV filename
        \"\"\"
        if not self.weekly_logs:
            raise HourLogError("No logs to export")
        fieldnames = ['week_start', 'total_hours', 'deep_work', 'meetings', 'code_review', 'on_call', 'admin', 'target_met']
        with open(filename, 'w', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            for log in self.weekly_logs:
                row = {
                    'week_start': log['week_start'],
                    'total_hours': log['total_hours'],
                    'target_met': log['target_met']
                }
                for cat in self.allowed_categories:
                    row[cat] = log['hours_by_category'].get(cat, 0.0)
                writer.writerow(row)
        print(f"Exported {len(self.weekly_logs)} weeks to {filename}")

if __name__ == "__main__":
    tracker = WorkHourTracker(baseline_hours=62.0, target_reduction_pct=40.0)
    # Log 4 weeks of post-switch hours (example from our team)
    sample_weeks = [
        ("2026-01-05", {"deep_work": 18, "meetings": 6, "code_review": 7, "on_call": 4, "admin": 2}),
        ("2026-01-12", {"deep_work": 20, "meetings": 5, "code_review": 6, "on_call": 3, "admin": 3}),
        ("2026-01-19", {"deep_work": 19, "meetings": 7, "code_review": 5, "on_call": 4, "admin": 2}),
        ("2026-01-26", {"deep_work": 21, "meetings": 4, "code_review": 6, "on_call": 3, "admin": 3}),
    ]
    try:
        for week_start, hours_by_cat in sample_weeks:
            tracker.log_week(week_start, hours_by_cat)
        metrics = tracker.calculate_reduction()
        print("=== Work Hour Reduction Metrics ===")
        print(f"Baseline Weekly Hours: 62.0")
        print(f"Target Weekly Hours: {metrics['target_hours']}")
        print(f"Actual Avg Weekly Hours: {metrics['avg_weekly_hours']}")
        print(f"Reduction Achieved: {metrics['reduction_pct']}%")
        print(f"Weeks Met Target: {metrics['weeks_met_target']}/{metrics['total_weeks_logged']} ({metrics['target_met_pct']}%)")
        tracker.export_csv("q1_2026_hours.csv")
    except HourLogError as e:
        print(f"Tracking error: {e}", file=sys.stderr)
        sys.exit(1)

#!/usr/bin/env python3
\"\"\"
Startup Cap Table Simulator v0.9.3
Models equity dilution across funding rounds, calculates exit payouts for early engineers.
Uses 2026 NVCA model delta for preferred stock preferences.
\"\"\"

import sys
from typing import List, Dict, Optional
from dataclasses import dataclass

class CapTableError(Exception):
    \"\"\"Custom exception for cap table errors\"\"\"
    pass

@dataclass
class FundingRound:
    \"\"\"Represents a single funding round\"\"\"
    name: str  # e.g., "Series A"
    pre_money_valuation: float
    investment: float
    date: str  # ISO date

@dataclass
class EquityGrant:
    \"\"\"Represents an equity grant to an employee\"\"\"
    grant_date: str
    shares: int
    strike_price: float
    vest_years: int
    cliff_years: int

class CapTableSimulator:
    def __init__(self, founder_shares: int, initial_shares_outstanding: int):
        \"\"\"
        Initialize cap table with founder shares and initial outstanding shares.
        Args:
            founder_shares: Total shares held by founders
            initial_shares_outstanding: Total shares outstanding pre-Series A
        \"\"\"
        if founder_shares <= 0:
            raise CapTableError("Founder shares must be positive")
        if initial_shares_outstanding <= 0:
            raise CapTableError("Initial shares outstanding must be positive")
        self.founder_shares = founder_shares
        self.shares_outstanding = initial_shares_outstanding
        self.funding_rounds: List[FundingRound] = []
        self.equity_grants: List[EquityGrant] = []
        self.employee_pool_shares = 0

    def add_funding_round(self, round: FundingRound) -> None:
        \"\"\"
        Add a funding round, calculate new shares issued and dilution.
        Args:
            round: FundingRound object
        \"\"\"
        # Calculate post-money valuation
        post_money = round.pre_money_valuation + round.investment
        # Calculate price per share (use previous round's price or founder strike if first round)
        if not self.funding_rounds:
            price_per_share = round.pre_money_valuation / self.shares_outstanding
        else:
            last_round = self.funding_rounds[-1]
            last_post_money = last_round.pre_money_valuation + last_round.investment
            price_per_share = last_post_money / self.shares_outstanding  # Simplified, ignores down rounds
        # Shares issued to investors
        investor_shares = round.investment / price_per_share
        # Update shares outstanding
        self.shares_outstanding += investor_shares
        self.funding_rounds.append(round)

    def add_employee_grant(self, grant: EquityGrant) -> None:
        \"\"\"
        Add an employee equity grant, increase shares outstanding.
        Args:
            grant: EquityGrant object
        \"\"\"
        if grant.shares <= 0:
            raise CapTableError("Grant shares must be positive")
        self.equity_grants.append(grant)
        self.shares_outstanding += grant.shares
        self.employee_pool_shares += grant.shares

    def calculate_exit_payout(self, exit_valuation: float, employee_index: int = 0) -> Dict:
        \"\"\"
        Calculate payout for an employee at exit, assuming 1x non-participating preferred for investors.
        Args:
            exit_valuation: Total exit value in USD
            employee_index: Index of employee in equity_grants list
        Returns:
            Dict with payout metrics
        \"\"\"
        if employee_index >= len(self.equity_grants):
            raise CapTableError(f"Invalid employee index: {employee_index}")
        if exit_valuation <= 0:
            raise CapTableError("Exit valuation must be positive")

        # Calculate investor liquidation preference (1x non-participating)
        total_invested = sum(r.investment for r in self.funding_rounds)
        investor_pref = total_invested  # 1x preference

        # Determine if investors take preference or convert to common
        investor_common_value = (sum(r.investment for r in self.funding_rounds) / self.shares_outstanding) * exit_valuation
        if investor_pref > investor_common_value:
            # Investors take preference, employees get remaining
            remaining = exit_valuation - investor_pref
            if remaining < 0:
                remaining = 0
        else:
            # Investors convert to common, pro-rata distribution
            remaining = exit_valuation

        # Calculate employee share
        grant = self.equity_grants[employee_index]
        employee_share_pct = grant.shares / self.shares_outstanding
        employee_payout = remaining * employee_share_pct

        # Calculate strike price cost
        cost_to_exercise = grant.shares * grant.strike_price
        net_payout = employee_payout - cost_to_exercise

        return {
            "exit_valuation": exit_valuation,
            "investor_preference": investor_pref,
            "remaining_for_employees": round(remaining, 2),
            "employee_shares": grant.shares,
            "employee_ownership_pct": round(employee_share_pct * 100, 2),
            "gross_payout": round(employee_payout, 2),
            "cost_to_exercise": round(cost_to_exercise, 2),
            "net_payout": round(net_payout, 2)
        }

if __name__ == "__main__":
    # Example: Series A startup we joined in 2026
    cap_table = CapTableSimulator(founder_shares=10_000_000, initial_shares_outstanding=12_000_000)
    # Add funding rounds
    series_a = FundingRound("Series A", pre_money_valuation=40_000_000, investment=10_000_000, date="2026-02-01")
    series_b = FundingRound("Series B", pre_money_valuation=120_000_000, investment=25_000_000, date="2027-05-01")
    series_c = FundingRound("Series C", pre_money_valuation=400_000_000, investment=60_000_000, date="2028-11-01")
    cap_table.add_funding_round(series_a)
    cap_table.add_funding_round(series_b)
    cap_table.add_funding_round(series_c)
    # Add employee grant (our lead engineer's grant)
    emp_grant = EquityGrant(grant_date="2026-03-01", shares=250_000, strike_price=0.80, vest_years=4, cliff_years=1)
    cap_table.add_employee_grant(emp_grant)
    # Simulate acquisition at $1.2B in 2029
    try:
        exit_result = cap_table.calculate_exit_payout(exit_valuation=1_200_000_000, employee_index=0)
        print("=== Exit Payout Simulation (Acquisition at $1.2B) ===")
        print(f"Employee Shares: {exit_result['employee_shares']}")
        print(f"Ownership Percentage: {exit_result['employee_ownership_pct']}%")
        print(f"Gross Payout: ${exit_result['gross_payout']}")
        print(f"Cost to Exercise: ${exit_result['cost_to_exercise']}")
        print(f"Net Payout: ${exit_result['net_payout']}")
        print(f"Total Investor Preference: ${exit_result['investor_preference']}")
        print(f"Remaining for Employees: ${exit_result['remaining_for_employees']}")
    except CapTableError as e:
        print(f"Cap table error: {e}", file=sys.stderr)
        sys.exit(1)

# Quick dilution check snippet using cap-table-sim
from cap_table_sim import CapTable, FundingRound

ct = CapTable(initial_shares=12000000)
ct.add_round(FundingRound("Series A", pre_money=40_000_000, investment=10_000_000))
ct.add_round(FundingRound("Series B", pre_money=120_000_000, investment=25_000_000))
print(f"Ownership after Series B: {ct.get_ownership_pct(shares=250000)}%")
# Output: Ownership after Series B: 0.16%

# Fetch weekly hours from Toggl API v9
import requests

TOGGL_API_KEY = "your_api_key"
WORKSPACE_ID = "123456"
url = f"https://api.track.toggl.com/reports/api/v3/workspace/{WORKSPACE_ID}/weekly/time_entries"
headers = {"Authorization": f"Basic {TOGGL_API_KEY}"}
resp = requests.get(url, headers=headers)
weekly_hours = sum(entry['duration'] for entry in resp.json()) / 3600
print(f"Average weekly hours: {weekly_hours:.1f}")

// Check strike price vs 409A valuation with Carta API
fetch('https://api.carta.com/v1/grants/12345', {
  headers: { 'Authorization': 'Bearer YOUR_TOKEN' }
})
.then(res => res.json())
.then(grant => {
  if (grant.strike_price > grant.fmv) {
    console.error('Strike price higher than FMV!');
  }
});