hiring

# Hiring Technical Help

The most expensive developer is the cheap one who breaks things. This skill helps you decide when to hire vs. use AI tools, find and vet contractors, and manage the founder-developer relationship — even if you can't evaluate code yourself.

**This skill is for hiring and managing technical people.** For writing specs contractors can build from, use **plan**. For trying AI tools before hiring, use **build**. For legal contracts and IP protection, use **legal**.

## Core Principles

- Hire for the problem, not the role. Define what you need done before you look for who can do it.
- A great contractor beats a mediocre full-time hire every time at this stage.
- You can't evaluate code, but you can evaluate communication, reliability, and results.
- The most expensive developer is the cheap one who breaks things. Budget for quality.
- AI tools have moved the line. Many things that used to require hiring now don't.

## When to Hire vs. When to Use AI Tools

### You Do NOT Need to Hire If:

- You need a landing page → Use Lovable, Framer, or Webflow
- You need a CRUD app (create, read, update, delete data) → Use Claude Code, Lovable, or Replit
- You need to integrate Stripe → Tell AI to do it (see payments)
- You need basic auth → AI tools handle this well
- You need UI polish → AI + design system handles 80% of this
- You need simple bug fixes → Describe the bug to Claude Code

### You DO Need to Hire When:

- **Complex integrations** — Connecting to enterprise APIs with poor documentation
- **Performance at scale** — Your app is slow under load and AI-generated fixes aren't working
- **Data migrations** — Moving from one database or architecture to another
- **Security audit** — You need someone to verify your AI-generated code is secure
- **Native mobile apps** — AI tools are weaker here (improving, but still)
- **Infrastructure you don't understand** — Something is broken in production and you can't debug it
- **Ongoing maintenance** — You're spending more time fixing than building

### Decision Framework

```
Do I need to hire?
1. Can I describe the task clearly enough for an AI tool? → Try AI first
2. Did AI fail or produce something that doesn't work? → Try a different AI prompt
3. Still stuck after 2-3 serious attempts? → Time to hire
4. Is this a one-time task or ongoing? → One-time = contractor. Ongoing = consider part-time.
```

**Tell AI:**
```
I'm trying to decide if I need to hire a developer. Here's what I need done:
[describe the task]

I've tried: [what AI tools you used, what happened]

Help me decide: can this be solved with a better prompt or approach,
or do I genuinely need a human developer? If I need to hire,
what type (freelance contractor, part-time dev, agency)?
```

---

## Types of Technical Help

| Type | Cost | Best For | Where to Find |
|------|------|----------|---------------|
| **Freelance contractor** | $50-150/hr | One-time tasks, specific features, bug fixes | Upwork, Toptal, referrals |
| **Part-time developer** | $2-6K/mo | Ongoing development, 10-20 hrs/week | Indie communities, referrals |
| **Fractional CTO** | $3-8K/mo | Architecture decisions, code review, hiring other devs | Toptal, referrals, FounderPath |
| **Dev agency** | $5-20K/project | Full builds, redesigns | Clutch.co, referrals |
| **Technical co-founder** | Equity | Building the company together, long-term | Co-founder matching, network |

**For most solo bootstrapped founders: Start with a freelance contractor.**

---

## Finding Good Developers

### Where to Look (Ranked by Quality)

1. **Personal referrals** — Ask other founders: "Who built your product?" Best source by far.
2. **Indie communities** — Indie Hackers, r/forhire, Twitter/X developer community. Developers here understand SaaS.
3. **Toptal** — Pre-vetted, expensive ($80-150+/hr), but high quality and low risk.
4. **Upwork** — Huge pool, variable quality. You need to vet carefully. More on this below.
5. **Arc.dev, Gun.io, Lemon.io** — Curated freelancer platforms. Mid-range pricing.
6. **Agency** — Good for well-defined projects. Expensive. You lose the direct relationship.

### Red Flags When Evaluating

- **No portfolio or GitHub** — They should be able to show you work they've done
- **Can't explain things simply** — If they use jargon to answer simple questions, they'll be hard to work with
- **"I can build anything"** — Specialists outperform generalists. Look for experience with your stack
- **No questions about your project** — Good developers ask questions before estimating
- **Price way below market** — $15-25/hr for a "senior developer" means they're either lying about experience or in a situation where communication overhead will eat the savings
- **Won't do a small paid trial** — The best test is a real task (see below)

### Green Flags

- They've built SaaS products before (not just websites or WordPress)
- They ask clarifying questions about requirements
- They push back on bad ideas ("You don't need that. Here's a simpler approach.")
- They communicate proactively ("Here's my progress. I'm blocked on X.")
- They have experience with your stack (React, Next.js, Supabase, whatever you're using)
- They can show you something they built that works and looks good

---

## The Paid Trial: Best Hiring Strategy

Never hire based on interviews alone. Do a paid trial.

### How It Works

1. Pick a real but self-contained task from your backlog (a bug fix, a small feature, an integration)
2. Write a clear brief (see Writing a Job Brief below)
3. Pay them their normal rate for 5-10 hours of work
4. Evaluate the result

### What You're Evaluating

- **Communication** — Did they ask clarifying questions? Did they update you on progress?
- **Speed** — How long did it take relative to their estimate?
- **Quality** — Does it work? Does it look right? Did they test it?
- **Independence** — Did they figure things out on their own or need constant hand-holding?
- **Code quality** — You can't read code, but you can: (a) ask Claude Code to review it, (b) ask another developer to glance at it, (c) check if it works without bugs

**Tell AI:**
```
Review this code from a contractor I'm evaluating. Check for:
- Obvious bugs or issues
- Security problems
- Code quality and readability
- Whether it follows the existing codebase patterns
[paste code or point to files]
```

---

## Writing a Job Brief

A good brief gets good candidates. A vague brief gets time-wasters.

### Template

```
# [Task Name]

## What I Need
[2-3 sentences describing the outcome you want. Focus on WHAT, not HOW.]

## Current Setup
- App built with: [framework, e.g., Next.js + Supabase]
- Hosted on: [e.g., Vercel]
- Repo: [GitHub link — you'll share after NDA/agreement]

## Specific Requirements
- [Requirement 1]
- [Requirement 2]
- [Requirement 3]

## What "Done" Looks Like
- [Acceptance criteria 1]
- [Acceptance criteria 2]
- [Acceptance criteria 3]

## Timeline
[When do you need this done?]

## Budget
[Your budget range, or "Tell me your estimate based on this brief"]

## To Apply
Tell me:
1. Have you built something similar before? Show me.
2. How would you approach this?
3. What's your estimated time and cost?
4. What questions do you have?
```

**Tell AI:**
```
Help me write a job brief for a freelance developer. I need:
[describe the task in plain English]
My app is built with [stack]. Format it as a clear brief that
a contractor can estimate from.
```

---

## Managing Contractors

### Communication Cadence

- **Short tasks (< 1 week):** Async updates. Ask for a progress update halfway through.
- **Ongoing work:** Weekly 15-minute sync call + daily async updates in Slack/email.
- **Complex projects:** Start with a kickoff call. Weekly demos of work-in-progress.

### Tools

| Purpose | Tool |
|---------|------|
| Communication | Slack (channel for the project) or email |
| Task tracking | Linear, GitHub Issues, or even a shared doc |
| Code access | GitHub (add them as a collaborator with limited access) |
| Payments | Upwork (built-in), Wise, or direct invoice via Stripe |
| Screen sharing | Loom for async demos, Zoom for live calls |

### Setting Expectations

Have this conversation before work starts:

```
Working Agreement:
- [ ] Scope of work defined in writing (the brief)
- [ ] Payment terms agreed (hourly, fixed-price, milestones)
- [ ] Timeline with milestones (not just a final deadline)
- [ ] Communication expectations (how often, which channel)
- [ ] What happens if scope changes (discuss before building)
- [ ] Code ownership (you own everything they write for you)
- [ ] IP assignment clause (in contract or Upwork ToS)
- [ ] Access to repo, environments, and credentials they need
- [ ] Definition of "done" (your acceptance criteria, not theirs)
```

---

## Budgeting

### Market Rates (2024-2025, USD)

| Level | US/UK/EU | Eastern Europe | Latin America | South/SE Asia |
|-------|----------|---------------|--------------|---------------|
| Junior | $40-75/hr | $25-45/hr | $25-50/hr | $15-30/hr |
| Mid | $75-125/hr | $40-75/hr | $40-75/hr | $25-50/hr |
| Senior | $125-200/hr | $60-120/hr | $60-100/hr | $40-80/hr |

### What to Expect

- **Simple bug fix:** 1-4 hours ($50-400)
- **Small feature:** 5-20 hours ($250-2,000)
- **Medium feature:** 20-60 hours ($1,000-6,000)
- **Full integration:** 40-100 hours ($2,000-10,000)
- **Ongoing part-time dev:** $2,000-6,000/month for 10-20 hrs/week

### Budget Tips

- **Fixed-price for defined tasks.** You know the cost upfront. Good for both sides.
- **Hourly for exploration or ongoing work.** When scope is unclear, hourly is fairer.
- **Milestone payments for large projects.** Pay 30% upfront, 30% at midpoint, 40% on completion.
- **Never pay 100% upfront.** And never ask for 100% completion before any payment.

---

## Protecting Yourself

### For Any Engagement

- **Written agreement** — Even informal. Email confirmation of scope, rate, and timeline counts.
- **Code in your repo** — They push to your GitHub repo. You always have the code.
- **Small increments** — Weekly deliverables, not a big bang after 2 months.
- **Code reviews** — Ask Claude Code to review their work periodically.

### For Larger Engagements

- **Freelancer contract** — Cover IP assignment, confidentiality, payment terms, termination
- **NDA** — If they'll see sensitive business information
- **Use Upwork/Toptal for payment** — Built-in dispute resolution if things go wrong

**Tell AI:**
```
Write a simple freelancer agreement for a contractor building
[describe the work] for my SaaS product. Include: scope of work,
payment terms, IP assignment, confidentiality, and termination clause.
Keep it short and founder-friendly.
```

---

## The Fractional CTO Option

If you're growing and need ongoing technical leadership but aren't ready for a full-time CTO:

### What a Fractional CTO Does

- Reviews architecture decisions (should we use X or Y?)
- Code reviews contractor work
- Helps you hire and manage developers
- On-call for production emergencies
- 5-10 hours per month

### When You Need One

- You have 2+ contractors and need someone to coordinate them
- You're making architectural decisions that will be expensive to reverse
- You're about to raise funding and need technical credibility
- You're growing past what you can manage alone technically

### Cost

$3,000-8,000/month for 5-15 hours. Expensive but prevents much more expensive mistakes.

---

## Common Mistakes

| Mistake | Fix |
|---------|-----|
| Hiring before trying AI tools | AI handles 70-80% of what non-technical founders need. Try it first |
| Hiring based on lowest bid | Cheap developers cost more in total. Budget for mid-range minimum |
| No written scope | Leads to scope creep and disputes. Write it down before starting |
| Giving full admin access immediately | Start with repo collaborator access. Expand as trust builds |
| No paid trial | One small paid task reveals more than five interviews |
| Paying 100% upfront | Milestone payments protect both sides |
| Not reviewing their code | Ask AI to review it. You don't need to read code to check quality |
| Hiring full-time too early | Contractors first. Hire full-time when you have consistent work for 40 hrs/week |

---

## Success Looks Like

- You have a reliable contractor you can call on for tasks AI can't handle
- Clear briefs that get accurate estimates and good results
- Code is always in your repo — you're never dependent on one person
- You know the difference between "I should hire for this" and "AI can handle this"
- Your technical costs are predictable and within budget

---

## Related Skills

- **build** — Use AI tools yourself before deciding to hire
- **plan** — Write specs that contractors can estimate and build from
- **debug** — Diagnose issues yourself before escalating to a developer
- **secure** — Security requirements to include in contractor briefs