Processize

---
name: processize
description: >
  Turn a product idea into a repeatable manual process you can start delivering today.
  Use to design manual-first products before writing any code.
compatibility:
  models: [any-llm]
  use-case: product-development
  frameworks: [minimalist-entrepreneur, manual-first]
---

# Processize

Design and validate a product by delivering it manually first. Only productize what you've proven works.

## Use This Skill When

- User has a product idea and wants to validate it manually
- User wants to understand how to deliver value without building software
- User is figuring out the step-by-step process of their product
- User says phrases like "how do I deliver this", "manual process", "before I code", "validation"

## When NOT to Use

- User is ready to build the actual software product (use MVP skill)
- User is designing the product user experience (use product-design skill)
- User is researching market fit for an idea (use validate-idea skill)

## Context: Processization Maturity

**Idea phase**: Concept only, not validated  
**Manual phase**: Founder delivering service by hand; repeatable process documented  
**Processized phase**: Another person could follow your process; consistent output → **Target**  
**Productized phase**: Customers self-serve; automated workflows; founder not involved

## Core Principle

**Processize before you productize.** Every great product started as someone doing the work manually. Gumroad began with Sahil manually collecting PayPal emails and sending payments one by one. Your job right now is to prove you can deliver value to real people by hand before writing a single line of code.

## Instructions

### Step 1: Strip Down the Idea to One Thing

Help the user articulate their product idea in the simplest terms:

**Questions to ask**:
- **One thing**: What is the single transformation you deliver? (Not a feature list; a before → after)
- **Customer starts with**: What's their situation before using your service?
- **Customer ends with**: What's their situation after?
- **No tech version**: If you only had a phone, email, and spreadsheet, how would you deliver this?
- **Weekend test**: Can you build and deliver this in 2 days? If not, too big.

**Example transformation**:
- Before: "I have a list of blog topics; I'm paralyzed about which to write first"
- After: "I have a prioritized, researched outline; I'm confident about my first post"
- Service: "Blog outline writing (manual research + formatting)"

### Step 2: Identify Your Initial Customers

**Critical step**: You need real people ready to pay, not hypothetical customers.

**Questions**:
- What community has this problem right now?
- Who is using a workaround or manual process?
- Where do these people gather? (Reddit, Slack, Discord, forums, local groups, Twitter)
- Can you name 10 specific people facing this problem?

**If you can't name 10 people**: You don't know your target community well enough. Return to the find-community skill first.

**Target**: Identify 3–5 people from your community you can reach out to this week.

### Step 3: Design the Manual Process

This is the core of processizing. Walk through exactly how you'd deliver the product's value by hand. Be extremely specific.

#### Process Documentation Template

**Trigger**: What kicks off the service?
```
Customer emails request with X information
- OR -
Customer fills out form with Y details
```

**Steps** (numbered, specific):
```
1. Receive request email
2. Extract key information (copy to spreadsheet row X)
3. Research X using [tools]
4. Create outline in [tool/format]
5. Review against checklist (5 min per item)
6. Format final deliverable (PDF, Notion, Google Doc)
7. Send to customer with summary email
```

**Tools used per step**:
```
Step 1–2: Email client
Step 3: Google, research tools, note-taking
Step 4: Google Docs
Step 5: Checklist template
Step 6–7: Email
```

**Time breakdown**:
```
Research: 15–30 min per customer
Outline creation: 20–45 min per customer
Review: 5–10 min per customer
Formatting + sending: 5 min per customer
Total: 45–90 min per customer
```

**Deliverable**: What the customer receives
```
1-page outline document + prioritized research notes
Delivered as: PDF
Sent via: Email + Dropbox link
```

**Quality check**: What makes it good?
```
- Outline has 3–5 main sections
- Research notes include 2+ sources per section
- Formatting is clean and scannable
```

#### The "Magic Piece of Paper"

Document your process so clearly that someone else could do it:

```
BLOG OUTLINE SERVICE - PROCESS MANUAL

TRIGGER: Customer request via [contact form]

INPUTS: Customer provides
- Blog topic
- Target audience (1-2 sentences)
- Any competitor articles they want to avoid copying
- Preferred format (outline vs. narrative)

PROCESS:
1. [Step 1 with exact instructions]
2. [Step 2 with exact instructions]
...
10. Send completed outline to customer

OUTPUTS: Deliverable
- 1-page outline (Google Doc)
- Research notes (Markdown)
- Time: 60 minutes per order

SUCCESS CRITERIA:
- Outline is actionable for writer
- Research is from authoritative sources
- Document is formatted, clean, scannable
```

### Step 4: Set Initial Pricing

**Pricing formula**: Time × Hourly rate + Value factor

```
Time per customer: 60 minutes
Your hourly rate (what you'd like): $50/hour
Base price: 1 hour × $50 = $50

Value check: Is $50 worth it to them?
- Saves them 3 hours of research = $150 value at their rate
- Yes, $50 is good

Initial price: $50 per order
```

**Rule**: Charge something, even if modest. Proves value and creates customer commitment.

### Step 5: Deliver to 3 Customers This Week

**Action steps**:
1. Find 3 people from your community with the problem
2. Reach out personally (not bulk email)
3. Offer: "I'm testing a service: [description]. Would you like me to do this for you? Price: $X"
4. Deliver manually (use your magic piece of paper)
5. Collect feedback: "What worked? What would improve this?"

**What you'll learn**:
- How long does it *actually* take? (Document it)
- What questions do customers ask repeatedly?
- What part takes longest?
- What part is most valuable to them?

### Step 6: Validate Before Productizing

**Keep delivering manually until**:
- ✓ 10+ customers have paid for the service
- ✓ Your process hasn't changed in 2+ weeks (stable)
- ✓ You can predict what customers will ask/need
- ✓ You're spending 80%+ of time on delivery (not selling)
- ✓ The most-painful step is clearly identifiable

**Then**: Automate only the slowest step (not the whole thing).

### Step 7: What to Automate First

**Priority order**:
1. **The slowest step** (saves you most time)
2. **The most repetitive step** (most error-prone if manual)
3. **The easiest to automate** (quick wins build momentum)

**Examples**:
- Intake form (replace email inbox) → Typeform + Zapier
- Research step (currently manual web searches) → AI research tools or templates
- Formatting (currently manual document creation) → Template in Google Docs
- Delivery (currently manual email) → Zapier → Automated email

**Don't automate**: The creative/thinking step. Keep that manual as long as possible.

## Output

For each processize project, create:

1. **Product definition** (one sentence: what transformation do you deliver?)

2. **Magic piece of paper**:
   - Trigger (what starts the process)
   - Step-by-step process (numbered, specific)
   - Tools needed at each step
   - Time per customer (breakdown by step)
   - Deliverable (what customer gets)
   - Quality checklist

3. **Target customers**:
   - Community they belong to
   - 3–5 specific people to reach out to this week
   - Where they gather

4. **Pricing**:
   - Time per customer
   - Hourly rate used
   - Final price with justification

5. **Validation plan**:
   - How you'll reach first 3 customers
   - How you'll collect feedback
   - Success metrics for "manual is working"

6. **Future productization** (not now, but plan for it):
   - Most painful/slowest step to automate first
   - How it might be automated (tools, workflows, code)
   - Timeline (only after 10+ manual customers)